Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

tokenwrapped

package

Go to main page

Versions in this module

v0

v0.0.1

Dec 19, 2024

Changes in this version

+ var TokenwrappedABI = TokenwrappedMetaData.ABI

+ var TokenwrappedBin = TokenwrappedMetaData.Bin

+ var TokenwrappedMetaData = &bind.MetaData

+ type Tokenwrapped struct

+ func DeployTokenwrapped(auth *bind.TransactOpts, backend bind.ContractBackend, name string, ...) (common.Address, *types.Transaction, *Tokenwrapped, error)

+ func NewTokenwrapped(address common.Address, backend bind.ContractBackend) (*Tokenwrapped, error)

+ type TokenwrappedApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type TokenwrappedApprovalIterator struct

+ Event *TokenwrappedApproval

+ func (it *TokenwrappedApprovalIterator) Close() error

+ func (it *TokenwrappedApprovalIterator) Error() error

+ func (it *TokenwrappedApprovalIterator) Next() bool

+ type TokenwrappedCaller struct

+ func NewTokenwrappedCaller(address common.Address, caller bind.ContractCaller) (*TokenwrappedCaller, error)

+ func (_Tokenwrapped *TokenwrappedCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error)

+ func (_Tokenwrapped *TokenwrappedCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error)

+ func (_Tokenwrapped *TokenwrappedCaller) BridgeAddress(opts *bind.CallOpts) (common.Address, error)

+ func (_Tokenwrapped *TokenwrappedCaller) DOMAINSEPARATOR(opts *bind.CallOpts) ([32]byte, error)

+ func (_Tokenwrapped *TokenwrappedCaller) DOMAINTYPEHASH(opts *bind.CallOpts) ([32]byte, error)

+ func (_Tokenwrapped *TokenwrappedCaller) Decimals(opts *bind.CallOpts) (uint8, error)

+ func (_Tokenwrapped *TokenwrappedCaller) DeploymentChainId(opts *bind.CallOpts) (*big.Int, error)

+ func (_Tokenwrapped *TokenwrappedCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_Tokenwrapped *TokenwrappedCaller) Nonces(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_Tokenwrapped *TokenwrappedCaller) PERMITTYPEHASH(opts *bind.CallOpts) ([32]byte, error)

+ func (_Tokenwrapped *TokenwrappedCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_Tokenwrapped *TokenwrappedCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ func (_Tokenwrapped *TokenwrappedCaller) VERSION(opts *bind.CallOpts) (string, error)

+ type TokenwrappedCallerRaw struct

+ Contract *TokenwrappedCaller

+ func (_Tokenwrapped *TokenwrappedCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type TokenwrappedCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *TokenwrappedCaller

+ func (_Tokenwrapped *TokenwrappedCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_Tokenwrapped *TokenwrappedCallerSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_Tokenwrapped *TokenwrappedCallerSession) BridgeAddress() (common.Address, error)

+ func (_Tokenwrapped *TokenwrappedCallerSession) DOMAINSEPARATOR() ([32]byte, error)

+ func (_Tokenwrapped *TokenwrappedCallerSession) DOMAINTYPEHASH() ([32]byte, error)

+ func (_Tokenwrapped *TokenwrappedCallerSession) Decimals() (uint8, error)

+ func (_Tokenwrapped *TokenwrappedCallerSession) DeploymentChainId() (*big.Int, error)

+ func (_Tokenwrapped *TokenwrappedCallerSession) Name() (string, error)

+ func (_Tokenwrapped *TokenwrappedCallerSession) Nonces(arg0 common.Address) (*big.Int, error)

+ func (_Tokenwrapped *TokenwrappedCallerSession) PERMITTYPEHASH() ([32]byte, error)

+ func (_Tokenwrapped *TokenwrappedCallerSession) Symbol() (string, error)

+ func (_Tokenwrapped *TokenwrappedCallerSession) TotalSupply() (*big.Int, error)

+ func (_Tokenwrapped *TokenwrappedCallerSession) VERSION() (string, error)

+ type TokenwrappedFilterer struct

+ func NewTokenwrappedFilterer(address common.Address, filterer bind.ContractFilterer) (*TokenwrappedFilterer, error)

+ func (_Tokenwrapped *TokenwrappedFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*TokenwrappedApprovalIterator, error)

+ func (_Tokenwrapped *TokenwrappedFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*TokenwrappedTransferIterator, error)

+ func (_Tokenwrapped *TokenwrappedFilterer) ParseApproval(log types.Log) (*TokenwrappedApproval, error)

+ func (_Tokenwrapped *TokenwrappedFilterer) ParseTransfer(log types.Log) (*TokenwrappedTransfer, error)

+ func (_Tokenwrapped *TokenwrappedFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *TokenwrappedApproval, ...) (event.Subscription, error)

+ func (_Tokenwrapped *TokenwrappedFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *TokenwrappedTransfer, from []common.Address, ...) (event.Subscription, error)

+ type TokenwrappedRaw struct

+ Contract *Tokenwrapped

+ func (_Tokenwrapped *TokenwrappedRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_Tokenwrapped *TokenwrappedRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type TokenwrappedSession struct

+ CallOpts bind.CallOpts

+ Contract *Tokenwrapped

+ TransactOpts bind.TransactOpts

+ func (_Tokenwrapped *TokenwrappedSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_Tokenwrapped *TokenwrappedSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_Tokenwrapped *TokenwrappedSession) BridgeAddress() (common.Address, error)

+ func (_Tokenwrapped *TokenwrappedSession) Burn(account common.Address, value *big.Int) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedSession) DOMAINSEPARATOR() ([32]byte, error)

+ func (_Tokenwrapped *TokenwrappedSession) DOMAINTYPEHASH() ([32]byte, error)

+ func (_Tokenwrapped *TokenwrappedSession) Decimals() (uint8, error)

+ func (_Tokenwrapped *TokenwrappedSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedSession) DeploymentChainId() (*big.Int, error)

+ func (_Tokenwrapped *TokenwrappedSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedSession) Mint(to common.Address, value *big.Int) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedSession) Name() (string, error)

+ func (_Tokenwrapped *TokenwrappedSession) Nonces(arg0 common.Address) (*big.Int, error)

+ func (_Tokenwrapped *TokenwrappedSession) PERMITTYPEHASH() ([32]byte, error)

+ func (_Tokenwrapped *TokenwrappedSession) Permit(owner common.Address, spender common.Address, value *big.Int, ...) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedSession) Symbol() (string, error)

+ func (_Tokenwrapped *TokenwrappedSession) TotalSupply() (*big.Int, error)

+ func (_Tokenwrapped *TokenwrappedSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedSession) VERSION() (string, error)

+ type TokenwrappedTransactor struct

+ func NewTokenwrappedTransactor(address common.Address, transactor bind.ContractTransactor) (*TokenwrappedTransactor, error)

+ func (_Tokenwrapped *TokenwrappedTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedTransactor) Burn(opts *bind.TransactOpts, account common.Address, value *big.Int) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedTransactor) Mint(opts *bind.TransactOpts, to common.Address, value *big.Int) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedTransactor) Permit(opts *bind.TransactOpts, owner common.Address, spender common.Address, ...) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedTransactor) Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ type TokenwrappedTransactorRaw struct

+ Contract *TokenwrappedTransactor

+ func (_Tokenwrapped *TokenwrappedTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type TokenwrappedTransactorSession struct

+ Contract *TokenwrappedTransactor

+ TransactOpts bind.TransactOpts

+ func (_Tokenwrapped *TokenwrappedTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedTransactorSession) Burn(account common.Address, value *big.Int) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedTransactorSession) Mint(to common.Address, value *big.Int) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedTransactorSession) Permit(owner common.Address, spender common.Address, value *big.Int, ...) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedTransactorSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_Tokenwrapped *TokenwrappedTransactorSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error)

+ type TokenwrappedTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type TokenwrappedTransferIterator struct

+ Event *TokenwrappedTransfer

+ func (it *TokenwrappedTransferIterator) Close() error

+ func (it *TokenwrappedTransferIterator) Error() error

+ func (it *TokenwrappedTransferIterator) Next() bool