extbridge

package

Go to main page

Versions in this module

v1

v1.2.0

Oct 21, 2019

Changes in this version

+ const BridgeTokensABI

+ const BridgeTokensBin

+ const BridgeTokensBinRuntime

type BridgeOperatorCaller

+ func (_BridgeOperator *BridgeOperatorCaller) GetOperatorList(opts *bind.CallOpts) ([]common.Address, error)

+ func (_BridgeOperator *BridgeOperatorCaller) OperatorList(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error)

type BridgeOperatorCallerSession

+ func (_BridgeOperator *BridgeOperatorCallerSession) GetOperatorList() ([]common.Address, error)

+ func (_BridgeOperator *BridgeOperatorCallerSession) OperatorList(arg0 *big.Int) (common.Address, error)

type BridgeOperatorSession

+ func (_BridgeOperator *BridgeOperatorSession) GetOperatorList() ([]common.Address, error)

+ func (_BridgeOperator *BridgeOperatorSession) OperatorList(arg0 *big.Int) (common.Address, error)

+ type BridgeTokens struct

+ func DeployBridgeTokens(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *BridgeTokens, error)

+ func NewBridgeTokens(address common.Address, backend bind.ContractBackend) (*BridgeTokens, error)

+ type BridgeTokensCaller struct

+ func NewBridgeTokensCaller(address common.Address, caller bind.ContractCaller) (*BridgeTokensCaller, error)

+ func (_BridgeTokens *BridgeTokensCaller) GetRegisteredTokenList(opts *bind.CallOpts) ([]common.Address, error)

+ func (_BridgeTokens *BridgeTokensCaller) IndexOfTokens(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_BridgeTokens *BridgeTokensCaller) IsOwner(opts *bind.CallOpts) (bool, error)

+ func (_BridgeTokens *BridgeTokensCaller) LockedTokens(opts *bind.CallOpts, arg0 common.Address) (bool, error)

+ func (_BridgeTokens *BridgeTokensCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_BridgeTokens *BridgeTokensCaller) RegisteredTokenList(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error)

+ func (_BridgeTokens *BridgeTokensCaller) RegisteredTokens(opts *bind.CallOpts, arg0 common.Address) (common.Address, error)

+ type BridgeTokensCallerRaw struct

+ Contract *BridgeTokensCaller

+ func (_BridgeTokens *BridgeTokensCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type BridgeTokensCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *BridgeTokensCaller

+ func (_BridgeTokens *BridgeTokensCallerSession) GetRegisteredTokenList() ([]common.Address, error)

+ func (_BridgeTokens *BridgeTokensCallerSession) IndexOfTokens(arg0 common.Address) (*big.Int, error)

+ func (_BridgeTokens *BridgeTokensCallerSession) IsOwner() (bool, error)

+ func (_BridgeTokens *BridgeTokensCallerSession) LockedTokens(arg0 common.Address) (bool, error)

+ func (_BridgeTokens *BridgeTokensCallerSession) Owner() (common.Address, error)

+ func (_BridgeTokens *BridgeTokensCallerSession) RegisteredTokenList(arg0 *big.Int) (common.Address, error)

+ func (_BridgeTokens *BridgeTokensCallerSession) RegisteredTokens(arg0 common.Address) (common.Address, error)

+ type BridgeTokensFilterer struct

+ func NewBridgeTokensFilterer(address common.Address, filterer bind.ContractFilterer) (*BridgeTokensFilterer, error)

+ func (_BridgeTokens *BridgeTokensFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*BridgeTokensOwnershipTransferredIterator, error)

+ func (_BridgeTokens *BridgeTokensFilterer) FilterTokenDeregistered(opts *bind.FilterOpts, token []common.Address) (*BridgeTokensTokenDeregisteredIterator, error)

+ func (_BridgeTokens *BridgeTokensFilterer) FilterTokenLocked(opts *bind.FilterOpts, token []common.Address) (*BridgeTokensTokenLockedIterator, error)

+ func (_BridgeTokens *BridgeTokensFilterer) FilterTokenRegistered(opts *bind.FilterOpts, token []common.Address) (*BridgeTokensTokenRegisteredIterator, error)

+ func (_BridgeTokens *BridgeTokensFilterer) FilterTokenUnlocked(opts *bind.FilterOpts, token []common.Address) (*BridgeTokensTokenUnlockedIterator, error)

+ func (_BridgeTokens *BridgeTokensFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *BridgeTokensOwnershipTransferred, ...) (event.Subscription, error)

+ func (_BridgeTokens *BridgeTokensFilterer) WatchTokenDeregistered(opts *bind.WatchOpts, sink chan<- *BridgeTokensTokenDeregistered, ...) (event.Subscription, error)

+ func (_BridgeTokens *BridgeTokensFilterer) WatchTokenLocked(opts *bind.WatchOpts, sink chan<- *BridgeTokensTokenLocked, ...) (event.Subscription, error)

+ func (_BridgeTokens *BridgeTokensFilterer) WatchTokenRegistered(opts *bind.WatchOpts, sink chan<- *BridgeTokensTokenRegistered, ...) (event.Subscription, error)

+ func (_BridgeTokens *BridgeTokensFilterer) WatchTokenUnlocked(opts *bind.WatchOpts, sink chan<- *BridgeTokensTokenUnlocked, ...) (event.Subscription, error)

+ type BridgeTokensOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type BridgeTokensOwnershipTransferredIterator struct

+ Event *BridgeTokensOwnershipTransferred

+ func (it *BridgeTokensOwnershipTransferredIterator) Close() error

+ func (it *BridgeTokensOwnershipTransferredIterator) Error() error

+ func (it *BridgeTokensOwnershipTransferredIterator) Next() bool

+ type BridgeTokensRaw struct

+ Contract *BridgeTokens

+ func (_BridgeTokens *BridgeTokensRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_BridgeTokens *BridgeTokensRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BridgeTokensSession struct

+ CallOpts bind.CallOpts

+ Contract *BridgeTokens

+ TransactOpts bind.TransactOpts

+ func (_BridgeTokens *BridgeTokensSession) DeregisterToken(_token common.Address) (*types.Transaction, error)

+ func (_BridgeTokens *BridgeTokensSession) GetRegisteredTokenList() ([]common.Address, error)

+ func (_BridgeTokens *BridgeTokensSession) IndexOfTokens(arg0 common.Address) (*big.Int, error)

+ func (_BridgeTokens *BridgeTokensSession) IsOwner() (bool, error)

+ func (_BridgeTokens *BridgeTokensSession) LockToken(_token common.Address) (*types.Transaction, error)

+ func (_BridgeTokens *BridgeTokensSession) LockedTokens(arg0 common.Address) (bool, error)

+ func (_BridgeTokens *BridgeTokensSession) Owner() (common.Address, error)

+ func (_BridgeTokens *BridgeTokensSession) RegisterToken(_token common.Address, _cToken common.Address) (*types.Transaction, error)

+ func (_BridgeTokens *BridgeTokensSession) RegisteredTokenList(arg0 *big.Int) (common.Address, error)

+ func (_BridgeTokens *BridgeTokensSession) RegisteredTokens(arg0 common.Address) (common.Address, error)

+ func (_BridgeTokens *BridgeTokensSession) RenounceOwnership() (*types.Transaction, error)

+ func (_BridgeTokens *BridgeTokensSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_BridgeTokens *BridgeTokensSession) UnlockToken(_token common.Address) (*types.Transaction, error)

+ type BridgeTokensTokenDeregistered struct

+ Raw types.Log

+ Token common.Address

+ type BridgeTokensTokenDeregisteredIterator struct

+ Event *BridgeTokensTokenDeregistered

+ func (it *BridgeTokensTokenDeregisteredIterator) Close() error

+ func (it *BridgeTokensTokenDeregisteredIterator) Error() error

+ func (it *BridgeTokensTokenDeregisteredIterator) Next() bool

+ type BridgeTokensTokenLocked struct

+ Raw types.Log

+ Token common.Address

+ type BridgeTokensTokenLockedIterator struct

+ Event *BridgeTokensTokenLocked

+ func (it *BridgeTokensTokenLockedIterator) Close() error

+ func (it *BridgeTokensTokenLockedIterator) Error() error

+ func (it *BridgeTokensTokenLockedIterator) Next() bool

+ type BridgeTokensTokenRegistered struct

+ Raw types.Log

+ Token common.Address

+ type BridgeTokensTokenRegisteredIterator struct

+ Event *BridgeTokensTokenRegistered

+ func (it *BridgeTokensTokenRegisteredIterator) Close() error

+ func (it *BridgeTokensTokenRegisteredIterator) Error() error

+ func (it *BridgeTokensTokenRegisteredIterator) Next() bool

+ type BridgeTokensTokenUnlocked struct

+ Raw types.Log

+ Token common.Address

+ type BridgeTokensTokenUnlockedIterator struct

+ Event *BridgeTokensTokenUnlocked

+ func (it *BridgeTokensTokenUnlockedIterator) Close() error

+ func (it *BridgeTokensTokenUnlockedIterator) Error() error

+ func (it *BridgeTokensTokenUnlockedIterator) Next() bool

+ type BridgeTokensTransactor struct

+ func NewBridgeTokensTransactor(address common.Address, transactor bind.ContractTransactor) (*BridgeTokensTransactor, error)

+ func (_BridgeTokens *BridgeTokensTransactor) DeregisterToken(opts *bind.TransactOpts, _token common.Address) (*types.Transaction, error)

+ func (_BridgeTokens *BridgeTokensTransactor) LockToken(opts *bind.TransactOpts, _token common.Address) (*types.Transaction, error)

+ func (_BridgeTokens *BridgeTokensTransactor) RegisterToken(opts *bind.TransactOpts, _token common.Address, _cToken common.Address) (*types.Transaction, error)

+ func (_BridgeTokens *BridgeTokensTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_BridgeTokens *BridgeTokensTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ func (_BridgeTokens *BridgeTokensTransactor) UnlockToken(opts *bind.TransactOpts, _token common.Address) (*types.Transaction, error)

+ type BridgeTokensTransactorRaw struct

+ Contract *BridgeTokensTransactor

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

+ func (_BridgeTokens *BridgeTokensTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BridgeTokensTransactorSession struct

+ Contract *BridgeTokensTransactor

+ TransactOpts bind.TransactOpts

+ func (_BridgeTokens *BridgeTokensTransactorSession) DeregisterToken(_token common.Address) (*types.Transaction, error)

+ func (_BridgeTokens *BridgeTokensTransactorSession) LockToken(_token common.Address) (*types.Transaction, error)

+ func (_BridgeTokens *BridgeTokensTransactorSession) RegisterToken(_token common.Address, _cToken common.Address) (*types.Transaction, error)

+ func (_BridgeTokens *BridgeTokensTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_BridgeTokens *BridgeTokensTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_BridgeTokens *BridgeTokensTransactorSession) UnlockToken(_token common.Address) (*types.Transaction, error)

type BridgeTransferCaller

+ func (_BridgeTransfer *BridgeTransferCaller) GetOperatorList(opts *bind.CallOpts) ([]common.Address, error)

+ func (_BridgeTransfer *BridgeTransferCaller) OperatorList(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error)

type BridgeTransferCallerSession

+ func (_BridgeTransfer *BridgeTransferCallerSession) GetOperatorList() ([]common.Address, error)

+ func (_BridgeTransfer *BridgeTransferCallerSession) OperatorList(arg0 *big.Int) (common.Address, error)

type BridgeTransferERC20Caller

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) GetOperatorList(opts *bind.CallOpts) ([]common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) GetRegisteredTokenList(opts *bind.CallOpts) ([]common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) IndexOfTokens(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) LockedTokens(opts *bind.CallOpts, arg0 common.Address) (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) OperatorList(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) RegisteredTokenList(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) RegisteredTokens(opts *bind.CallOpts, arg0 common.Address) (common.Address, error)

type BridgeTransferERC20CallerSession

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) GetOperatorList() ([]common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) GetRegisteredTokenList() ([]common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) IndexOfTokens(arg0 common.Address) (*big.Int, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) LockedTokens(arg0 common.Address) (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) OperatorList(arg0 *big.Int) (common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) RegisteredTokenList(arg0 *big.Int) (common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) RegisteredTokens(arg0 common.Address) (common.Address, error)

type BridgeTransferERC20Filterer

+ func (_BridgeTransferERC20 *BridgeTransferERC20Filterer) FilterTokenDeregistered(opts *bind.FilterOpts, token []common.Address) (*BridgeTransferERC20TokenDeregisteredIterator, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Filterer) FilterTokenLocked(opts *bind.FilterOpts, token []common.Address) (*BridgeTransferERC20TokenLockedIterator, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Filterer) FilterTokenRegistered(opts *bind.FilterOpts, token []common.Address) (*BridgeTransferERC20TokenRegisteredIterator, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Filterer) FilterTokenUnlocked(opts *bind.FilterOpts, token []common.Address) (*BridgeTransferERC20TokenUnlockedIterator, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Filterer) WatchTokenDeregistered(opts *bind.WatchOpts, sink chan<- *BridgeTransferERC20TokenDeregistered, ...) (event.Subscription, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Filterer) WatchTokenLocked(opts *bind.WatchOpts, sink chan<- *BridgeTransferERC20TokenLocked, ...) (event.Subscription, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Filterer) WatchTokenRegistered(opts *bind.WatchOpts, sink chan<- *BridgeTransferERC20TokenRegistered, ...) (event.Subscription, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Filterer) WatchTokenUnlocked(opts *bind.WatchOpts, sink chan<- *BridgeTransferERC20TokenUnlocked, ...) (event.Subscription, error)

type BridgeTransferERC20HandleValueTransfer

+ LowerHandleNonce uint64

type BridgeTransferERC20Session

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) GetOperatorList() ([]common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) GetRegisteredTokenList() ([]common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) IndexOfTokens(arg0 common.Address) (*big.Int, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) LockToken(_token common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) LockedTokens(arg0 common.Address) (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) OperatorList(arg0 *big.Int) (common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) RegisteredTokenList(arg0 *big.Int) (common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) RegisteredTokens(arg0 common.Address) (common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) UnlockToken(_token common.Address) (*types.Transaction, error)

+ type BridgeTransferERC20TokenDeregistered struct

+ Raw types.Log

+ Token common.Address

+ type BridgeTransferERC20TokenDeregisteredIterator struct

+ Event *BridgeTransferERC20TokenDeregistered

+ func (it *BridgeTransferERC20TokenDeregisteredIterator) Close() error

+ func (it *BridgeTransferERC20TokenDeregisteredIterator) Error() error

+ func (it *BridgeTransferERC20TokenDeregisteredIterator) Next() bool

+ type BridgeTransferERC20TokenLocked struct

+ Raw types.Log

+ Token common.Address

+ type BridgeTransferERC20TokenLockedIterator struct

+ Event *BridgeTransferERC20TokenLocked

+ func (it *BridgeTransferERC20TokenLockedIterator) Close() error

+ func (it *BridgeTransferERC20TokenLockedIterator) Error() error

+ func (it *BridgeTransferERC20TokenLockedIterator) Next() bool

+ type BridgeTransferERC20TokenRegistered struct

+ Raw types.Log

+ Token common.Address

+ type BridgeTransferERC20TokenRegisteredIterator struct

+ Event *BridgeTransferERC20TokenRegistered

+ func (it *BridgeTransferERC20TokenRegisteredIterator) Close() error

+ func (it *BridgeTransferERC20TokenRegisteredIterator) Error() error

+ func (it *BridgeTransferERC20TokenRegisteredIterator) Next() bool

+ type BridgeTransferERC20TokenUnlocked struct

+ Raw types.Log

+ Token common.Address

+ type BridgeTransferERC20TokenUnlockedIterator struct

+ Event *BridgeTransferERC20TokenUnlocked

+ func (it *BridgeTransferERC20TokenUnlockedIterator) Close() error

+ func (it *BridgeTransferERC20TokenUnlockedIterator) Error() error

+ func (it *BridgeTransferERC20TokenUnlockedIterator) Next() bool

type BridgeTransferERC20Transactor

+ func (_BridgeTransferERC20 *BridgeTransferERC20Transactor) LockToken(opts *bind.TransactOpts, _token common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Transactor) UnlockToken(opts *bind.TransactOpts, _token common.Address) (*types.Transaction, error)

type BridgeTransferERC20TransactorSession

+ func (_BridgeTransferERC20 *BridgeTransferERC20TransactorSession) LockToken(_token common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20TransactorSession) UnlockToken(_token common.Address) (*types.Transaction, error)

type BridgeTransferERC721Caller

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) GetOperatorList(opts *bind.CallOpts) ([]common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) GetRegisteredTokenList(opts *bind.CallOpts) ([]common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) IndexOfTokens(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) LockedTokens(opts *bind.CallOpts, arg0 common.Address) (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) OperatorList(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) RegisteredTokenList(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) RegisteredTokens(opts *bind.CallOpts, arg0 common.Address) (common.Address, error)

type BridgeTransferERC721CallerSession

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) GetOperatorList() ([]common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) GetRegisteredTokenList() ([]common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) IndexOfTokens(arg0 common.Address) (*big.Int, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) LockedTokens(arg0 common.Address) (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) OperatorList(arg0 *big.Int) (common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) RegisteredTokenList(arg0 *big.Int) (common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) RegisteredTokens(arg0 common.Address) (common.Address, error)

type BridgeTransferERC721Filterer

+ func (_BridgeTransferERC721 *BridgeTransferERC721Filterer) FilterTokenDeregistered(opts *bind.FilterOpts, token []common.Address) (*BridgeTransferERC721TokenDeregisteredIterator, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Filterer) FilterTokenLocked(opts *bind.FilterOpts, token []common.Address) (*BridgeTransferERC721TokenLockedIterator, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Filterer) FilterTokenRegistered(opts *bind.FilterOpts, token []common.Address) (*BridgeTransferERC721TokenRegisteredIterator, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Filterer) FilterTokenUnlocked(opts *bind.FilterOpts, token []common.Address) (*BridgeTransferERC721TokenUnlockedIterator, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Filterer) WatchTokenDeregistered(opts *bind.WatchOpts, sink chan<- *BridgeTransferERC721TokenDeregistered, ...) (event.Subscription, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Filterer) WatchTokenLocked(opts *bind.WatchOpts, sink chan<- *BridgeTransferERC721TokenLocked, ...) (event.Subscription, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Filterer) WatchTokenRegistered(opts *bind.WatchOpts, sink chan<- *BridgeTransferERC721TokenRegistered, ...) (event.Subscription, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Filterer) WatchTokenUnlocked(opts *bind.WatchOpts, sink chan<- *BridgeTransferERC721TokenUnlocked, ...) (event.Subscription, error)

type BridgeTransferERC721HandleValueTransfer

+ LowerHandleNonce uint64

type BridgeTransferERC721Session

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) GetOperatorList() ([]common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) GetRegisteredTokenList() ([]common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) IndexOfTokens(arg0 common.Address) (*big.Int, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) LockToken(_token common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) LockedTokens(arg0 common.Address) (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) OperatorList(arg0 *big.Int) (common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) RegisteredTokenList(arg0 *big.Int) (common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) RegisteredTokens(arg0 common.Address) (common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) UnlockToken(_token common.Address) (*types.Transaction, error)

+ type BridgeTransferERC721TokenDeregistered struct

+ Raw types.Log

+ Token common.Address

+ type BridgeTransferERC721TokenDeregisteredIterator struct

+ Event *BridgeTransferERC721TokenDeregistered

+ func (it *BridgeTransferERC721TokenDeregisteredIterator) Close() error

+ func (it *BridgeTransferERC721TokenDeregisteredIterator) Error() error

+ func (it *BridgeTransferERC721TokenDeregisteredIterator) Next() bool

+ type BridgeTransferERC721TokenLocked struct

+ Raw types.Log

+ Token common.Address

+ type BridgeTransferERC721TokenLockedIterator struct

+ Event *BridgeTransferERC721TokenLocked

+ func (it *BridgeTransferERC721TokenLockedIterator) Close() error

+ func (it *BridgeTransferERC721TokenLockedIterator) Error() error

+ func (it *BridgeTransferERC721TokenLockedIterator) Next() bool

+ type BridgeTransferERC721TokenRegistered struct

+ Raw types.Log

+ Token common.Address

+ type BridgeTransferERC721TokenRegisteredIterator struct

+ Event *BridgeTransferERC721TokenRegistered

+ func (it *BridgeTransferERC721TokenRegisteredIterator) Close() error

+ func (it *BridgeTransferERC721TokenRegisteredIterator) Error() error

+ func (it *BridgeTransferERC721TokenRegisteredIterator) Next() bool

+ type BridgeTransferERC721TokenUnlocked struct

+ Raw types.Log

+ Token common.Address

+ type BridgeTransferERC721TokenUnlockedIterator struct

+ Event *BridgeTransferERC721TokenUnlocked

+ func (it *BridgeTransferERC721TokenUnlockedIterator) Close() error

+ func (it *BridgeTransferERC721TokenUnlockedIterator) Error() error

+ func (it *BridgeTransferERC721TokenUnlockedIterator) Next() bool

type BridgeTransferERC721Transactor

+ func (_BridgeTransferERC721 *BridgeTransferERC721Transactor) LockToken(opts *bind.TransactOpts, _token common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Transactor) UnlockToken(opts *bind.TransactOpts, _token common.Address) (*types.Transaction, error)

type BridgeTransferERC721TransactorSession

+ func (_BridgeTransferERC721 *BridgeTransferERC721TransactorSession) LockToken(_token common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721TransactorSession) UnlockToken(_token common.Address) (*types.Transaction, error)

type BridgeTransferHandleValueTransfer

+ LowerHandleNonce uint64

type BridgeTransferSession

+ func (_BridgeTransfer *BridgeTransferSession) GetOperatorList() ([]common.Address, error)

+ func (_BridgeTransfer *BridgeTransferSession) OperatorList(arg0 *big.Int) (common.Address, error)

type ExtBridgeCaller

+ func (_ExtBridge *ExtBridgeCaller) GetOperatorList(opts *bind.CallOpts) ([]common.Address, error)

+ func (_ExtBridge *ExtBridgeCaller) GetRegisteredTokenList(opts *bind.CallOpts) ([]common.Address, error)

+ func (_ExtBridge *ExtBridgeCaller) IndexOfTokens(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_ExtBridge *ExtBridgeCaller) LockedTokens(opts *bind.CallOpts, arg0 common.Address) (bool, error)

+ func (_ExtBridge *ExtBridgeCaller) OperatorList(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error)

+ func (_ExtBridge *ExtBridgeCaller) RegisteredTokenList(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error)

+ func (_ExtBridge *ExtBridgeCaller) RegisteredTokens(opts *bind.CallOpts, arg0 common.Address) (common.Address, error)

type ExtBridgeCallerSession

+ func (_ExtBridge *ExtBridgeCallerSession) GetOperatorList() ([]common.Address, error)

+ func (_ExtBridge *ExtBridgeCallerSession) GetRegisteredTokenList() ([]common.Address, error)

+ func (_ExtBridge *ExtBridgeCallerSession) IndexOfTokens(arg0 common.Address) (*big.Int, error)

+ func (_ExtBridge *ExtBridgeCallerSession) LockedTokens(arg0 common.Address) (bool, error)

+ func (_ExtBridge *ExtBridgeCallerSession) OperatorList(arg0 *big.Int) (common.Address, error)

+ func (_ExtBridge *ExtBridgeCallerSession) RegisteredTokenList(arg0 *big.Int) (common.Address, error)

+ func (_ExtBridge *ExtBridgeCallerSession) RegisteredTokens(arg0 common.Address) (common.Address, error)

type ExtBridgeFilterer

+ func (_ExtBridge *ExtBridgeFilterer) FilterTokenDeregistered(opts *bind.FilterOpts, token []common.Address) (*ExtBridgeTokenDeregisteredIterator, error)

+ func (_ExtBridge *ExtBridgeFilterer) FilterTokenLocked(opts *bind.FilterOpts, token []common.Address) (*ExtBridgeTokenLockedIterator, error)

+ func (_ExtBridge *ExtBridgeFilterer) FilterTokenRegistered(opts *bind.FilterOpts, token []common.Address) (*ExtBridgeTokenRegisteredIterator, error)

+ func (_ExtBridge *ExtBridgeFilterer) FilterTokenUnlocked(opts *bind.FilterOpts, token []common.Address) (*ExtBridgeTokenUnlockedIterator, error)

+ func (_ExtBridge *ExtBridgeFilterer) WatchTokenDeregistered(opts *bind.WatchOpts, sink chan<- *ExtBridgeTokenDeregistered, ...) (event.Subscription, error)

+ func (_ExtBridge *ExtBridgeFilterer) WatchTokenLocked(opts *bind.WatchOpts, sink chan<- *ExtBridgeTokenLocked, ...) (event.Subscription, error)

+ func (_ExtBridge *ExtBridgeFilterer) WatchTokenRegistered(opts *bind.WatchOpts, sink chan<- *ExtBridgeTokenRegistered, ...) (event.Subscription, error)

+ func (_ExtBridge *ExtBridgeFilterer) WatchTokenUnlocked(opts *bind.WatchOpts, sink chan<- *ExtBridgeTokenUnlocked, ...) (event.Subscription, error)

type ExtBridgeHandleValueTransfer

+ LowerHandleNonce uint64

type ExtBridgeSession

+ func (_ExtBridge *ExtBridgeSession) GetOperatorList() ([]common.Address, error)

+ func (_ExtBridge *ExtBridgeSession) GetRegisteredTokenList() ([]common.Address, error)

+ func (_ExtBridge *ExtBridgeSession) IndexOfTokens(arg0 common.Address) (*big.Int, error)

+ func (_ExtBridge *ExtBridgeSession) LockToken(_token common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeSession) LockedTokens(arg0 common.Address) (bool, error)

+ func (_ExtBridge *ExtBridgeSession) OperatorList(arg0 *big.Int) (common.Address, error)

+ func (_ExtBridge *ExtBridgeSession) RegisteredTokenList(arg0 *big.Int) (common.Address, error)

+ func (_ExtBridge *ExtBridgeSession) RegisteredTokens(arg0 common.Address) (common.Address, error)

+ func (_ExtBridge *ExtBridgeSession) RequestSellERC20(_tokenAddress common.Address, _to common.Address, _value *big.Int, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeSession) RequestSellERC721(_tokenAddress common.Address, _to common.Address, _tokenId *big.Int, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeSession) UnlockToken(_token common.Address) (*types.Transaction, error)

+ type ExtBridgeTokenDeregistered struct

+ Raw types.Log

+ Token common.Address

+ type ExtBridgeTokenDeregisteredIterator struct

+ Event *ExtBridgeTokenDeregistered

+ func (it *ExtBridgeTokenDeregisteredIterator) Close() error

+ func (it *ExtBridgeTokenDeregisteredIterator) Error() error

+ func (it *ExtBridgeTokenDeregisteredIterator) Next() bool

+ type ExtBridgeTokenLocked struct

+ Raw types.Log

+ Token common.Address

+ type ExtBridgeTokenLockedIterator struct

+ Event *ExtBridgeTokenLocked

+ func (it *ExtBridgeTokenLockedIterator) Close() error

+ func (it *ExtBridgeTokenLockedIterator) Error() error

+ func (it *ExtBridgeTokenLockedIterator) Next() bool

+ type ExtBridgeTokenRegistered struct

+ Raw types.Log

+ Token common.Address

+ type ExtBridgeTokenRegisteredIterator struct

+ Event *ExtBridgeTokenRegistered

+ func (it *ExtBridgeTokenRegisteredIterator) Close() error

+ func (it *ExtBridgeTokenRegisteredIterator) Error() error

+ func (it *ExtBridgeTokenRegisteredIterator) Next() bool

+ type ExtBridgeTokenUnlocked struct

+ Raw types.Log

+ Token common.Address

+ type ExtBridgeTokenUnlockedIterator struct

+ Event *ExtBridgeTokenUnlocked

+ func (it *ExtBridgeTokenUnlockedIterator) Close() error

+ func (it *ExtBridgeTokenUnlockedIterator) Error() error

+ func (it *ExtBridgeTokenUnlockedIterator) Next() bool

type ExtBridgeTransactor

+ func (_ExtBridge *ExtBridgeTransactor) LockToken(opts *bind.TransactOpts, _token common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactor) RequestSellERC20(opts *bind.TransactOpts, _tokenAddress common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactor) RequestSellERC721(opts *bind.TransactOpts, _tokenAddress common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactor) UnlockToken(opts *bind.TransactOpts, _token common.Address) (*types.Transaction, error)

type ExtBridgeTransactorSession

+ func (_ExtBridge *ExtBridgeTransactorSession) LockToken(_token common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactorSession) RequestSellERC20(_tokenAddress common.Address, _to common.Address, _value *big.Int, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactorSession) RequestSellERC721(_tokenAddress common.Address, _to common.Address, _tokenId *big.Int, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactorSession) UnlockToken(_token common.Address) (*types.Transaction, error)

v1.2.0-rc.1

Sep 17, 2019

v1.1.1

Aug 21, 2019

Changes in this version

+ const CountersABI

+ const CountersBin

+ const CountersBinRuntime

+ type Counters struct

+ func DeployCounters(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Counters, error)

+ func NewCounters(address common.Address, backend bind.ContractBackend) (*Counters, error)

+ type CountersCaller struct

+ func NewCountersCaller(address common.Address, caller bind.ContractCaller) (*CountersCaller, error)

+ type CountersCallerRaw struct

+ Contract *CountersCaller

+ func (_Counters *CountersCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type CountersCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *CountersCaller

+ type CountersFilterer struct

+ func NewCountersFilterer(address common.Address, filterer bind.ContractFilterer) (*CountersFilterer, error)

+ type CountersRaw struct

+ Contract *Counters

+ func (_Counters *CountersRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_Counters *CountersRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type CountersSession struct

+ CallOpts bind.CallOpts

+ Contract *Counters

+ TransactOpts bind.TransactOpts

+ type CountersTransactor struct

+ func NewCountersTransactor(address common.Address, transactor bind.ContractTransactor) (*CountersTransactor, error)

+ type CountersTransactorRaw struct

+ Contract *CountersTransactor

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

+ func (_Counters *CountersTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type CountersTransactorSession struct

+ Contract *CountersTransactor

+ TransactOpts bind.TransactOpts

v1.1.0

Aug 14, 2019

Changes in this version

+ const AddressABI

+ const AddressBin

+ const AddressBinRuntime

+ const BridgeFeeABI

+ const BridgeFeeBin

+ const BridgeFeeBinRuntime

+ const BridgeHandledRequestsABI

+ const BridgeHandledRequestsBin

+ const BridgeHandledRequestsBinRuntime

+ const BridgeOperatorABI

+ const BridgeOperatorBin

+ const BridgeOperatorBinRuntime

+ const BridgeTransferABI

+ const BridgeTransferBin

+ const BridgeTransferBinRuntime

+ const BridgeTransferERC20ABI

+ const BridgeTransferERC20Bin

+ const BridgeTransferERC20BinRuntime

+ const BridgeTransferERC721ABI

+ const BridgeTransferERC721Bin

+ const BridgeTransferERC721BinRuntime

+ const CallbackABI

+ const CallbackBin

+ const CallbackBinRuntime

+ const ERC165ABI

+ const ERC165Bin

+ const ERC165BinRuntime

+ const ERC20ABI

+ const ERC20Bin

+ const ERC20BinRuntime

+ const ERC20BurnableABI

+ const ERC20BurnableBin

+ const ERC20BurnableBinRuntime

+ const ERC20MintableABI

+ const ERC20MintableBin

+ const ERC20MintableBinRuntime

+ const ERC721ABI

+ const ERC721Bin

+ const ERC721BinRuntime

+ const ERC721BurnableABI

+ const ERC721BurnableBin

+ const ERC721BurnableBinRuntime

+ const ERC721MetadataABI

+ const ERC721MetadataBin

+ const ERC721MetadataBinRuntime

+ const ERC721MetadataMintableABI

+ const ERC721MetadataMintableBin

+ const ERC721MetadataMintableBinRuntime

+ const ExtBridgeABI

+ const ExtBridgeBin

+ const ExtBridgeBinRuntime

+ const IERC165ABI

+ const IERC165Bin

+ const IERC165BinRuntime

+ const IERC20ABI

+ const IERC20Bin

+ const IERC20BinRuntime

+ const IERC20BridgeReceiverABI

+ const IERC20BridgeReceiverBin

+ const IERC20BridgeReceiverBinRuntime

+ const IERC721ABI

+ const IERC721Bin

+ const IERC721BinRuntime

+ const IERC721BridgeReceiverABI

+ const IERC721BridgeReceiverBin

+ const IERC721BridgeReceiverBinRuntime

+ const IERC721MetadataABI

+ const IERC721MetadataBin

+ const IERC721MetadataBinRuntime

+ const IERC721ReceiverABI

+ const IERC721ReceiverBin

+ const IERC721ReceiverBinRuntime

+ const MinterRoleABI

+ const MinterRoleBin

+ const MinterRoleBinRuntime

+ const OwnableABI

+ const OwnableBin

+ const OwnableBinRuntime

+ const RolesABI

+ const RolesBin

+ const RolesBinRuntime

+ const SafeMathABI

+ const SafeMathBin

+ const SafeMathBinRuntime

+ type Address struct

+ func DeployAddress(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Address, error)

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

+ type AddressCaller struct

+ func NewAddressCaller(address common.Address, caller bind.ContractCaller) (*AddressCaller, error)

+ type AddressCallerRaw struct

+ Contract *AddressCaller

+ func (_Address *AddressCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type AddressCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *AddressCaller

+ type AddressFilterer struct

+ func NewAddressFilterer(address common.Address, filterer bind.ContractFilterer) (*AddressFilterer, error)

+ type AddressRaw struct

+ Contract *Address

+ func (_Address *AddressRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_Address *AddressRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AddressSession struct

+ CallOpts bind.CallOpts

+ Contract *Address

+ TransactOpts bind.TransactOpts

+ type AddressTransactor struct

+ func NewAddressTransactor(address common.Address, transactor bind.ContractTransactor) (*AddressTransactor, error)

+ type AddressTransactorRaw struct

+ Contract *AddressTransactor

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

+ func (_Address *AddressTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AddressTransactorSession struct

+ Contract *AddressTransactor

+ TransactOpts bind.TransactOpts

+ type BridgeFee struct

+ func DeployBridgeFee(auth *bind.TransactOpts, backend bind.ContractBackend, ...) (common.Address, *types.Transaction, *BridgeFee, error)

+ func NewBridgeFee(address common.Address, backend bind.ContractBackend) (*BridgeFee, error)

+ type BridgeFeeCaller struct

+ func NewBridgeFeeCaller(address common.Address, caller bind.ContractCaller) (*BridgeFeeCaller, error)

+ func (_BridgeFee *BridgeFeeCaller) FeeOfERC20(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_BridgeFee *BridgeFeeCaller) FeeOfKLAY(opts *bind.CallOpts) (*big.Int, error)

+ func (_BridgeFee *BridgeFeeCaller) FeeReceiver(opts *bind.CallOpts) (common.Address, error)

+ type BridgeFeeCallerRaw struct

+ Contract *BridgeFeeCaller

+ func (_BridgeFee *BridgeFeeCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type BridgeFeeCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *BridgeFeeCaller

+ func (_BridgeFee *BridgeFeeCallerSession) FeeOfERC20(arg0 common.Address) (*big.Int, error)

+ func (_BridgeFee *BridgeFeeCallerSession) FeeOfKLAY() (*big.Int, error)

+ func (_BridgeFee *BridgeFeeCallerSession) FeeReceiver() (common.Address, error)

+ type BridgeFeeERC20FeeChanged struct

+ Fee *big.Int

+ Raw types.Log

+ Token common.Address

+ type BridgeFeeERC20FeeChangedIterator struct

+ Event *BridgeFeeERC20FeeChanged

+ func (it *BridgeFeeERC20FeeChangedIterator) Close() error

+ func (it *BridgeFeeERC20FeeChangedIterator) Error() error

+ func (it *BridgeFeeERC20FeeChangedIterator) Next() bool

+ type BridgeFeeFeeReceiverChanged struct

+ FeeReceiver common.Address

+ Raw types.Log

+ type BridgeFeeFeeReceiverChangedIterator struct

+ Event *BridgeFeeFeeReceiverChanged

+ func (it *BridgeFeeFeeReceiverChangedIterator) Close() error

+ func (it *BridgeFeeFeeReceiverChangedIterator) Error() error

+ func (it *BridgeFeeFeeReceiverChangedIterator) Next() bool

+ type BridgeFeeFilterer struct

+ func NewBridgeFeeFilterer(address common.Address, filterer bind.ContractFilterer) (*BridgeFeeFilterer, error)

+ func (_BridgeFee *BridgeFeeFilterer) FilterERC20FeeChanged(opts *bind.FilterOpts, fee []*big.Int) (*BridgeFeeERC20FeeChangedIterator, error)

+ func (_BridgeFee *BridgeFeeFilterer) FilterFeeReceiverChanged(opts *bind.FilterOpts, feeReceiver []common.Address) (*BridgeFeeFeeReceiverChangedIterator, error)

+ func (_BridgeFee *BridgeFeeFilterer) FilterKLAYFeeChanged(opts *bind.FilterOpts, fee []*big.Int) (*BridgeFeeKLAYFeeChangedIterator, error)

+ func (_BridgeFee *BridgeFeeFilterer) WatchERC20FeeChanged(opts *bind.WatchOpts, sink chan<- *BridgeFeeERC20FeeChanged, fee []*big.Int) (event.Subscription, error)

+ func (_BridgeFee *BridgeFeeFilterer) WatchFeeReceiverChanged(opts *bind.WatchOpts, sink chan<- *BridgeFeeFeeReceiverChanged, ...) (event.Subscription, error)

+ func (_BridgeFee *BridgeFeeFilterer) WatchKLAYFeeChanged(opts *bind.WatchOpts, sink chan<- *BridgeFeeKLAYFeeChanged, fee []*big.Int) (event.Subscription, error)

+ type BridgeFeeKLAYFeeChanged struct

+ Fee *big.Int

+ Raw types.Log

+ type BridgeFeeKLAYFeeChangedIterator struct

+ Event *BridgeFeeKLAYFeeChanged

+ func (it *BridgeFeeKLAYFeeChangedIterator) Close() error

+ func (it *BridgeFeeKLAYFeeChangedIterator) Error() error

+ func (it *BridgeFeeKLAYFeeChangedIterator) Next() bool

+ type BridgeFeeRaw struct

+ Contract *BridgeFee

+ func (_BridgeFee *BridgeFeeRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_BridgeFee *BridgeFeeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BridgeFeeSession struct

+ CallOpts bind.CallOpts

+ Contract *BridgeFee

+ TransactOpts bind.TransactOpts

+ func (_BridgeFee *BridgeFeeSession) FeeOfERC20(arg0 common.Address) (*big.Int, error)

+ func (_BridgeFee *BridgeFeeSession) FeeOfKLAY() (*big.Int, error)

+ func (_BridgeFee *BridgeFeeSession) FeeReceiver() (common.Address, error)

+ type BridgeFeeTransactor struct

+ func NewBridgeFeeTransactor(address common.Address, transactor bind.ContractTransactor) (*BridgeFeeTransactor, error)

+ type BridgeFeeTransactorRaw struct

+ Contract *BridgeFeeTransactor

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

+ func (_BridgeFee *BridgeFeeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BridgeFeeTransactorSession struct

+ Contract *BridgeFeeTransactor

+ TransactOpts bind.TransactOpts

+ type BridgeHandledRequests struct

+ func DeployBridgeHandledRequests(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *BridgeHandledRequests, error)

+ func NewBridgeHandledRequests(address common.Address, backend bind.ContractBackend) (*BridgeHandledRequests, error)

+ type BridgeHandledRequestsCaller struct

+ func NewBridgeHandledRequestsCaller(address common.Address, caller bind.ContractCaller) (*BridgeHandledRequestsCaller, error)

+ func (_BridgeHandledRequests *BridgeHandledRequestsCaller) HandledRequestTx(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ type BridgeHandledRequestsCallerRaw struct

+ Contract *BridgeHandledRequestsCaller

+ func (_BridgeHandledRequests *BridgeHandledRequestsCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type BridgeHandledRequestsCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *BridgeHandledRequestsCaller

+ func (_BridgeHandledRequests *BridgeHandledRequestsCallerSession) HandledRequestTx(arg0 [32]byte) (bool, error)

+ type BridgeHandledRequestsFilterer struct

+ func NewBridgeHandledRequestsFilterer(address common.Address, filterer bind.ContractFilterer) (*BridgeHandledRequestsFilterer, error)

+ type BridgeHandledRequestsRaw struct

+ Contract *BridgeHandledRequests

+ func (_BridgeHandledRequests *BridgeHandledRequestsRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_BridgeHandledRequests *BridgeHandledRequestsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BridgeHandledRequestsSession struct

+ CallOpts bind.CallOpts

+ Contract *BridgeHandledRequests

+ TransactOpts bind.TransactOpts

+ func (_BridgeHandledRequests *BridgeHandledRequestsSession) HandledRequestTx(arg0 [32]byte) (bool, error)

+ type BridgeHandledRequestsTransactor struct

+ func NewBridgeHandledRequestsTransactor(address common.Address, transactor bind.ContractTransactor) (*BridgeHandledRequestsTransactor, error)

+ type BridgeHandledRequestsTransactorRaw struct

+ Contract *BridgeHandledRequestsTransactor

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

+ func (_BridgeHandledRequests *BridgeHandledRequestsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BridgeHandledRequestsTransactorSession struct

+ Contract *BridgeHandledRequestsTransactor

+ TransactOpts bind.TransactOpts

+ type BridgeOperator struct

+ func DeployBridgeOperator(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *BridgeOperator, error)

+ func NewBridgeOperator(address common.Address, backend bind.ContractBackend) (*BridgeOperator, error)

+ type BridgeOperatorCaller struct

+ func NewBridgeOperatorCaller(address common.Address, caller bind.ContractCaller) (*BridgeOperatorCaller, error)

+ func (_BridgeOperator *BridgeOperatorCaller) ClosedValueTransferVotes(opts *bind.CallOpts, arg0 uint64) (bool, error)

+ func (_BridgeOperator *BridgeOperatorCaller) ConfigurationNonce(opts *bind.CallOpts) (uint64, error)

+ func (_BridgeOperator *BridgeOperatorCaller) IsOwner(opts *bind.CallOpts) (bool, error)

+ func (_BridgeOperator *BridgeOperatorCaller) OperatorThresholds(opts *bind.CallOpts, arg0 uint8) (uint8, error)

+ func (_BridgeOperator *BridgeOperatorCaller) Operators(opts *bind.CallOpts, arg0 common.Address) (bool, error)

+ func (_BridgeOperator *BridgeOperatorCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_BridgeOperator *BridgeOperatorCaller) Votes(opts *bind.CallOpts, arg0 [32]byte, arg1 common.Address) (bool, error)

+ func (_BridgeOperator *BridgeOperatorCaller) VotesCounts(opts *bind.CallOpts, arg0 [32]byte) (uint8, error)

+ type BridgeOperatorCallerRaw struct

+ Contract *BridgeOperatorCaller

+ func (_BridgeOperator *BridgeOperatorCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type BridgeOperatorCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *BridgeOperatorCaller

+ func (_BridgeOperator *BridgeOperatorCallerSession) ClosedValueTransferVotes(arg0 uint64) (bool, error)

+ func (_BridgeOperator *BridgeOperatorCallerSession) ConfigurationNonce() (uint64, error)

+ func (_BridgeOperator *BridgeOperatorCallerSession) IsOwner() (bool, error)

+ func (_BridgeOperator *BridgeOperatorCallerSession) OperatorThresholds(arg0 uint8) (uint8, error)

+ func (_BridgeOperator *BridgeOperatorCallerSession) Operators(arg0 common.Address) (bool, error)

+ func (_BridgeOperator *BridgeOperatorCallerSession) Owner() (common.Address, error)

+ func (_BridgeOperator *BridgeOperatorCallerSession) Votes(arg0 [32]byte, arg1 common.Address) (bool, error)

+ func (_BridgeOperator *BridgeOperatorCallerSession) VotesCounts(arg0 [32]byte) (uint8, error)

+ type BridgeOperatorFilterer struct

+ func NewBridgeOperatorFilterer(address common.Address, filterer bind.ContractFilterer) (*BridgeOperatorFilterer, error)

+ func (_BridgeOperator *BridgeOperatorFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*BridgeOperatorOwnershipTransferredIterator, error)

+ func (_BridgeOperator *BridgeOperatorFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *BridgeOperatorOwnershipTransferred, ...) (event.Subscription, error)

+ type BridgeOperatorOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type BridgeOperatorOwnershipTransferredIterator struct

+ Event *BridgeOperatorOwnershipTransferred

+ func (it *BridgeOperatorOwnershipTransferredIterator) Close() error

+ func (it *BridgeOperatorOwnershipTransferredIterator) Error() error

+ func (it *BridgeOperatorOwnershipTransferredIterator) Next() bool

+ type BridgeOperatorRaw struct

+ Contract *BridgeOperator

+ func (_BridgeOperator *BridgeOperatorRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_BridgeOperator *BridgeOperatorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BridgeOperatorSession struct

+ CallOpts bind.CallOpts

+ Contract *BridgeOperator

+ TransactOpts bind.TransactOpts

+ func (_BridgeOperator *BridgeOperatorSession) ClosedValueTransferVotes(arg0 uint64) (bool, error)

+ func (_BridgeOperator *BridgeOperatorSession) ConfigurationNonce() (uint64, error)

+ func (_BridgeOperator *BridgeOperatorSession) DeregisterOperator(_operator common.Address) (*types.Transaction, error)

+ func (_BridgeOperator *BridgeOperatorSession) IsOwner() (bool, error)

+ func (_BridgeOperator *BridgeOperatorSession) OperatorThresholds(arg0 uint8) (uint8, error)

+ func (_BridgeOperator *BridgeOperatorSession) Operators(arg0 common.Address) (bool, error)

+ func (_BridgeOperator *BridgeOperatorSession) Owner() (common.Address, error)

+ func (_BridgeOperator *BridgeOperatorSession) RegisterOperator(_operator common.Address) (*types.Transaction, error)

+ func (_BridgeOperator *BridgeOperatorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_BridgeOperator *BridgeOperatorSession) SetOperatorThreshold(_voteType uint8, _threshold uint8) (*types.Transaction, error)

+ func (_BridgeOperator *BridgeOperatorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_BridgeOperator *BridgeOperatorSession) Votes(arg0 [32]byte, arg1 common.Address) (bool, error)

+ func (_BridgeOperator *BridgeOperatorSession) VotesCounts(arg0 [32]byte) (uint8, error)

+ type BridgeOperatorTransactor struct

+ func NewBridgeOperatorTransactor(address common.Address, transactor bind.ContractTransactor) (*BridgeOperatorTransactor, error)

+ func (_BridgeOperator *BridgeOperatorTransactor) DeregisterOperator(opts *bind.TransactOpts, _operator common.Address) (*types.Transaction, error)

+ func (_BridgeOperator *BridgeOperatorTransactor) RegisterOperator(opts *bind.TransactOpts, _operator common.Address) (*types.Transaction, error)

+ func (_BridgeOperator *BridgeOperatorTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_BridgeOperator *BridgeOperatorTransactor) SetOperatorThreshold(opts *bind.TransactOpts, _voteType uint8, _threshold uint8) (*types.Transaction, error)

+ func (_BridgeOperator *BridgeOperatorTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type BridgeOperatorTransactorRaw struct

+ Contract *BridgeOperatorTransactor

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

+ func (_BridgeOperator *BridgeOperatorTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BridgeOperatorTransactorSession struct

+ Contract *BridgeOperatorTransactor

+ TransactOpts bind.TransactOpts

+ func (_BridgeOperator *BridgeOperatorTransactorSession) DeregisterOperator(_operator common.Address) (*types.Transaction, error)

+ func (_BridgeOperator *BridgeOperatorTransactorSession) RegisterOperator(_operator common.Address) (*types.Transaction, error)

+ func (_BridgeOperator *BridgeOperatorTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_BridgeOperator *BridgeOperatorTransactorSession) SetOperatorThreshold(_voteType uint8, _threshold uint8) (*types.Transaction, error)

+ func (_BridgeOperator *BridgeOperatorTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type BridgeTransfer struct

+ func DeployBridgeTransfer(auth *bind.TransactOpts, backend bind.ContractBackend, _modeMintBurn bool) (common.Address, *types.Transaction, *BridgeTransfer, error)

+ func NewBridgeTransfer(address common.Address, backend bind.ContractBackend) (*BridgeTransfer, error)

+ type BridgeTransferCaller struct

+ func NewBridgeTransferCaller(address common.Address, caller bind.ContractCaller) (*BridgeTransferCaller, error)

+ func (_BridgeTransfer *BridgeTransferCaller) AllowedTokens(opts *bind.CallOpts, arg0 common.Address) (common.Address, error)

+ func (_BridgeTransfer *BridgeTransferCaller) ClosedValueTransferVotes(opts *bind.CallOpts, arg0 uint64) (bool, error)

+ func (_BridgeTransfer *BridgeTransferCaller) ConfigurationNonce(opts *bind.CallOpts) (uint64, error)

+ func (_BridgeTransfer *BridgeTransferCaller) FeeOfERC20(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_BridgeTransfer *BridgeTransferCaller) FeeOfKLAY(opts *bind.CallOpts) (*big.Int, error)

+ func (_BridgeTransfer *BridgeTransferCaller) FeeReceiver(opts *bind.CallOpts) (common.Address, error)

+ func (_BridgeTransfer *BridgeTransferCaller) HandleNoncesToBlockNums(opts *bind.CallOpts, arg0 uint64) (uint64, error)

+ func (_BridgeTransfer *BridgeTransferCaller) HandledRequestTx(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ func (_BridgeTransfer *BridgeTransferCaller) IsOwner(opts *bind.CallOpts) (bool, error)

+ func (_BridgeTransfer *BridgeTransferCaller) IsRunning(opts *bind.CallOpts) (bool, error)

+ func (_BridgeTransfer *BridgeTransferCaller) LowerHandleNonce(opts *bind.CallOpts) (uint64, error)

+ func (_BridgeTransfer *BridgeTransferCaller) ModeMintBurn(opts *bind.CallOpts) (bool, error)

+ func (_BridgeTransfer *BridgeTransferCaller) OperatorThresholds(opts *bind.CallOpts, arg0 uint8) (uint8, error)

+ func (_BridgeTransfer *BridgeTransferCaller) Operators(opts *bind.CallOpts, arg0 common.Address) (bool, error)

+ func (_BridgeTransfer *BridgeTransferCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_BridgeTransfer *BridgeTransferCaller) RecoveryBlockNumber(opts *bind.CallOpts) (uint64, error)

+ func (_BridgeTransfer *BridgeTransferCaller) RequestNonce(opts *bind.CallOpts) (uint64, error)

+ func (_BridgeTransfer *BridgeTransferCaller) UpperHandleNonce(opts *bind.CallOpts) (uint64, error)

+ func (_BridgeTransfer *BridgeTransferCaller) Votes(opts *bind.CallOpts, arg0 [32]byte, arg1 common.Address) (bool, error)

+ func (_BridgeTransfer *BridgeTransferCaller) VotesCounts(opts *bind.CallOpts, arg0 [32]byte) (uint8, error)

+ type BridgeTransferCallerRaw struct

+ Contract *BridgeTransferCaller

+ func (_BridgeTransfer *BridgeTransferCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type BridgeTransferCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *BridgeTransferCaller

+ func (_BridgeTransfer *BridgeTransferCallerSession) AllowedTokens(arg0 common.Address) (common.Address, error)

+ func (_BridgeTransfer *BridgeTransferCallerSession) ClosedValueTransferVotes(arg0 uint64) (bool, error)

+ func (_BridgeTransfer *BridgeTransferCallerSession) ConfigurationNonce() (uint64, error)

+ func (_BridgeTransfer *BridgeTransferCallerSession) FeeOfERC20(arg0 common.Address) (*big.Int, error)

+ func (_BridgeTransfer *BridgeTransferCallerSession) FeeOfKLAY() (*big.Int, error)

+ func (_BridgeTransfer *BridgeTransferCallerSession) FeeReceiver() (common.Address, error)

+ func (_BridgeTransfer *BridgeTransferCallerSession) HandleNoncesToBlockNums(arg0 uint64) (uint64, error)

+ func (_BridgeTransfer *BridgeTransferCallerSession) HandledRequestTx(arg0 [32]byte) (bool, error)

+ func (_BridgeTransfer *BridgeTransferCallerSession) IsOwner() (bool, error)

+ func (_BridgeTransfer *BridgeTransferCallerSession) IsRunning() (bool, error)

+ func (_BridgeTransfer *BridgeTransferCallerSession) LowerHandleNonce() (uint64, error)

+ func (_BridgeTransfer *BridgeTransferCallerSession) ModeMintBurn() (bool, error)

+ func (_BridgeTransfer *BridgeTransferCallerSession) OperatorThresholds(arg0 uint8) (uint8, error)

+ func (_BridgeTransfer *BridgeTransferCallerSession) Operators(arg0 common.Address) (bool, error)

+ func (_BridgeTransfer *BridgeTransferCallerSession) Owner() (common.Address, error)

+ func (_BridgeTransfer *BridgeTransferCallerSession) RecoveryBlockNumber() (uint64, error)

+ func (_BridgeTransfer *BridgeTransferCallerSession) RequestNonce() (uint64, error)

+ func (_BridgeTransfer *BridgeTransferCallerSession) UpperHandleNonce() (uint64, error)

+ func (_BridgeTransfer *BridgeTransferCallerSession) Votes(arg0 [32]byte, arg1 common.Address) (bool, error)

+ func (_BridgeTransfer *BridgeTransferCallerSession) VotesCounts(arg0 [32]byte) (uint8, error)

+ type BridgeTransferERC20 struct

+ func DeployBridgeTransferERC20(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *BridgeTransferERC20, error)

+ func NewBridgeTransferERC20(address common.Address, backend bind.ContractBackend) (*BridgeTransferERC20, error)

+ type BridgeTransferERC20Caller struct

+ func NewBridgeTransferERC20Caller(address common.Address, caller bind.ContractCaller) (*BridgeTransferERC20Caller, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) AllowedTokens(opts *bind.CallOpts, arg0 common.Address) (common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) ClosedValueTransferVotes(opts *bind.CallOpts, arg0 uint64) (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) ConfigurationNonce(opts *bind.CallOpts) (uint64, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) FeeOfERC20(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) FeeOfKLAY(opts *bind.CallOpts) (*big.Int, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) FeeReceiver(opts *bind.CallOpts) (common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) HandleNoncesToBlockNums(opts *bind.CallOpts, arg0 uint64) (uint64, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) HandledRequestTx(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) IsOwner(opts *bind.CallOpts) (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) IsRunning(opts *bind.CallOpts) (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) LowerHandleNonce(opts *bind.CallOpts) (uint64, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) ModeMintBurn(opts *bind.CallOpts) (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) OperatorThresholds(opts *bind.CallOpts, arg0 uint8) (uint8, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) Operators(opts *bind.CallOpts, arg0 common.Address) (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) RecoveryBlockNumber(opts *bind.CallOpts) (uint64, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) RequestNonce(opts *bind.CallOpts) (uint64, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) UpperHandleNonce(opts *bind.CallOpts) (uint64, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) Votes(opts *bind.CallOpts, arg0 [32]byte, arg1 common.Address) (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Caller) VotesCounts(opts *bind.CallOpts, arg0 [32]byte) (uint8, error)

+ type BridgeTransferERC20CallerRaw struct

+ Contract *BridgeTransferERC20Caller

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type BridgeTransferERC20CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *BridgeTransferERC20Caller

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) AllowedTokens(arg0 common.Address) (common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) ClosedValueTransferVotes(arg0 uint64) (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) ConfigurationNonce() (uint64, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) FeeOfERC20(arg0 common.Address) (*big.Int, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) FeeOfKLAY() (*big.Int, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) FeeReceiver() (common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) HandleNoncesToBlockNums(arg0 uint64) (uint64, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) HandledRequestTx(arg0 [32]byte) (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) IsOwner() (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) IsRunning() (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) LowerHandleNonce() (uint64, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) ModeMintBurn() (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) OperatorThresholds(arg0 uint8) (uint8, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) Operators(arg0 common.Address) (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) Owner() (common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) RecoveryBlockNumber() (uint64, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) RequestNonce() (uint64, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) UpperHandleNonce() (uint64, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) Votes(arg0 [32]byte, arg1 common.Address) (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20CallerSession) VotesCounts(arg0 [32]byte) (uint8, error)

+ type BridgeTransferERC20ERC20FeeChanged struct

+ Fee *big.Int

+ Raw types.Log

+ Token common.Address

+ type BridgeTransferERC20ERC20FeeChangedIterator struct

+ Event *BridgeTransferERC20ERC20FeeChanged

+ func (it *BridgeTransferERC20ERC20FeeChangedIterator) Close() error

+ func (it *BridgeTransferERC20ERC20FeeChangedIterator) Error() error

+ func (it *BridgeTransferERC20ERC20FeeChangedIterator) Next() bool

+ type BridgeTransferERC20FeeChanged struct

+ Fee *big.Int

+ Raw types.Log

+ Token common.Address

+ type BridgeTransferERC20FeeChangedIterator struct

+ Event *BridgeTransferERC20FeeChanged

+ func (it *BridgeTransferERC20FeeChangedIterator) Close() error

+ func (it *BridgeTransferERC20FeeChangedIterator) Error() error

+ func (it *BridgeTransferERC20FeeChangedIterator) Next() bool

+ type BridgeTransferERC20FeeReceiverChanged struct

+ FeeReceiver common.Address

+ Raw types.Log

+ type BridgeTransferERC20FeeReceiverChangedIterator struct

+ Event *BridgeTransferERC20FeeReceiverChanged

+ func (it *BridgeTransferERC20FeeReceiverChangedIterator) Close() error

+ func (it *BridgeTransferERC20FeeReceiverChangedIterator) Error() error

+ func (it *BridgeTransferERC20FeeReceiverChangedIterator) Next() bool

+ type BridgeTransferERC20Filterer struct

+ func NewBridgeTransferERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*BridgeTransferERC20Filterer, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Filterer) FilterERC20FeeChanged(opts *bind.FilterOpts, fee []*big.Int) (*BridgeTransferERC20ERC20FeeChangedIterator, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Filterer) FilterFeeReceiverChanged(opts *bind.FilterOpts, feeReceiver []common.Address) (*BridgeTransferERC20FeeReceiverChangedIterator, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Filterer) FilterHandleValueTransfer(opts *bind.FilterOpts) (*BridgeTransferERC20HandleValueTransferIterator, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Filterer) FilterKLAYFeeChanged(opts *bind.FilterOpts, fee []*big.Int) (*BridgeTransferERC20KLAYFeeChangedIterator, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Filterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*BridgeTransferERC20OwnershipTransferredIterator, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Filterer) FilterRequestValueTransfer(opts *bind.FilterOpts) (*BridgeTransferERC20RequestValueTransferIterator, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Filterer) WatchERC20FeeChanged(opts *bind.WatchOpts, sink chan<- *BridgeTransferERC20ERC20FeeChanged, ...) (event.Subscription, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Filterer) WatchFeeReceiverChanged(opts *bind.WatchOpts, sink chan<- *BridgeTransferERC20FeeReceiverChanged, ...) (event.Subscription, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Filterer) WatchHandleValueTransfer(opts *bind.WatchOpts, sink chan<- *BridgeTransferERC20HandleValueTransfer) (event.Subscription, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Filterer) WatchKLAYFeeChanged(opts *bind.WatchOpts, sink chan<- *BridgeTransferERC20KLAYFeeChanged, ...) (event.Subscription, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Filterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *BridgeTransferERC20OwnershipTransferred, ...) (event.Subscription, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Filterer) WatchRequestValueTransfer(opts *bind.WatchOpts, sink chan<- *BridgeTransferERC20RequestValueTransfer) (event.Subscription, error)

+ type BridgeTransferERC20HandleValueTransfer struct

+ ExtraData []*big.Int

+ From common.Address

+ HandleNonce uint64

+ Raw types.Log

+ RequestTxHash [32]byte

+ To common.Address

+ TokenAddress common.Address

+ TokenType uint8

+ ValueOrTokenId *big.Int

+ type BridgeTransferERC20HandleValueTransferIterator struct

+ Event *BridgeTransferERC20HandleValueTransfer

+ func (it *BridgeTransferERC20HandleValueTransferIterator) Close() error

+ func (it *BridgeTransferERC20HandleValueTransferIterator) Error() error

+ func (it *BridgeTransferERC20HandleValueTransferIterator) Next() bool

+ type BridgeTransferERC20KLAYFeeChanged struct

+ Fee *big.Int

+ Raw types.Log

+ type BridgeTransferERC20KLAYFeeChangedIterator struct

+ Event *BridgeTransferERC20KLAYFeeChanged

+ func (it *BridgeTransferERC20KLAYFeeChangedIterator) Close() error

+ func (it *BridgeTransferERC20KLAYFeeChangedIterator) Error() error

+ func (it *BridgeTransferERC20KLAYFeeChangedIterator) Next() bool

+ type BridgeTransferERC20OwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type BridgeTransferERC20OwnershipTransferredIterator struct

+ Event *BridgeTransferERC20OwnershipTransferred

+ func (it *BridgeTransferERC20OwnershipTransferredIterator) Close() error

+ func (it *BridgeTransferERC20OwnershipTransferredIterator) Error() error

+ func (it *BridgeTransferERC20OwnershipTransferredIterator) Next() bool

+ type BridgeTransferERC20Raw struct

+ Contract *BridgeTransferERC20

+ func (_BridgeTransferERC20 *BridgeTransferERC20Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_BridgeTransferERC20 *BridgeTransferERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BridgeTransferERC20RequestValueTransfer struct

+ ExtraData []*big.Int

+ Fee *big.Int

+ From common.Address

+ Raw types.Log

+ RequestNonce uint64

+ To common.Address

+ TokenAddress common.Address

+ TokenType uint8

+ Uri string

+ ValueOrTokenId *big.Int

+ type BridgeTransferERC20RequestValueTransferIterator struct

+ Event *BridgeTransferERC20RequestValueTransfer

+ func (it *BridgeTransferERC20RequestValueTransferIterator) Close() error

+ func (it *BridgeTransferERC20RequestValueTransferIterator) Error() error

+ func (it *BridgeTransferERC20RequestValueTransferIterator) Next() bool

+ type BridgeTransferERC20Session struct

+ CallOpts bind.CallOpts

+ Contract *BridgeTransferERC20

+ TransactOpts bind.TransactOpts

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) AllowedTokens(arg0 common.Address) (common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) ClosedValueTransferVotes(arg0 uint64) (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) ConfigurationNonce() (uint64, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) DeregisterOperator(_operator common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) DeregisterToken(_token common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) FeeOfERC20(arg0 common.Address) (*big.Int, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) FeeOfKLAY() (*big.Int, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) FeeReceiver() (common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) HandleERC20Transfer(_requestTxHash [32]byte, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) HandleNoncesToBlockNums(arg0 uint64) (uint64, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) HandledRequestTx(arg0 [32]byte) (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) IsOwner() (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) IsRunning() (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) LowerHandleNonce() (uint64, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) ModeMintBurn() (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) OnERC20Received(_from common.Address, _to common.Address, _value *big.Int, _feeLimit *big.Int, ...) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) OperatorThresholds(arg0 uint8) (uint8, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) Operators(arg0 common.Address) (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) Owner() (common.Address, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) RecoveryBlockNumber() (uint64, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) RegisterOperator(_operator common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) RegisterToken(_token common.Address, _cToken common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) RenounceOwnership() (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) RequestERC20Transfer(_tokenAddress common.Address, _to common.Address, _value *big.Int, ...) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) RequestNonce() (uint64, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) SetERC20Fee(_token common.Address, _fee *big.Int, _requestNonce uint64) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) SetFeeReceiver(_feeReceiver common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) SetOperatorThreshold(_voteType uint8, _threshold uint8) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) Start(_status bool) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) UpperHandleNonce() (uint64, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) Votes(arg0 [32]byte, arg1 common.Address) (bool, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Session) VotesCounts(arg0 [32]byte) (uint8, error)

+ type BridgeTransferERC20Transactor struct

+ func NewBridgeTransferERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*BridgeTransferERC20Transactor, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Transactor) DeregisterOperator(opts *bind.TransactOpts, _operator common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Transactor) DeregisterToken(opts *bind.TransactOpts, _token common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Transactor) HandleERC20Transfer(opts *bind.TransactOpts, _requestTxHash [32]byte, _from common.Address, ...) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Transactor) OnERC20Received(opts *bind.TransactOpts, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Transactor) RegisterOperator(opts *bind.TransactOpts, _operator common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Transactor) RegisterToken(opts *bind.TransactOpts, _token common.Address, _cToken common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Transactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Transactor) RequestERC20Transfer(opts *bind.TransactOpts, _tokenAddress common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Transactor) SetERC20Fee(opts *bind.TransactOpts, _token common.Address, _fee *big.Int, ...) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Transactor) SetFeeReceiver(opts *bind.TransactOpts, _feeReceiver common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Transactor) SetOperatorThreshold(opts *bind.TransactOpts, _voteType uint8, _threshold uint8) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Transactor) Start(opts *bind.TransactOpts, _status bool) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20Transactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type BridgeTransferERC20TransactorRaw struct

+ Contract *BridgeTransferERC20Transactor

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

+ func (_BridgeTransferERC20 *BridgeTransferERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BridgeTransferERC20TransactorSession struct

+ Contract *BridgeTransferERC20Transactor

+ TransactOpts bind.TransactOpts

+ func (_BridgeTransferERC20 *BridgeTransferERC20TransactorSession) DeregisterOperator(_operator common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20TransactorSession) DeregisterToken(_token common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20TransactorSession) HandleERC20Transfer(_requestTxHash [32]byte, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20TransactorSession) OnERC20Received(_from common.Address, _to common.Address, _value *big.Int, _feeLimit *big.Int, ...) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20TransactorSession) RegisterOperator(_operator common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20TransactorSession) RegisterToken(_token common.Address, _cToken common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20TransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20TransactorSession) RequestERC20Transfer(_tokenAddress common.Address, _to common.Address, _value *big.Int, ...) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20TransactorSession) SetERC20Fee(_token common.Address, _fee *big.Int, _requestNonce uint64) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20TransactorSession) SetFeeReceiver(_feeReceiver common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20TransactorSession) SetOperatorThreshold(_voteType uint8, _threshold uint8) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20TransactorSession) Start(_status bool) (*types.Transaction, error)

+ func (_BridgeTransferERC20 *BridgeTransferERC20TransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type BridgeTransferERC721 struct

+ func DeployBridgeTransferERC721(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *BridgeTransferERC721, error)

+ func NewBridgeTransferERC721(address common.Address, backend bind.ContractBackend) (*BridgeTransferERC721, error)

+ type BridgeTransferERC721Caller struct

+ func NewBridgeTransferERC721Caller(address common.Address, caller bind.ContractCaller) (*BridgeTransferERC721Caller, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) AllowedTokens(opts *bind.CallOpts, arg0 common.Address) (common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) ClosedValueTransferVotes(opts *bind.CallOpts, arg0 uint64) (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) ConfigurationNonce(opts *bind.CallOpts) (uint64, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) FeeOfERC20(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) FeeOfKLAY(opts *bind.CallOpts) (*big.Int, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) FeeReceiver(opts *bind.CallOpts) (common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) HandleNoncesToBlockNums(opts *bind.CallOpts, arg0 uint64) (uint64, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) HandledRequestTx(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) IsOwner(opts *bind.CallOpts) (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) IsRunning(opts *bind.CallOpts) (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) LowerHandleNonce(opts *bind.CallOpts) (uint64, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) ModeMintBurn(opts *bind.CallOpts) (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) OperatorThresholds(opts *bind.CallOpts, arg0 uint8) (uint8, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) Operators(opts *bind.CallOpts, arg0 common.Address) (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) RecoveryBlockNumber(opts *bind.CallOpts) (uint64, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) RequestNonce(opts *bind.CallOpts) (uint64, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) UpperHandleNonce(opts *bind.CallOpts) (uint64, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) Votes(opts *bind.CallOpts, arg0 [32]byte, arg1 common.Address) (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Caller) VotesCounts(opts *bind.CallOpts, arg0 [32]byte) (uint8, error)

+ type BridgeTransferERC721CallerRaw struct

+ Contract *BridgeTransferERC721Caller

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type BridgeTransferERC721CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *BridgeTransferERC721Caller

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) AllowedTokens(arg0 common.Address) (common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) ClosedValueTransferVotes(arg0 uint64) (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) ConfigurationNonce() (uint64, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) FeeOfERC20(arg0 common.Address) (*big.Int, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) FeeOfKLAY() (*big.Int, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) FeeReceiver() (common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) HandleNoncesToBlockNums(arg0 uint64) (uint64, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) HandledRequestTx(arg0 [32]byte) (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) IsOwner() (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) IsRunning() (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) LowerHandleNonce() (uint64, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) ModeMintBurn() (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) OperatorThresholds(arg0 uint8) (uint8, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) Operators(arg0 common.Address) (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) Owner() (common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) RecoveryBlockNumber() (uint64, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) RequestNonce() (uint64, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) UpperHandleNonce() (uint64, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) Votes(arg0 [32]byte, arg1 common.Address) (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721CallerSession) VotesCounts(arg0 [32]byte) (uint8, error)

+ type BridgeTransferERC721ERC20FeeChanged struct

+ Fee *big.Int

+ Raw types.Log

+ Token common.Address

+ type BridgeTransferERC721ERC20FeeChangedIterator struct

+ Event *BridgeTransferERC721ERC20FeeChanged

+ func (it *BridgeTransferERC721ERC20FeeChangedIterator) Close() error

+ func (it *BridgeTransferERC721ERC20FeeChangedIterator) Error() error

+ func (it *BridgeTransferERC721ERC20FeeChangedIterator) Next() bool

+ type BridgeTransferERC721FeeReceiverChanged struct

+ FeeReceiver common.Address

+ Raw types.Log

+ type BridgeTransferERC721FeeReceiverChangedIterator struct

+ Event *BridgeTransferERC721FeeReceiverChanged

+ func (it *BridgeTransferERC721FeeReceiverChangedIterator) Close() error

+ func (it *BridgeTransferERC721FeeReceiverChangedIterator) Error() error

+ func (it *BridgeTransferERC721FeeReceiverChangedIterator) Next() bool

+ type BridgeTransferERC721Filterer struct

+ func NewBridgeTransferERC721Filterer(address common.Address, filterer bind.ContractFilterer) (*BridgeTransferERC721Filterer, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Filterer) FilterERC20FeeChanged(opts *bind.FilterOpts, fee []*big.Int) (*BridgeTransferERC721ERC20FeeChangedIterator, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Filterer) FilterFeeReceiverChanged(opts *bind.FilterOpts, feeReceiver []common.Address) (*BridgeTransferERC721FeeReceiverChangedIterator, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Filterer) FilterHandleValueTransfer(opts *bind.FilterOpts) (*BridgeTransferERC721HandleValueTransferIterator, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Filterer) FilterKLAYFeeChanged(opts *bind.FilterOpts, fee []*big.Int) (*BridgeTransferERC721KLAYFeeChangedIterator, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Filterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*BridgeTransferERC721OwnershipTransferredIterator, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Filterer) FilterRequestValueTransfer(opts *bind.FilterOpts) (*BridgeTransferERC721RequestValueTransferIterator, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Filterer) WatchERC20FeeChanged(opts *bind.WatchOpts, sink chan<- *BridgeTransferERC721ERC20FeeChanged, ...) (event.Subscription, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Filterer) WatchFeeReceiverChanged(opts *bind.WatchOpts, sink chan<- *BridgeTransferERC721FeeReceiverChanged, ...) (event.Subscription, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Filterer) WatchHandleValueTransfer(opts *bind.WatchOpts, sink chan<- *BridgeTransferERC721HandleValueTransfer) (event.Subscription, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Filterer) WatchKLAYFeeChanged(opts *bind.WatchOpts, sink chan<- *BridgeTransferERC721KLAYFeeChanged, ...) (event.Subscription, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Filterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *BridgeTransferERC721OwnershipTransferred, ...) (event.Subscription, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Filterer) WatchRequestValueTransfer(opts *bind.WatchOpts, sink chan<- *BridgeTransferERC721RequestValueTransfer) (event.Subscription, error)

+ type BridgeTransferERC721HandleValueTransfer struct

+ ExtraData []*big.Int

+ From common.Address

+ HandleNonce uint64

+ Raw types.Log

+ RequestTxHash [32]byte

+ To common.Address

+ TokenAddress common.Address

+ TokenType uint8

+ ValueOrTokenId *big.Int

+ type BridgeTransferERC721HandleValueTransferIterator struct

+ Event *BridgeTransferERC721HandleValueTransfer

+ func (it *BridgeTransferERC721HandleValueTransferIterator) Close() error

+ func (it *BridgeTransferERC721HandleValueTransferIterator) Error() error

+ func (it *BridgeTransferERC721HandleValueTransferIterator) Next() bool

+ type BridgeTransferERC721KLAYFeeChanged struct

+ Fee *big.Int

+ Raw types.Log

+ type BridgeTransferERC721KLAYFeeChangedIterator struct

+ Event *BridgeTransferERC721KLAYFeeChanged

+ func (it *BridgeTransferERC721KLAYFeeChangedIterator) Close() error

+ func (it *BridgeTransferERC721KLAYFeeChangedIterator) Error() error

+ func (it *BridgeTransferERC721KLAYFeeChangedIterator) Next() bool

+ type BridgeTransferERC721OwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type BridgeTransferERC721OwnershipTransferredIterator struct

+ Event *BridgeTransferERC721OwnershipTransferred

+ func (it *BridgeTransferERC721OwnershipTransferredIterator) Close() error

+ func (it *BridgeTransferERC721OwnershipTransferredIterator) Error() error

+ func (it *BridgeTransferERC721OwnershipTransferredIterator) Next() bool

+ type BridgeTransferERC721Raw struct

+ Contract *BridgeTransferERC721

+ func (_BridgeTransferERC721 *BridgeTransferERC721Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_BridgeTransferERC721 *BridgeTransferERC721Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BridgeTransferERC721RequestValueTransfer struct

+ ExtraData []*big.Int

+ Fee *big.Int

+ From common.Address

+ Raw types.Log

+ RequestNonce uint64

+ To common.Address

+ TokenAddress common.Address

+ TokenType uint8

+ Uri string

+ ValueOrTokenId *big.Int

+ type BridgeTransferERC721RequestValueTransferIterator struct

+ Event *BridgeTransferERC721RequestValueTransfer

+ func (it *BridgeTransferERC721RequestValueTransferIterator) Close() error

+ func (it *BridgeTransferERC721RequestValueTransferIterator) Error() error

+ func (it *BridgeTransferERC721RequestValueTransferIterator) Next() bool

+ type BridgeTransferERC721Session struct

+ CallOpts bind.CallOpts

+ Contract *BridgeTransferERC721

+ TransactOpts bind.TransactOpts

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) AllowedTokens(arg0 common.Address) (common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) ClosedValueTransferVotes(arg0 uint64) (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) ConfigurationNonce() (uint64, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) DeregisterOperator(_operator common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) DeregisterToken(_token common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) FeeOfERC20(arg0 common.Address) (*big.Int, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) FeeOfKLAY() (*big.Int, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) FeeReceiver() (common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) HandleERC721Transfer(_requestTxHash [32]byte, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) HandleNoncesToBlockNums(arg0 uint64) (uint64, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) HandledRequestTx(arg0 [32]byte) (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) IsOwner() (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) IsRunning() (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) LowerHandleNonce() (uint64, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) ModeMintBurn() (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) OnERC721Received(_from common.Address, _tokenId *big.Int, _to common.Address, ...) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) OperatorThresholds(arg0 uint8) (uint8, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) Operators(arg0 common.Address) (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) Owner() (common.Address, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) RecoveryBlockNumber() (uint64, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) RegisterOperator(_operator common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) RegisterToken(_token common.Address, _cToken common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) RenounceOwnership() (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) RequestERC721Transfer(_tokenAddress common.Address, _to common.Address, _tokenId *big.Int, ...) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) RequestNonce() (uint64, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) SetFeeReceiver(_feeReceiver common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) SetOperatorThreshold(_voteType uint8, _threshold uint8) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) Start(_status bool) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) UpperHandleNonce() (uint64, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) Votes(arg0 [32]byte, arg1 common.Address) (bool, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Session) VotesCounts(arg0 [32]byte) (uint8, error)

+ type BridgeTransferERC721Transactor struct

+ func NewBridgeTransferERC721Transactor(address common.Address, transactor bind.ContractTransactor) (*BridgeTransferERC721Transactor, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Transactor) DeregisterOperator(opts *bind.TransactOpts, _operator common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Transactor) DeregisterToken(opts *bind.TransactOpts, _token common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Transactor) HandleERC721Transfer(opts *bind.TransactOpts, _requestTxHash [32]byte, _from common.Address, ...) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Transactor) OnERC721Received(opts *bind.TransactOpts, _from common.Address, _tokenId *big.Int, ...) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Transactor) RegisterOperator(opts *bind.TransactOpts, _operator common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Transactor) RegisterToken(opts *bind.TransactOpts, _token common.Address, _cToken common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Transactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Transactor) RequestERC721Transfer(opts *bind.TransactOpts, _tokenAddress common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Transactor) SetFeeReceiver(opts *bind.TransactOpts, _feeReceiver common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Transactor) SetOperatorThreshold(opts *bind.TransactOpts, _voteType uint8, _threshold uint8) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Transactor) Start(opts *bind.TransactOpts, _status bool) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721Transactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type BridgeTransferERC721TransactorRaw struct

+ Contract *BridgeTransferERC721Transactor

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

+ func (_BridgeTransferERC721 *BridgeTransferERC721TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BridgeTransferERC721TransactorSession struct

+ Contract *BridgeTransferERC721Transactor

+ TransactOpts bind.TransactOpts

+ func (_BridgeTransferERC721 *BridgeTransferERC721TransactorSession) DeregisterOperator(_operator common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721TransactorSession) DeregisterToken(_token common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721TransactorSession) HandleERC721Transfer(_requestTxHash [32]byte, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721TransactorSession) OnERC721Received(_from common.Address, _tokenId *big.Int, _to common.Address, ...) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721TransactorSession) RegisterOperator(_operator common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721TransactorSession) RegisterToken(_token common.Address, _cToken common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721TransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721TransactorSession) RequestERC721Transfer(_tokenAddress common.Address, _to common.Address, _tokenId *big.Int, ...) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721TransactorSession) SetFeeReceiver(_feeReceiver common.Address) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721TransactorSession) SetOperatorThreshold(_voteType uint8, _threshold uint8) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721TransactorSession) Start(_status bool) (*types.Transaction, error)

+ func (_BridgeTransferERC721 *BridgeTransferERC721TransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type BridgeTransferFeeReceiverChanged struct

+ FeeReceiver common.Address

+ Raw types.Log

+ type BridgeTransferFeeReceiverChangedIterator struct

+ Event *BridgeTransferFeeReceiverChanged

+ func (it *BridgeTransferFeeReceiverChangedIterator) Close() error

+ func (it *BridgeTransferFeeReceiverChangedIterator) Error() error

+ func (it *BridgeTransferFeeReceiverChangedIterator) Next() bool

+ type BridgeTransferFilterer struct

+ func NewBridgeTransferFilterer(address common.Address, filterer bind.ContractFilterer) (*BridgeTransferFilterer, error)

+ func (_BridgeTransfer *BridgeTransferFilterer) FilterERC20FeeChanged(opts *bind.FilterOpts, fee []*big.Int) (*BridgeTransferERC20FeeChangedIterator, error)

+ func (_BridgeTransfer *BridgeTransferFilterer) FilterFeeReceiverChanged(opts *bind.FilterOpts, feeReceiver []common.Address) (*BridgeTransferFeeReceiverChangedIterator, error)

+ func (_BridgeTransfer *BridgeTransferFilterer) FilterHandleValueTransfer(opts *bind.FilterOpts) (*BridgeTransferHandleValueTransferIterator, error)

+ func (_BridgeTransfer *BridgeTransferFilterer) FilterKLAYFeeChanged(opts *bind.FilterOpts, fee []*big.Int) (*BridgeTransferKLAYFeeChangedIterator, error)

+ func (_BridgeTransfer *BridgeTransferFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*BridgeTransferOwnershipTransferredIterator, error)

+ func (_BridgeTransfer *BridgeTransferFilterer) FilterRequestValueTransfer(opts *bind.FilterOpts) (*BridgeTransferRequestValueTransferIterator, error)

+ func (_BridgeTransfer *BridgeTransferFilterer) WatchERC20FeeChanged(opts *bind.WatchOpts, sink chan<- *BridgeTransferERC20FeeChanged, ...) (event.Subscription, error)

+ func (_BridgeTransfer *BridgeTransferFilterer) WatchFeeReceiverChanged(opts *bind.WatchOpts, sink chan<- *BridgeTransferFeeReceiverChanged, ...) (event.Subscription, error)

+ func (_BridgeTransfer *BridgeTransferFilterer) WatchHandleValueTransfer(opts *bind.WatchOpts, sink chan<- *BridgeTransferHandleValueTransfer) (event.Subscription, error)

+ func (_BridgeTransfer *BridgeTransferFilterer) WatchKLAYFeeChanged(opts *bind.WatchOpts, sink chan<- *BridgeTransferKLAYFeeChanged, ...) (event.Subscription, error)

+ func (_BridgeTransfer *BridgeTransferFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *BridgeTransferOwnershipTransferred, ...) (event.Subscription, error)

+ func (_BridgeTransfer *BridgeTransferFilterer) WatchRequestValueTransfer(opts *bind.WatchOpts, sink chan<- *BridgeTransferRequestValueTransfer) (event.Subscription, error)

+ type BridgeTransferHandleValueTransfer struct

+ ExtraData []*big.Int

+ From common.Address

+ HandleNonce uint64

+ Raw types.Log

+ RequestTxHash [32]byte

+ To common.Address

+ TokenAddress common.Address

+ TokenType uint8

+ ValueOrTokenId *big.Int

+ type BridgeTransferHandleValueTransferIterator struct

+ Event *BridgeTransferHandleValueTransfer

+ func (it *BridgeTransferHandleValueTransferIterator) Close() error

+ func (it *BridgeTransferHandleValueTransferIterator) Error() error

+ func (it *BridgeTransferHandleValueTransferIterator) Next() bool

+ type BridgeTransferKLAYFeeChanged struct

+ Fee *big.Int

+ Raw types.Log

+ type BridgeTransferKLAYFeeChangedIterator struct

+ Event *BridgeTransferKLAYFeeChanged

+ func (it *BridgeTransferKLAYFeeChangedIterator) Close() error

+ func (it *BridgeTransferKLAYFeeChangedIterator) Error() error

+ func (it *BridgeTransferKLAYFeeChangedIterator) Next() bool

+ type BridgeTransferOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type BridgeTransferOwnershipTransferredIterator struct

+ Event *BridgeTransferOwnershipTransferred

+ func (it *BridgeTransferOwnershipTransferredIterator) Close() error

+ func (it *BridgeTransferOwnershipTransferredIterator) Error() error

+ func (it *BridgeTransferOwnershipTransferredIterator) Next() bool

+ type BridgeTransferRaw struct

+ Contract *BridgeTransfer

+ func (_BridgeTransfer *BridgeTransferRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_BridgeTransfer *BridgeTransferRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BridgeTransferRequestValueTransfer struct

+ ExtraData []*big.Int

+ Fee *big.Int

+ From common.Address

+ Raw types.Log

+ RequestNonce uint64

+ To common.Address

+ TokenAddress common.Address

+ TokenType uint8

+ Uri string

+ ValueOrTokenId *big.Int

+ type BridgeTransferRequestValueTransferIterator struct

+ Event *BridgeTransferRequestValueTransfer

+ func (it *BridgeTransferRequestValueTransferIterator) Close() error

+ func (it *BridgeTransferRequestValueTransferIterator) Error() error

+ func (it *BridgeTransferRequestValueTransferIterator) Next() bool

+ type BridgeTransferSession struct

+ CallOpts bind.CallOpts

+ Contract *BridgeTransfer

+ TransactOpts bind.TransactOpts

+ func (_BridgeTransfer *BridgeTransferSession) AllowedTokens(arg0 common.Address) (common.Address, error)

+ func (_BridgeTransfer *BridgeTransferSession) ClosedValueTransferVotes(arg0 uint64) (bool, error)

+ func (_BridgeTransfer *BridgeTransferSession) ConfigurationNonce() (uint64, error)

+ func (_BridgeTransfer *BridgeTransferSession) DeregisterOperator(_operator common.Address) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferSession) DeregisterToken(_token common.Address) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferSession) FeeOfERC20(arg0 common.Address) (*big.Int, error)

+ func (_BridgeTransfer *BridgeTransferSession) FeeOfKLAY() (*big.Int, error)

+ func (_BridgeTransfer *BridgeTransferSession) FeeReceiver() (common.Address, error)

+ func (_BridgeTransfer *BridgeTransferSession) HandleNoncesToBlockNums(arg0 uint64) (uint64, error)

+ func (_BridgeTransfer *BridgeTransferSession) HandledRequestTx(arg0 [32]byte) (bool, error)

+ func (_BridgeTransfer *BridgeTransferSession) IsOwner() (bool, error)

+ func (_BridgeTransfer *BridgeTransferSession) IsRunning() (bool, error)

+ func (_BridgeTransfer *BridgeTransferSession) LowerHandleNonce() (uint64, error)

+ func (_BridgeTransfer *BridgeTransferSession) ModeMintBurn() (bool, error)

+ func (_BridgeTransfer *BridgeTransferSession) OperatorThresholds(arg0 uint8) (uint8, error)

+ func (_BridgeTransfer *BridgeTransferSession) Operators(arg0 common.Address) (bool, error)

+ func (_BridgeTransfer *BridgeTransferSession) Owner() (common.Address, error)

+ func (_BridgeTransfer *BridgeTransferSession) RecoveryBlockNumber() (uint64, error)

+ func (_BridgeTransfer *BridgeTransferSession) RegisterOperator(_operator common.Address) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferSession) RegisterToken(_token common.Address, _cToken common.Address) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferSession) RenounceOwnership() (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferSession) RequestNonce() (uint64, error)

+ func (_BridgeTransfer *BridgeTransferSession) SetFeeReceiver(_feeReceiver common.Address) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferSession) SetOperatorThreshold(_voteType uint8, _threshold uint8) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferSession) Start(_status bool) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferSession) UpperHandleNonce() (uint64, error)

+ func (_BridgeTransfer *BridgeTransferSession) Votes(arg0 [32]byte, arg1 common.Address) (bool, error)

+ func (_BridgeTransfer *BridgeTransferSession) VotesCounts(arg0 [32]byte) (uint8, error)

+ type BridgeTransferTransactor struct

+ func NewBridgeTransferTransactor(address common.Address, transactor bind.ContractTransactor) (*BridgeTransferTransactor, error)

+ func (_BridgeTransfer *BridgeTransferTransactor) DeregisterOperator(opts *bind.TransactOpts, _operator common.Address) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferTransactor) DeregisterToken(opts *bind.TransactOpts, _token common.Address) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferTransactor) RegisterOperator(opts *bind.TransactOpts, _operator common.Address) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferTransactor) RegisterToken(opts *bind.TransactOpts, _token common.Address, _cToken common.Address) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferTransactor) SetFeeReceiver(opts *bind.TransactOpts, _feeReceiver common.Address) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferTransactor) SetOperatorThreshold(opts *bind.TransactOpts, _voteType uint8, _threshold uint8) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferTransactor) Start(opts *bind.TransactOpts, _status bool) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type BridgeTransferTransactorRaw struct

+ Contract *BridgeTransferTransactor

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

+ func (_BridgeTransfer *BridgeTransferTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BridgeTransferTransactorSession struct

+ Contract *BridgeTransferTransactor

+ TransactOpts bind.TransactOpts

+ func (_BridgeTransfer *BridgeTransferTransactorSession) DeregisterOperator(_operator common.Address) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferTransactorSession) DeregisterToken(_token common.Address) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferTransactorSession) RegisterOperator(_operator common.Address) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferTransactorSession) RegisterToken(_token common.Address, _cToken common.Address) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferTransactorSession) SetFeeReceiver(_feeReceiver common.Address) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferTransactorSession) SetOperatorThreshold(_voteType uint8, _threshold uint8) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferTransactorSession) Start(_status bool) (*types.Transaction, error)

+ func (_BridgeTransfer *BridgeTransferTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type Callback struct

+ func DeployCallback(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Callback, error)

+ func NewCallback(address common.Address, backend bind.ContractBackend) (*Callback, error)

+ type CallbackCaller struct

+ func NewCallbackCaller(address common.Address, caller bind.ContractCaller) (*CallbackCaller, error)

+ type CallbackCallerRaw struct

+ Contract *CallbackCaller

+ func (_Callback *CallbackCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type CallbackCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *CallbackCaller

+ type CallbackFilterer struct

+ func NewCallbackFilterer(address common.Address, filterer bind.ContractFilterer) (*CallbackFilterer, error)

+ func (_Callback *CallbackFilterer) FilterRegisteredOffer(opts *bind.FilterOpts) (*CallbackRegisteredOfferIterator, error)

+ func (_Callback *CallbackFilterer) WatchRegisteredOffer(opts *bind.WatchOpts, sink chan<- *CallbackRegisteredOffer) (event.Subscription, error)

+ type CallbackRaw struct

+ Contract *Callback

+ func (_Callback *CallbackRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_Callback *CallbackRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type CallbackRegisteredOffer struct

+ Owner common.Address

+ Price *big.Int

+ Raw types.Log

+ TokenAddress common.Address

+ ValueOrID *big.Int

+ type CallbackRegisteredOfferIterator struct

+ Event *CallbackRegisteredOffer

+ func (it *CallbackRegisteredOfferIterator) Close() error

+ func (it *CallbackRegisteredOfferIterator) Error() error

+ func (it *CallbackRegisteredOfferIterator) Next() bool

+ type CallbackSession struct

+ CallOpts bind.CallOpts

+ Contract *Callback

+ TransactOpts bind.TransactOpts

+ func (_Callback *CallbackSession) RegisterOffer(_owner common.Address, _valueOrID *big.Int, _tokenAddress common.Address, ...) (*types.Transaction, error)

+ type CallbackTransactor struct

+ func NewCallbackTransactor(address common.Address, transactor bind.ContractTransactor) (*CallbackTransactor, error)

+ func (_Callback *CallbackTransactor) RegisterOffer(opts *bind.TransactOpts, _owner common.Address, _valueOrID *big.Int, ...) (*types.Transaction, error)

+ type CallbackTransactorRaw struct

+ Contract *CallbackTransactor

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

+ func (_Callback *CallbackTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type CallbackTransactorSession struct

+ Contract *CallbackTransactor

+ TransactOpts bind.TransactOpts

+ func (_Callback *CallbackTransactorSession) RegisterOffer(_owner common.Address, _valueOrID *big.Int, _tokenAddress common.Address, ...) (*types.Transaction, error)

+ type ERC165 struct

+ func DeployERC165(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC165, error)

+ func NewERC165(address common.Address, backend bind.ContractBackend) (*ERC165, error)

+ type ERC165Caller struct

+ func NewERC165Caller(address common.Address, caller bind.ContractCaller) (*ERC165Caller, error)

+ func (_ERC165 *ERC165Caller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ type ERC165CallerRaw struct

+ Contract *ERC165Caller

+ func (_ERC165 *ERC165CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ERC165CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC165Caller

+ func (_ERC165 *ERC165CallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ type ERC165Filterer struct

+ func NewERC165Filterer(address common.Address, filterer bind.ContractFilterer) (*ERC165Filterer, error)

+ type ERC165Raw struct

+ Contract *ERC165

+ func (_ERC165 *ERC165Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_ERC165 *ERC165Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC165Session struct

+ CallOpts bind.CallOpts

+ Contract *ERC165

+ TransactOpts bind.TransactOpts

+ func (_ERC165 *ERC165Session) SupportsInterface(interfaceId [4]byte) (bool, error)

+ type ERC165Transactor struct

+ func NewERC165Transactor(address common.Address, transactor bind.ContractTransactor) (*ERC165Transactor, error)

+ type ERC165TransactorRaw struct

+ Contract *ERC165Transactor

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

+ func (_ERC165 *ERC165TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC165TransactorSession struct

+ Contract *ERC165Transactor

+ TransactOpts bind.TransactOpts

+ type ERC20 struct

+ func DeployERC20(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC20, error)

+ func NewERC20(address common.Address, backend bind.ContractBackend) (*ERC20, error)

+ type ERC20Approval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type ERC20ApprovalIterator struct

+ Event *ERC20Approval

+ func (it *ERC20ApprovalIterator) Close() error

+ func (it *ERC20ApprovalIterator) Error() error

+ func (it *ERC20ApprovalIterator) Next() bool

+ type ERC20Burnable struct

+ func DeployERC20Burnable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC20Burnable, error)

+ func NewERC20Burnable(address common.Address, backend bind.ContractBackend) (*ERC20Burnable, error)

+ type ERC20BurnableApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type ERC20BurnableApprovalIterator struct

+ Event *ERC20BurnableApproval

+ func (it *ERC20BurnableApprovalIterator) Close() error

+ func (it *ERC20BurnableApprovalIterator) Error() error

+ func (it *ERC20BurnableApprovalIterator) Next() bool

+ type ERC20BurnableCaller struct

+ func NewERC20BurnableCaller(address common.Address, caller bind.ContractCaller) (*ERC20BurnableCaller, error)

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

+ func (_ERC20Burnable *ERC20BurnableCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_ERC20Burnable *ERC20BurnableCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type ERC20BurnableCallerRaw struct

+ Contract *ERC20BurnableCaller

+ func (_ERC20Burnable *ERC20BurnableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ERC20BurnableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC20BurnableCaller

+ func (_ERC20Burnable *ERC20BurnableCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_ERC20Burnable *ERC20BurnableCallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC20Burnable *ERC20BurnableCallerSession) TotalSupply() (*big.Int, error)

+ type ERC20BurnableFilterer struct

+ func NewERC20BurnableFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20BurnableFilterer, error)

+ func (_ERC20Burnable *ERC20BurnableFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20BurnableApprovalIterator, error)

+ func (_ERC20Burnable *ERC20BurnableFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20BurnableTransferIterator, error)

+ func (_ERC20Burnable *ERC20BurnableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20BurnableApproval, ...) (event.Subscription, error)

+ func (_ERC20Burnable *ERC20BurnableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20BurnableTransfer, ...) (event.Subscription, error)

+ type ERC20BurnableRaw struct

+ Contract *ERC20Burnable

+ func (_ERC20Burnable *ERC20BurnableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_ERC20Burnable *ERC20BurnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20BurnableSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC20Burnable

+ TransactOpts bind.TransactOpts

+ func (_ERC20Burnable *ERC20BurnableSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_ERC20Burnable *ERC20BurnableSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error)

+ func (_ERC20Burnable *ERC20BurnableSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC20Burnable *ERC20BurnableSession) Burn(value *big.Int) (*types.Transaction, error)

+ func (_ERC20Burnable *ERC20BurnableSession) BurnFrom(from common.Address, value *big.Int) (*types.Transaction, error)

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

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

+ func (_ERC20Burnable *ERC20BurnableSession) TotalSupply() (*big.Int, error)

+ func (_ERC20Burnable *ERC20BurnableSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error)

+ func (_ERC20Burnable *ERC20BurnableSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error)

+ type ERC20BurnableTransactor struct

+ func NewERC20BurnableTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20BurnableTransactor, error)

+ func (_ERC20Burnable *ERC20BurnableTransactor) Approve(opts *bind.TransactOpts, spender common.Address, value *big.Int) (*types.Transaction, error)

+ func (_ERC20Burnable *ERC20BurnableTransactor) Burn(opts *bind.TransactOpts, value *big.Int) (*types.Transaction, error)

+ func (_ERC20Burnable *ERC20BurnableTransactor) BurnFrom(opts *bind.TransactOpts, from common.Address, value *big.Int) (*types.Transaction, error)

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

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

+ func (_ERC20Burnable *ERC20BurnableTransactor) Transfer(opts *bind.TransactOpts, to common.Address, value *big.Int) (*types.Transaction, error)

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

+ type ERC20BurnableTransactorRaw struct

+ Contract *ERC20BurnableTransactor

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

+ func (_ERC20Burnable *ERC20BurnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20BurnableTransactorSession struct

+ Contract *ERC20BurnableTransactor

+ TransactOpts bind.TransactOpts

+ func (_ERC20Burnable *ERC20BurnableTransactorSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error)

+ func (_ERC20Burnable *ERC20BurnableTransactorSession) Burn(value *big.Int) (*types.Transaction, error)

+ func (_ERC20Burnable *ERC20BurnableTransactorSession) BurnFrom(from common.Address, value *big.Int) (*types.Transaction, error)

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

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

+ func (_ERC20Burnable *ERC20BurnableTransactorSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error)

+ func (_ERC20Burnable *ERC20BurnableTransactorSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error)

+ type ERC20BurnableTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type ERC20BurnableTransferIterator struct

+ Event *ERC20BurnableTransfer

+ func (it *ERC20BurnableTransferIterator) Close() error

+ func (it *ERC20BurnableTransferIterator) Error() error

+ func (it *ERC20BurnableTransferIterator) Next() bool

+ type ERC20Caller struct

+ func NewERC20Caller(address common.Address, caller bind.ContractCaller) (*ERC20Caller, error)

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

+ func (_ERC20 *ERC20Caller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type ERC20CallerRaw struct

+ Contract *ERC20Caller

+ func (_ERC20 *ERC20CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ERC20CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC20Caller

+ func (_ERC20 *ERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20CallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20CallerSession) TotalSupply() (*big.Int, error)

+ type ERC20Filterer struct

+ func NewERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*ERC20Filterer, error)

+ func (_ERC20 *ERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20ApprovalIterator, error)

+ func (_ERC20 *ERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20TransferIterator, error)

+ func (_ERC20 *ERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20Approval, owner []common.Address, ...) (event.Subscription, error)

+ func (_ERC20 *ERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20Transfer, from []common.Address, ...) (event.Subscription, error)

+ type ERC20Mintable struct

+ func DeployERC20Mintable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC20Mintable, error)

+ func NewERC20Mintable(address common.Address, backend bind.ContractBackend) (*ERC20Mintable, error)

+ type ERC20MintableApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type ERC20MintableApprovalIterator struct

+ Event *ERC20MintableApproval

+ func (it *ERC20MintableApprovalIterator) Close() error

+ func (it *ERC20MintableApprovalIterator) Error() error

+ func (it *ERC20MintableApprovalIterator) Next() bool

+ type ERC20MintableCaller struct

+ func NewERC20MintableCaller(address common.Address, caller bind.ContractCaller) (*ERC20MintableCaller, error)

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

+ func (_ERC20Mintable *ERC20MintableCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_ERC20Mintable *ERC20MintableCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error)

+ func (_ERC20Mintable *ERC20MintableCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type ERC20MintableCallerRaw struct

+ Contract *ERC20MintableCaller

+ func (_ERC20Mintable *ERC20MintableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ERC20MintableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC20MintableCaller

+ func (_ERC20Mintable *ERC20MintableCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_ERC20Mintable *ERC20MintableCallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC20Mintable *ERC20MintableCallerSession) IsMinter(account common.Address) (bool, error)

+ func (_ERC20Mintable *ERC20MintableCallerSession) TotalSupply() (*big.Int, error)

+ type ERC20MintableFilterer struct

+ func NewERC20MintableFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20MintableFilterer, error)

+ func (_ERC20Mintable *ERC20MintableFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20MintableApprovalIterator, error)

+ func (_ERC20Mintable *ERC20MintableFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*ERC20MintableMinterAddedIterator, error)

+ func (_ERC20Mintable *ERC20MintableFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*ERC20MintableMinterRemovedIterator, error)

+ func (_ERC20Mintable *ERC20MintableFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20MintableTransferIterator, error)

+ func (_ERC20Mintable *ERC20MintableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20MintableApproval, ...) (event.Subscription, error)

+ func (_ERC20Mintable *ERC20MintableFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *ERC20MintableMinterAdded, ...) (event.Subscription, error)

+ func (_ERC20Mintable *ERC20MintableFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *ERC20MintableMinterRemoved, ...) (event.Subscription, error)

+ func (_ERC20Mintable *ERC20MintableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20MintableTransfer, ...) (event.Subscription, error)

+ type ERC20MintableMinterAdded struct

+ Account common.Address

+ Raw types.Log

+ type ERC20MintableMinterAddedIterator struct

+ Event *ERC20MintableMinterAdded

+ func (it *ERC20MintableMinterAddedIterator) Close() error

+ func (it *ERC20MintableMinterAddedIterator) Error() error

+ func (it *ERC20MintableMinterAddedIterator) Next() bool

+ type ERC20MintableMinterRemoved struct

+ Account common.Address

+ Raw types.Log

+ type ERC20MintableMinterRemovedIterator struct

+ Event *ERC20MintableMinterRemoved

+ func (it *ERC20MintableMinterRemovedIterator) Close() error

+ func (it *ERC20MintableMinterRemovedIterator) Error() error

+ func (it *ERC20MintableMinterRemovedIterator) Next() bool

+ type ERC20MintableRaw struct

+ Contract *ERC20Mintable

+ func (_ERC20Mintable *ERC20MintableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_ERC20Mintable *ERC20MintableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20MintableSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC20Mintable

+ TransactOpts bind.TransactOpts

+ func (_ERC20Mintable *ERC20MintableSession) AddMinter(account common.Address) (*types.Transaction, error)

+ func (_ERC20Mintable *ERC20MintableSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_ERC20Mintable *ERC20MintableSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error)

+ func (_ERC20Mintable *ERC20MintableSession) BalanceOf(owner common.Address) (*big.Int, error)

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

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

+ func (_ERC20Mintable *ERC20MintableSession) IsMinter(account common.Address) (bool, error)

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

+ func (_ERC20Mintable *ERC20MintableSession) RenounceMinter() (*types.Transaction, error)

+ func (_ERC20Mintable *ERC20MintableSession) TotalSupply() (*big.Int, error)

+ func (_ERC20Mintable *ERC20MintableSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error)

+ func (_ERC20Mintable *ERC20MintableSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error)

+ type ERC20MintableTransactor struct

+ func NewERC20MintableTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20MintableTransactor, error)

+ func (_ERC20Mintable *ERC20MintableTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error)

+ func (_ERC20Mintable *ERC20MintableTransactor) Approve(opts *bind.TransactOpts, spender common.Address, value *big.Int) (*types.Transaction, error)

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

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

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

+ func (_ERC20Mintable *ERC20MintableTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_ERC20Mintable *ERC20MintableTransactor) Transfer(opts *bind.TransactOpts, to common.Address, value *big.Int) (*types.Transaction, error)

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

+ type ERC20MintableTransactorRaw struct

+ Contract *ERC20MintableTransactor

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

+ func (_ERC20Mintable *ERC20MintableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20MintableTransactorSession struct

+ Contract *ERC20MintableTransactor

+ TransactOpts bind.TransactOpts

+ func (_ERC20Mintable *ERC20MintableTransactorSession) AddMinter(account common.Address) (*types.Transaction, error)

+ func (_ERC20Mintable *ERC20MintableTransactorSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error)

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

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

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

+ func (_ERC20Mintable *ERC20MintableTransactorSession) RenounceMinter() (*types.Transaction, error)

+ func (_ERC20Mintable *ERC20MintableTransactorSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error)

+ func (_ERC20Mintable *ERC20MintableTransactorSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error)

+ type ERC20MintableTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type ERC20MintableTransferIterator struct

+ Event *ERC20MintableTransfer

+ func (it *ERC20MintableTransferIterator) Close() error

+ func (it *ERC20MintableTransferIterator) Error() error

+ func (it *ERC20MintableTransferIterator) Next() bool

+ type ERC20Raw struct

+ Contract *ERC20

+ func (_ERC20 *ERC20Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_ERC20 *ERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20Session struct

+ CallOpts bind.CallOpts

+ Contract *ERC20

+ TransactOpts bind.TransactOpts

+ func (_ERC20 *ERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20Session) Approve(spender common.Address, value *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Session) BalanceOf(owner common.Address) (*big.Int, error)

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

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

+ func (_ERC20 *ERC20Session) TotalSupply() (*big.Int, error)

+ func (_ERC20 *ERC20Session) Transfer(to common.Address, value *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Session) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error)

+ type ERC20Transactor struct

+ func NewERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*ERC20Transactor, error)

+ func (_ERC20 *ERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, value *big.Int) (*types.Transaction, error)

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

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

+ func (_ERC20 *ERC20Transactor) Transfer(opts *bind.TransactOpts, to common.Address, value *big.Int) (*types.Transaction, error)

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

+ type ERC20TransactorRaw struct

+ Contract *ERC20Transactor

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

+ func (_ERC20 *ERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20TransactorSession struct

+ Contract *ERC20Transactor

+ TransactOpts bind.TransactOpts

+ func (_ERC20 *ERC20TransactorSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error)

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

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

+ func (_ERC20 *ERC20TransactorSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20TransactorSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error)

+ type ERC20Transfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type ERC20TransferIterator struct

+ Event *ERC20Transfer

+ func (it *ERC20TransferIterator) Close() error

+ func (it *ERC20TransferIterator) Error() error

+ func (it *ERC20TransferIterator) Next() bool

+ type ERC721 struct

+ func DeployERC721(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC721, error)

+ func NewERC721(address common.Address, backend bind.ContractBackend) (*ERC721, error)

+ type ERC721Approval struct

+ Approved common.Address

+ Owner common.Address

+ Raw types.Log

+ TokenId *big.Int

+ type ERC721ApprovalForAll struct

+ Approved bool

+ Operator common.Address

+ Owner common.Address

+ Raw types.Log

+ type ERC721ApprovalForAllIterator struct

+ Event *ERC721ApprovalForAll

+ func (it *ERC721ApprovalForAllIterator) Close() error

+ func (it *ERC721ApprovalForAllIterator) Error() error

+ func (it *ERC721ApprovalForAllIterator) Next() bool

+ type ERC721ApprovalIterator struct

+ Event *ERC721Approval

+ func (it *ERC721ApprovalIterator) Close() error

+ func (it *ERC721ApprovalIterator) Error() error

+ func (it *ERC721ApprovalIterator) Next() bool

+ type ERC721Burnable struct

+ func DeployERC721Burnable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC721Burnable, error)

+ func NewERC721Burnable(address common.Address, backend bind.ContractBackend) (*ERC721Burnable, error)

+ type ERC721BurnableApproval struct

+ Approved common.Address

+ Owner common.Address

+ Raw types.Log

+ TokenId *big.Int

+ type ERC721BurnableApprovalForAll struct

+ Approved bool

+ Operator common.Address

+ Owner common.Address

+ Raw types.Log

+ type ERC721BurnableApprovalForAllIterator struct

+ Event *ERC721BurnableApprovalForAll

+ func (it *ERC721BurnableApprovalForAllIterator) Close() error

+ func (it *ERC721BurnableApprovalForAllIterator) Error() error

+ func (it *ERC721BurnableApprovalForAllIterator) Next() bool

+ type ERC721BurnableApprovalIterator struct

+ Event *ERC721BurnableApproval

+ func (it *ERC721BurnableApprovalIterator) Close() error

+ func (it *ERC721BurnableApprovalIterator) Error() error

+ func (it *ERC721BurnableApprovalIterator) Next() bool

+ type ERC721BurnableCaller struct

+ func NewERC721BurnableCaller(address common.Address, caller bind.ContractCaller) (*ERC721BurnableCaller, error)

+ func (_ERC721Burnable *ERC721BurnableCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_ERC721Burnable *ERC721BurnableCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721Burnable *ERC721BurnableCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721Burnable *ERC721BurnableCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721Burnable *ERC721BurnableCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ type ERC721BurnableCallerRaw struct

+ Contract *ERC721BurnableCaller

+ func (_ERC721Burnable *ERC721BurnableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ERC721BurnableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC721BurnableCaller

+ func (_ERC721Burnable *ERC721BurnableCallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721Burnable *ERC721BurnableCallerSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Burnable *ERC721BurnableCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721Burnable *ERC721BurnableCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Burnable *ERC721BurnableCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ type ERC721BurnableFilterer struct

+ func NewERC721BurnableFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC721BurnableFilterer, error)

+ func (_ERC721Burnable *ERC721BurnableFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, ...) (*ERC721BurnableApprovalIterator, error)

+ func (_ERC721Burnable *ERC721BurnableFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ERC721BurnableApprovalForAllIterator, error)

+ func (_ERC721Burnable *ERC721BurnableFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, ...) (*ERC721BurnableTransferIterator, error)

+ func (_ERC721Burnable *ERC721BurnableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC721BurnableApproval, ...) (event.Subscription, error)

+ func (_ERC721Burnable *ERC721BurnableFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ERC721BurnableApprovalForAll, ...) (event.Subscription, error)

+ func (_ERC721Burnable *ERC721BurnableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC721BurnableTransfer, ...) (event.Subscription, error)

+ type ERC721BurnableRaw struct

+ Contract *ERC721Burnable

+ func (_ERC721Burnable *ERC721BurnableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_ERC721Burnable *ERC721BurnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721BurnableSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC721Burnable

+ TransactOpts bind.TransactOpts

+ func (_ERC721Burnable *ERC721BurnableSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721Burnable *ERC721BurnableSession) Burn(tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Burnable *ERC721BurnableSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721Burnable *ERC721BurnableSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Burnable *ERC721BurnableSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_ERC721Burnable *ERC721BurnableSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type ERC721BurnableTransactor struct

+ func NewERC721BurnableTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC721BurnableTransactor, error)

+ func (_ERC721Burnable *ERC721BurnableTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableTransactor) Burn(opts *bind.TransactOpts, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableTransactor) SetApprovalForAll(opts *bind.TransactOpts, to common.Address, approved bool) (*types.Transaction, error)

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

+ type ERC721BurnableTransactorRaw struct

+ Contract *ERC721BurnableTransactor

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

+ func (_ERC721Burnable *ERC721BurnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721BurnableTransactorSession struct

+ Contract *ERC721BurnableTransactor

+ TransactOpts bind.TransactOpts

+ func (_ERC721Burnable *ERC721BurnableTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableTransactorSession) Burn(tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableTransactorSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type ERC721BurnableTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ TokenId *big.Int

+ type ERC721BurnableTransferIterator struct

+ Event *ERC721BurnableTransfer

+ func (it *ERC721BurnableTransferIterator) Close() error

+ func (it *ERC721BurnableTransferIterator) Error() error

+ func (it *ERC721BurnableTransferIterator) Next() bool

+ type ERC721Caller struct

+ func NewERC721Caller(address common.Address, caller bind.ContractCaller) (*ERC721Caller, error)

+ func (_ERC721 *ERC721Caller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_ERC721 *ERC721Caller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721 *ERC721Caller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721 *ERC721Caller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721 *ERC721Caller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ type ERC721CallerRaw struct

+ Contract *ERC721Caller

+ func (_ERC721 *ERC721CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ERC721CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC721Caller

+ func (_ERC721 *ERC721CallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721 *ERC721CallerSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721 *ERC721CallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721 *ERC721CallerSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721 *ERC721CallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ type ERC721Filterer struct

+ func NewERC721Filterer(address common.Address, filterer bind.ContractFilterer) (*ERC721Filterer, error)

+ func (_ERC721 *ERC721Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, ...) (*ERC721ApprovalIterator, error)

+ func (_ERC721 *ERC721Filterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ERC721ApprovalForAllIterator, error)

+ func (_ERC721 *ERC721Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, ...) (*ERC721TransferIterator, error)

+ func (_ERC721 *ERC721Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC721Approval, owner []common.Address, ...) (event.Subscription, error)

+ func (_ERC721 *ERC721Filterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ERC721ApprovalForAll, ...) (event.Subscription, error)

+ func (_ERC721 *ERC721Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC721Transfer, from []common.Address, ...) (event.Subscription, error)

+ type ERC721Metadata struct

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

+ func NewERC721Metadata(address common.Address, backend bind.ContractBackend) (*ERC721Metadata, error)

+ type ERC721MetadataApproval struct

+ Approved common.Address

+ Owner common.Address

+ Raw types.Log

+ TokenId *big.Int

+ type ERC721MetadataApprovalForAll struct

+ Approved bool

+ Operator common.Address

+ Owner common.Address

+ Raw types.Log

+ type ERC721MetadataApprovalForAllIterator struct

+ Event *ERC721MetadataApprovalForAll

+ func (it *ERC721MetadataApprovalForAllIterator) Close() error

+ func (it *ERC721MetadataApprovalForAllIterator) Error() error

+ func (it *ERC721MetadataApprovalForAllIterator) Next() bool

+ type ERC721MetadataApprovalIterator struct

+ Event *ERC721MetadataApproval

+ func (it *ERC721MetadataApprovalIterator) Close() error

+ func (it *ERC721MetadataApprovalIterator) Error() error

+ func (it *ERC721MetadataApprovalIterator) Next() bool

+ type ERC721MetadataCaller struct

+ func NewERC721MetadataCaller(address common.Address, caller bind.ContractCaller) (*ERC721MetadataCaller, error)

+ func (_ERC721Metadata *ERC721MetadataCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_ERC721Metadata *ERC721MetadataCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721Metadata *ERC721MetadataCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721Metadata *ERC721MetadataCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_ERC721Metadata *ERC721MetadataCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721Metadata *ERC721MetadataCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ func (_ERC721Metadata *ERC721MetadataCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_ERC721Metadata *ERC721MetadataCaller) TokenURI(opts *bind.CallOpts, tokenId *big.Int) (string, error)

+ type ERC721MetadataCallerRaw struct

+ Contract *ERC721MetadataCaller

+ func (_ERC721Metadata *ERC721MetadataCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ERC721MetadataCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC721MetadataCaller

+ func (_ERC721Metadata *ERC721MetadataCallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721Metadata *ERC721MetadataCallerSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Metadata *ERC721MetadataCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721Metadata *ERC721MetadataCallerSession) Name() (string, error)

+ func (_ERC721Metadata *ERC721MetadataCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Metadata *ERC721MetadataCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_ERC721Metadata *ERC721MetadataCallerSession) Symbol() (string, error)

+ func (_ERC721Metadata *ERC721MetadataCallerSession) TokenURI(tokenId *big.Int) (string, error)

+ type ERC721MetadataFilterer struct

+ func NewERC721MetadataFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC721MetadataFilterer, error)

+ func (_ERC721Metadata *ERC721MetadataFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, ...) (*ERC721MetadataApprovalIterator, error)

+ func (_ERC721Metadata *ERC721MetadataFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ERC721MetadataApprovalForAllIterator, error)

+ func (_ERC721Metadata *ERC721MetadataFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, ...) (*ERC721MetadataTransferIterator, error)

+ func (_ERC721Metadata *ERC721MetadataFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC721MetadataApproval, ...) (event.Subscription, error)

+ func (_ERC721Metadata *ERC721MetadataFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ERC721MetadataApprovalForAll, ...) (event.Subscription, error)

+ func (_ERC721Metadata *ERC721MetadataFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC721MetadataTransfer, ...) (event.Subscription, error)

+ type ERC721MetadataMintable struct

+ func DeployERC721MetadataMintable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC721MetadataMintable, error)

+ func NewERC721MetadataMintable(address common.Address, backend bind.ContractBackend) (*ERC721MetadataMintable, error)

+ type ERC721MetadataMintableApproval struct

+ Approved common.Address

+ Owner common.Address

+ Raw types.Log

+ TokenId *big.Int

+ type ERC721MetadataMintableApprovalForAll struct

+ Approved bool

+ Operator common.Address

+ Owner common.Address

+ Raw types.Log

+ type ERC721MetadataMintableApprovalForAllIterator struct

+ Event *ERC721MetadataMintableApprovalForAll

+ func (it *ERC721MetadataMintableApprovalForAllIterator) Close() error

+ func (it *ERC721MetadataMintableApprovalForAllIterator) Error() error

+ func (it *ERC721MetadataMintableApprovalForAllIterator) Next() bool

+ type ERC721MetadataMintableApprovalIterator struct

+ Event *ERC721MetadataMintableApproval

+ func (it *ERC721MetadataMintableApprovalIterator) Close() error

+ func (it *ERC721MetadataMintableApprovalIterator) Error() error

+ func (it *ERC721MetadataMintableApprovalIterator) Next() bool

+ type ERC721MetadataMintableCaller struct

+ func NewERC721MetadataMintableCaller(address common.Address, caller bind.ContractCaller) (*ERC721MetadataMintableCaller, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCaller) TokenURI(opts *bind.CallOpts, tokenId *big.Int) (string, error)

+ type ERC721MetadataMintableCallerRaw struct

+ Contract *ERC721MetadataMintableCaller

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ERC721MetadataMintableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC721MetadataMintableCaller

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCallerSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCallerSession) IsMinter(account common.Address) (bool, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCallerSession) Name() (string, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCallerSession) Symbol() (string, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCallerSession) TokenURI(tokenId *big.Int) (string, error)

+ type ERC721MetadataMintableFilterer struct

+ func NewERC721MetadataMintableFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC721MetadataMintableFilterer, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, ...) (*ERC721MetadataMintableApprovalIterator, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ERC721MetadataMintableApprovalForAllIterator, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*ERC721MetadataMintableMinterAddedIterator, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*ERC721MetadataMintableMinterRemovedIterator, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, ...) (*ERC721MetadataMintableTransferIterator, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC721MetadataMintableApproval, ...) (event.Subscription, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ERC721MetadataMintableApprovalForAll, ...) (event.Subscription, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *ERC721MetadataMintableMinterAdded, ...) (event.Subscription, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *ERC721MetadataMintableMinterRemoved, ...) (event.Subscription, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC721MetadataMintableTransfer, ...) (event.Subscription, error)

+ type ERC721MetadataMintableMinterAdded struct

+ Account common.Address

+ Raw types.Log

+ type ERC721MetadataMintableMinterAddedIterator struct

+ Event *ERC721MetadataMintableMinterAdded

+ func (it *ERC721MetadataMintableMinterAddedIterator) Close() error

+ func (it *ERC721MetadataMintableMinterAddedIterator) Error() error

+ func (it *ERC721MetadataMintableMinterAddedIterator) Next() bool

+ type ERC721MetadataMintableMinterRemoved struct

+ Account common.Address

+ Raw types.Log

+ type ERC721MetadataMintableMinterRemovedIterator struct

+ Event *ERC721MetadataMintableMinterRemoved

+ func (it *ERC721MetadataMintableMinterRemovedIterator) Close() error

+ func (it *ERC721MetadataMintableMinterRemovedIterator) Error() error

+ func (it *ERC721MetadataMintableMinterRemovedIterator) Next() bool

+ type ERC721MetadataMintableRaw struct

+ Contract *ERC721MetadataMintable

+ func (_ERC721MetadataMintable *ERC721MetadataMintableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_ERC721MetadataMintable *ERC721MetadataMintableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721MetadataMintableSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC721MetadataMintable

+ TransactOpts bind.TransactOpts

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) AddMinter(account common.Address) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) IsMinter(account common.Address) (bool, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) MintWithTokenURI(to common.Address, tokenId *big.Int, tokenURI string) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) Name() (string, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) RenounceMinter() (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) Symbol() (string, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) TokenURI(tokenId *big.Int) (string, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type ERC721MetadataMintableTransactor struct

+ func NewERC721MetadataMintableTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC721MetadataMintableTransactor, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactor) MintWithTokenURI(opts *bind.TransactOpts, to common.Address, tokenId *big.Int, tokenURI string) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactor) SetApprovalForAll(opts *bind.TransactOpts, to common.Address, approved bool) (*types.Transaction, error)

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

+ type ERC721MetadataMintableTransactorRaw struct

+ Contract *ERC721MetadataMintableTransactor

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

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721MetadataMintableTransactorSession struct

+ Contract *ERC721MetadataMintableTransactor

+ TransactOpts bind.TransactOpts

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactorSession) AddMinter(account common.Address) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactorSession) MintWithTokenURI(to common.Address, tokenId *big.Int, tokenURI string) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactorSession) RenounceMinter() (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactorSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type ERC721MetadataMintableTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ TokenId *big.Int

+ type ERC721MetadataMintableTransferIterator struct

+ Event *ERC721MetadataMintableTransfer

+ func (it *ERC721MetadataMintableTransferIterator) Close() error

+ func (it *ERC721MetadataMintableTransferIterator) Error() error

+ func (it *ERC721MetadataMintableTransferIterator) Next() bool

+ type ERC721MetadataRaw struct

+ Contract *ERC721Metadata

+ func (_ERC721Metadata *ERC721MetadataRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_ERC721Metadata *ERC721MetadataRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721MetadataSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC721Metadata

+ TransactOpts bind.TransactOpts

+ func (_ERC721Metadata *ERC721MetadataSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Metadata *ERC721MetadataSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721Metadata *ERC721MetadataSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Metadata *ERC721MetadataSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721Metadata *ERC721MetadataSession) Name() (string, error)

+ func (_ERC721Metadata *ERC721MetadataSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Metadata *ERC721MetadataSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721Metadata *ERC721MetadataSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721Metadata *ERC721MetadataSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_ERC721Metadata *ERC721MetadataSession) Symbol() (string, error)

+ func (_ERC721Metadata *ERC721MetadataSession) TokenURI(tokenId *big.Int) (string, error)

+ func (_ERC721Metadata *ERC721MetadataSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type ERC721MetadataTransactor struct

+ func NewERC721MetadataTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC721MetadataTransactor, error)

+ func (_ERC721Metadata *ERC721MetadataTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Metadata *ERC721MetadataTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_ERC721Metadata *ERC721MetadataTransactor) SetApprovalForAll(opts *bind.TransactOpts, to common.Address, approved bool) (*types.Transaction, error)

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

+ type ERC721MetadataTransactorRaw struct

+ Contract *ERC721MetadataTransactor

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

+ func (_ERC721Metadata *ERC721MetadataTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721MetadataTransactorSession struct

+ Contract *ERC721MetadataTransactor

+ TransactOpts bind.TransactOpts

+ func (_ERC721Metadata *ERC721MetadataTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Metadata *ERC721MetadataTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721Metadata *ERC721MetadataTransactorSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721Metadata *ERC721MetadataTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type ERC721MetadataTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ TokenId *big.Int

+ type ERC721MetadataTransferIterator struct

+ Event *ERC721MetadataTransfer

+ func (it *ERC721MetadataTransferIterator) Close() error

+ func (it *ERC721MetadataTransferIterator) Error() error

+ func (it *ERC721MetadataTransferIterator) Next() bool

+ type ERC721Raw struct

+ Contract *ERC721

+ func (_ERC721 *ERC721Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_ERC721 *ERC721Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721Session struct

+ CallOpts bind.CallOpts

+ Contract *ERC721

+ TransactOpts bind.TransactOpts

+ func (_ERC721 *ERC721Session) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721 *ERC721Session) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721 *ERC721Session) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721 *ERC721Session) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721 *ERC721Session) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721 *ERC721Session) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721 *ERC721Session) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721 *ERC721Session) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_ERC721 *ERC721Session) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type ERC721Transactor struct

+ func NewERC721Transactor(address common.Address, transactor bind.ContractTransactor) (*ERC721Transactor, error)

+ func (_ERC721 *ERC721Transactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721 *ERC721Transactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_ERC721 *ERC721Transactor) SetApprovalForAll(opts *bind.TransactOpts, to common.Address, approved bool) (*types.Transaction, error)

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

+ type ERC721TransactorRaw struct

+ Contract *ERC721Transactor

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

+ func (_ERC721 *ERC721TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721TransactorSession struct

+ Contract *ERC721Transactor

+ TransactOpts bind.TransactOpts

+ func (_ERC721 *ERC721TransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721 *ERC721TransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721 *ERC721TransactorSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721 *ERC721TransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type ERC721Transfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ TokenId *big.Int

+ type ERC721TransferIterator struct

+ Event *ERC721Transfer

+ func (it *ERC721TransferIterator) Close() error

+ func (it *ERC721TransferIterator) Error() error

+ func (it *ERC721TransferIterator) Next() bool

+ type ExtBridge struct

+ func DeployExtBridge(auth *bind.TransactOpts, backend bind.ContractBackend, _modeMintBurn bool) (common.Address, *types.Transaction, *ExtBridge, error)

+ func NewExtBridge(address common.Address, backend bind.ContractBackend) (*ExtBridge, error)

+ type ExtBridgeCaller struct

+ func NewExtBridgeCaller(address common.Address, caller bind.ContractCaller) (*ExtBridgeCaller, error)

+ func (_ExtBridge *ExtBridgeCaller) AllowedTokens(opts *bind.CallOpts, arg0 common.Address) (common.Address, error)

+ func (_ExtBridge *ExtBridgeCaller) Callback(opts *bind.CallOpts) (common.Address, error)

+ func (_ExtBridge *ExtBridgeCaller) ClosedValueTransferVotes(opts *bind.CallOpts, arg0 uint64) (bool, error)

+ func (_ExtBridge *ExtBridgeCaller) ConfigurationNonce(opts *bind.CallOpts) (uint64, error)

+ func (_ExtBridge *ExtBridgeCaller) FeeOfERC20(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_ExtBridge *ExtBridgeCaller) FeeOfKLAY(opts *bind.CallOpts) (*big.Int, error)

+ func (_ExtBridge *ExtBridgeCaller) FeeReceiver(opts *bind.CallOpts) (common.Address, error)

+ func (_ExtBridge *ExtBridgeCaller) HandleNoncesToBlockNums(opts *bind.CallOpts, arg0 uint64) (uint64, error)

+ func (_ExtBridge *ExtBridgeCaller) HandledRequestTx(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ func (_ExtBridge *ExtBridgeCaller) IsOwner(opts *bind.CallOpts) (bool, error)

+ func (_ExtBridge *ExtBridgeCaller) IsRunning(opts *bind.CallOpts) (bool, error)

+ func (_ExtBridge *ExtBridgeCaller) LowerHandleNonce(opts *bind.CallOpts) (uint64, error)

+ func (_ExtBridge *ExtBridgeCaller) ModeMintBurn(opts *bind.CallOpts) (bool, error)

+ func (_ExtBridge *ExtBridgeCaller) OperatorThresholds(opts *bind.CallOpts, arg0 uint8) (uint8, error)

+ func (_ExtBridge *ExtBridgeCaller) Operators(opts *bind.CallOpts, arg0 common.Address) (bool, error)

+ func (_ExtBridge *ExtBridgeCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_ExtBridge *ExtBridgeCaller) RecoveryBlockNumber(opts *bind.CallOpts) (uint64, error)

+ func (_ExtBridge *ExtBridgeCaller) RequestNonce(opts *bind.CallOpts) (uint64, error)

+ func (_ExtBridge *ExtBridgeCaller) UpperHandleNonce(opts *bind.CallOpts) (uint64, error)

+ func (_ExtBridge *ExtBridgeCaller) Votes(opts *bind.CallOpts, arg0 [32]byte, arg1 common.Address) (bool, error)

+ func (_ExtBridge *ExtBridgeCaller) VotesCounts(opts *bind.CallOpts, arg0 [32]byte) (uint8, error)

+ type ExtBridgeCallerRaw struct

+ Contract *ExtBridgeCaller

+ func (_ExtBridge *ExtBridgeCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ExtBridgeCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ExtBridgeCaller

+ func (_ExtBridge *ExtBridgeCallerSession) AllowedTokens(arg0 common.Address) (common.Address, error)

+ func (_ExtBridge *ExtBridgeCallerSession) Callback() (common.Address, error)

+ func (_ExtBridge *ExtBridgeCallerSession) ClosedValueTransferVotes(arg0 uint64) (bool, error)

+ func (_ExtBridge *ExtBridgeCallerSession) ConfigurationNonce() (uint64, error)

+ func (_ExtBridge *ExtBridgeCallerSession) FeeOfERC20(arg0 common.Address) (*big.Int, error)

+ func (_ExtBridge *ExtBridgeCallerSession) FeeOfKLAY() (*big.Int, error)

+ func (_ExtBridge *ExtBridgeCallerSession) FeeReceiver() (common.Address, error)

+ func (_ExtBridge *ExtBridgeCallerSession) HandleNoncesToBlockNums(arg0 uint64) (uint64, error)

+ func (_ExtBridge *ExtBridgeCallerSession) HandledRequestTx(arg0 [32]byte) (bool, error)

+ func (_ExtBridge *ExtBridgeCallerSession) IsOwner() (bool, error)

+ func (_ExtBridge *ExtBridgeCallerSession) IsRunning() (bool, error)

+ func (_ExtBridge *ExtBridgeCallerSession) LowerHandleNonce() (uint64, error)

+ func (_ExtBridge *ExtBridgeCallerSession) ModeMintBurn() (bool, error)

+ func (_ExtBridge *ExtBridgeCallerSession) OperatorThresholds(arg0 uint8) (uint8, error)

+ func (_ExtBridge *ExtBridgeCallerSession) Operators(arg0 common.Address) (bool, error)

+ func (_ExtBridge *ExtBridgeCallerSession) Owner() (common.Address, error)

+ func (_ExtBridge *ExtBridgeCallerSession) RecoveryBlockNumber() (uint64, error)

+ func (_ExtBridge *ExtBridgeCallerSession) RequestNonce() (uint64, error)

+ func (_ExtBridge *ExtBridgeCallerSession) UpperHandleNonce() (uint64, error)

+ func (_ExtBridge *ExtBridgeCallerSession) Votes(arg0 [32]byte, arg1 common.Address) (bool, error)

+ func (_ExtBridge *ExtBridgeCallerSession) VotesCounts(arg0 [32]byte) (uint8, error)

+ type ExtBridgeERC20FeeChanged struct

+ Fee *big.Int

+ Raw types.Log

+ Token common.Address

+ type ExtBridgeERC20FeeChangedIterator struct

+ Event *ExtBridgeERC20FeeChanged

+ func (it *ExtBridgeERC20FeeChangedIterator) Close() error

+ func (it *ExtBridgeERC20FeeChangedIterator) Error() error

+ func (it *ExtBridgeERC20FeeChangedIterator) Next() bool

+ type ExtBridgeFeeReceiverChanged struct

+ FeeReceiver common.Address

+ Raw types.Log

+ type ExtBridgeFeeReceiverChangedIterator struct

+ Event *ExtBridgeFeeReceiverChanged

+ func (it *ExtBridgeFeeReceiverChangedIterator) Close() error

+ func (it *ExtBridgeFeeReceiverChangedIterator) Error() error

+ func (it *ExtBridgeFeeReceiverChangedIterator) Next() bool

+ type ExtBridgeFilterer struct

+ func NewExtBridgeFilterer(address common.Address, filterer bind.ContractFilterer) (*ExtBridgeFilterer, error)

+ func (_ExtBridge *ExtBridgeFilterer) FilterERC20FeeChanged(opts *bind.FilterOpts, fee []*big.Int) (*ExtBridgeERC20FeeChangedIterator, error)

+ func (_ExtBridge *ExtBridgeFilterer) FilterFeeReceiverChanged(opts *bind.FilterOpts, feeReceiver []common.Address) (*ExtBridgeFeeReceiverChangedIterator, error)

+ func (_ExtBridge *ExtBridgeFilterer) FilterHandleValueTransfer(opts *bind.FilterOpts) (*ExtBridgeHandleValueTransferIterator, error)

+ func (_ExtBridge *ExtBridgeFilterer) FilterKLAYFeeChanged(opts *bind.FilterOpts, fee []*big.Int) (*ExtBridgeKLAYFeeChangedIterator, error)

+ func (_ExtBridge *ExtBridgeFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*ExtBridgeOwnershipTransferredIterator, error)

+ func (_ExtBridge *ExtBridgeFilterer) FilterRequestValueTransfer(opts *bind.FilterOpts) (*ExtBridgeRequestValueTransferIterator, error)

+ func (_ExtBridge *ExtBridgeFilterer) WatchERC20FeeChanged(opts *bind.WatchOpts, sink chan<- *ExtBridgeERC20FeeChanged, fee []*big.Int) (event.Subscription, error)

+ func (_ExtBridge *ExtBridgeFilterer) WatchFeeReceiverChanged(opts *bind.WatchOpts, sink chan<- *ExtBridgeFeeReceiverChanged, ...) (event.Subscription, error)

+ func (_ExtBridge *ExtBridgeFilterer) WatchHandleValueTransfer(opts *bind.WatchOpts, sink chan<- *ExtBridgeHandleValueTransfer) (event.Subscription, error)

+ func (_ExtBridge *ExtBridgeFilterer) WatchKLAYFeeChanged(opts *bind.WatchOpts, sink chan<- *ExtBridgeKLAYFeeChanged, fee []*big.Int) (event.Subscription, error)

+ func (_ExtBridge *ExtBridgeFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ExtBridgeOwnershipTransferred, ...) (event.Subscription, error)

+ func (_ExtBridge *ExtBridgeFilterer) WatchRequestValueTransfer(opts *bind.WatchOpts, sink chan<- *ExtBridgeRequestValueTransfer) (event.Subscription, error)

+ type ExtBridgeHandleValueTransfer struct

+ ExtraData []*big.Int

+ From common.Address

+ HandleNonce uint64

+ Raw types.Log

+ RequestTxHash [32]byte

+ To common.Address

+ TokenAddress common.Address

+ TokenType uint8

+ ValueOrTokenId *big.Int

+ type ExtBridgeHandleValueTransferIterator struct

+ Event *ExtBridgeHandleValueTransfer

+ func (it *ExtBridgeHandleValueTransferIterator) Close() error

+ func (it *ExtBridgeHandleValueTransferIterator) Error() error

+ func (it *ExtBridgeHandleValueTransferIterator) Next() bool

+ type ExtBridgeKLAYFeeChanged struct

+ Fee *big.Int

+ Raw types.Log

+ type ExtBridgeKLAYFeeChangedIterator struct

+ Event *ExtBridgeKLAYFeeChanged

+ func (it *ExtBridgeKLAYFeeChangedIterator) Close() error

+ func (it *ExtBridgeKLAYFeeChangedIterator) Error() error

+ func (it *ExtBridgeKLAYFeeChangedIterator) Next() bool

+ type ExtBridgeOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type ExtBridgeOwnershipTransferredIterator struct

+ Event *ExtBridgeOwnershipTransferred

+ func (it *ExtBridgeOwnershipTransferredIterator) Close() error

+ func (it *ExtBridgeOwnershipTransferredIterator) Error() error

+ func (it *ExtBridgeOwnershipTransferredIterator) Next() bool

+ type ExtBridgeRaw struct

+ Contract *ExtBridge

+ func (_ExtBridge *ExtBridgeRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_ExtBridge *ExtBridgeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ExtBridgeRequestValueTransfer struct

+ ExtraData []*big.Int

+ Fee *big.Int

+ From common.Address

+ Raw types.Log

+ RequestNonce uint64

+ To common.Address

+ TokenAddress common.Address

+ TokenType uint8

+ Uri string

+ ValueOrTokenId *big.Int

+ type ExtBridgeRequestValueTransferIterator struct

+ Event *ExtBridgeRequestValueTransfer

+ func (it *ExtBridgeRequestValueTransferIterator) Close() error

+ func (it *ExtBridgeRequestValueTransferIterator) Error() error

+ func (it *ExtBridgeRequestValueTransferIterator) Next() bool

+ type ExtBridgeSession struct

+ CallOpts bind.CallOpts

+ Contract *ExtBridge

+ TransactOpts bind.TransactOpts

+ func (_ExtBridge *ExtBridgeSession) AllowedTokens(arg0 common.Address) (common.Address, error)

+ func (_ExtBridge *ExtBridgeSession) Callback() (common.Address, error)

+ func (_ExtBridge *ExtBridgeSession) ClosedValueTransferVotes(arg0 uint64) (bool, error)

+ func (_ExtBridge *ExtBridgeSession) ConfigurationNonce() (uint64, error)

+ func (_ExtBridge *ExtBridgeSession) DeregisterOperator(_operator common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeSession) DeregisterToken(_token common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeSession) FeeOfERC20(arg0 common.Address) (*big.Int, error)

+ func (_ExtBridge *ExtBridgeSession) FeeOfKLAY() (*big.Int, error)

+ func (_ExtBridge *ExtBridgeSession) FeeReceiver() (common.Address, error)

+ func (_ExtBridge *ExtBridgeSession) HandleERC20Transfer(_requestTxHash [32]byte, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeSession) HandleERC721Transfer(_requestTxHash [32]byte, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeSession) HandleNoncesToBlockNums(arg0 uint64) (uint64, error)

+ func (_ExtBridge *ExtBridgeSession) HandledRequestTx(arg0 [32]byte) (bool, error)

+ func (_ExtBridge *ExtBridgeSession) IsOwner() (bool, error)

+ func (_ExtBridge *ExtBridgeSession) IsRunning() (bool, error)

+ func (_ExtBridge *ExtBridgeSession) LowerHandleNonce() (uint64, error)

+ func (_ExtBridge *ExtBridgeSession) ModeMintBurn() (bool, error)

+ func (_ExtBridge *ExtBridgeSession) OnERC20Received(_from common.Address, _to common.Address, _value *big.Int, _feeLimit *big.Int, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeSession) OnERC721Received(_from common.Address, _tokenId *big.Int, _to common.Address, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeSession) OperatorThresholds(arg0 uint8) (uint8, error)

+ func (_ExtBridge *ExtBridgeSession) Operators(arg0 common.Address) (bool, error)

+ func (_ExtBridge *ExtBridgeSession) Owner() (common.Address, error)

+ func (_ExtBridge *ExtBridgeSession) RecoveryBlockNumber() (uint64, error)

+ func (_ExtBridge *ExtBridgeSession) RegisterOperator(_operator common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeSession) RegisterToken(_token common.Address, _cToken common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeSession) RenounceOwnership() (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeSession) RequestERC20Transfer(_tokenAddress common.Address, _to common.Address, _value *big.Int, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeSession) RequestERC721Transfer(_tokenAddress common.Address, _to common.Address, _tokenId *big.Int, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeSession) RequestNonce() (uint64, error)

+ func (_ExtBridge *ExtBridgeSession) SetCallback(_addr common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeSession) SetERC20Fee(_token common.Address, _fee *big.Int, _requestNonce uint64) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeSession) SetFeeReceiver(_feeReceiver common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeSession) SetOperatorThreshold(_voteType uint8, _threshold uint8) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeSession) Start(_status bool) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeSession) UpperHandleNonce() (uint64, error)

+ func (_ExtBridge *ExtBridgeSession) Votes(arg0 [32]byte, arg1 common.Address) (bool, error)

+ func (_ExtBridge *ExtBridgeSession) VotesCounts(arg0 [32]byte) (uint8, error)

+ type ExtBridgeTransactor struct

+ func NewExtBridgeTransactor(address common.Address, transactor bind.ContractTransactor) (*ExtBridgeTransactor, error)

+ func (_ExtBridge *ExtBridgeTransactor) DeregisterOperator(opts *bind.TransactOpts, _operator common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactor) DeregisterToken(opts *bind.TransactOpts, _token common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactor) HandleERC20Transfer(opts *bind.TransactOpts, _requestTxHash [32]byte, _from common.Address, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactor) HandleERC721Transfer(opts *bind.TransactOpts, _requestTxHash [32]byte, _from common.Address, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactor) OnERC20Received(opts *bind.TransactOpts, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactor) OnERC721Received(opts *bind.TransactOpts, _from common.Address, _tokenId *big.Int, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactor) RegisterOperator(opts *bind.TransactOpts, _operator common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactor) RegisterToken(opts *bind.TransactOpts, _token common.Address, _cToken common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactor) RequestERC20Transfer(opts *bind.TransactOpts, _tokenAddress common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactor) RequestERC721Transfer(opts *bind.TransactOpts, _tokenAddress common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactor) SetCallback(opts *bind.TransactOpts, _addr common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactor) SetERC20Fee(opts *bind.TransactOpts, _token common.Address, _fee *big.Int, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactor) SetFeeReceiver(opts *bind.TransactOpts, _feeReceiver common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactor) SetOperatorThreshold(opts *bind.TransactOpts, _voteType uint8, _threshold uint8) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactor) Start(opts *bind.TransactOpts, _status bool) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type ExtBridgeTransactorRaw struct

+ Contract *ExtBridgeTransactor

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

+ func (_ExtBridge *ExtBridgeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ExtBridgeTransactorSession struct

+ Contract *ExtBridgeTransactor

+ TransactOpts bind.TransactOpts

+ func (_ExtBridge *ExtBridgeTransactorSession) DeregisterOperator(_operator common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactorSession) DeregisterToken(_token common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactorSession) HandleERC20Transfer(_requestTxHash [32]byte, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactorSession) HandleERC721Transfer(_requestTxHash [32]byte, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactorSession) OnERC20Received(_from common.Address, _to common.Address, _value *big.Int, _feeLimit *big.Int, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactorSession) OnERC721Received(_from common.Address, _tokenId *big.Int, _to common.Address, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactorSession) RegisterOperator(_operator common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactorSession) RegisterToken(_token common.Address, _cToken common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactorSession) RequestERC20Transfer(_tokenAddress common.Address, _to common.Address, _value *big.Int, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactorSession) RequestERC721Transfer(_tokenAddress common.Address, _to common.Address, _tokenId *big.Int, ...) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactorSession) SetCallback(_addr common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactorSession) SetERC20Fee(_token common.Address, _fee *big.Int, _requestNonce uint64) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactorSession) SetFeeReceiver(_feeReceiver common.Address) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactorSession) SetOperatorThreshold(_voteType uint8, _threshold uint8) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactorSession) Start(_status bool) (*types.Transaction, error)

+ func (_ExtBridge *ExtBridgeTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type IERC165 struct

+ func DeployIERC165(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *IERC165, error)

+ func NewIERC165(address common.Address, backend bind.ContractBackend) (*IERC165, error)

+ type IERC165Caller struct

+ func NewIERC165Caller(address common.Address, caller bind.ContractCaller) (*IERC165Caller, error)

+ func (_IERC165 *IERC165Caller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ type IERC165CallerRaw struct

+ Contract *IERC165Caller

+ func (_IERC165 *IERC165CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type IERC165CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC165Caller

+ func (_IERC165 *IERC165CallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ type IERC165Filterer struct

+ func NewIERC165Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC165Filterer, error)

+ type IERC165Raw struct

+ Contract *IERC165

+ func (_IERC165 *IERC165Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_IERC165 *IERC165Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC165Session struct

+ CallOpts bind.CallOpts

+ Contract *IERC165

+ TransactOpts bind.TransactOpts

+ func (_IERC165 *IERC165Session) SupportsInterface(interfaceId [4]byte) (bool, error)

+ type IERC165Transactor struct

+ func NewIERC165Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC165Transactor, error)

+ type IERC165TransactorRaw struct

+ Contract *IERC165Transactor

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

+ func (_IERC165 *IERC165TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC165TransactorSession struct

+ Contract *IERC165Transactor

+ TransactOpts bind.TransactOpts

+ type IERC20 struct

+ func DeployIERC20(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *IERC20, error)

+ func NewIERC20(address common.Address, backend bind.ContractBackend) (*IERC20, error)

+ type IERC20Approval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type IERC20ApprovalIterator struct

+ Event *IERC20Approval

+ func (it *IERC20ApprovalIterator) Close() error

+ func (it *IERC20ApprovalIterator) Error() error

+ func (it *IERC20ApprovalIterator) Next() bool

+ type IERC20BridgeReceiver struct

+ func DeployIERC20BridgeReceiver(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *IERC20BridgeReceiver, error)

+ func NewIERC20BridgeReceiver(address common.Address, backend bind.ContractBackend) (*IERC20BridgeReceiver, error)

+ type IERC20BridgeReceiverCaller struct

+ func NewIERC20BridgeReceiverCaller(address common.Address, caller bind.ContractCaller) (*IERC20BridgeReceiverCaller, error)

+ type IERC20BridgeReceiverCallerRaw struct

+ Contract *IERC20BridgeReceiverCaller

+ func (_IERC20BridgeReceiver *IERC20BridgeReceiverCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type IERC20BridgeReceiverCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC20BridgeReceiverCaller

+ type IERC20BridgeReceiverFilterer struct

+ func NewIERC20BridgeReceiverFilterer(address common.Address, filterer bind.ContractFilterer) (*IERC20BridgeReceiverFilterer, error)

+ type IERC20BridgeReceiverRaw struct

+ Contract *IERC20BridgeReceiver

+ func (_IERC20BridgeReceiver *IERC20BridgeReceiverRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_IERC20BridgeReceiver *IERC20BridgeReceiverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC20BridgeReceiverSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC20BridgeReceiver

+ TransactOpts bind.TransactOpts

+ func (_IERC20BridgeReceiver *IERC20BridgeReceiverSession) OnERC20Received(_from common.Address, _to common.Address, _amount *big.Int, _feeLimit *big.Int, ...) (*types.Transaction, error)

+ type IERC20BridgeReceiverTransactor struct

+ func NewIERC20BridgeReceiverTransactor(address common.Address, transactor bind.ContractTransactor) (*IERC20BridgeReceiverTransactor, error)

+ func (_IERC20BridgeReceiver *IERC20BridgeReceiverTransactor) OnERC20Received(opts *bind.TransactOpts, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ type IERC20BridgeReceiverTransactorRaw struct

+ Contract *IERC20BridgeReceiverTransactor

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

+ func (_IERC20BridgeReceiver *IERC20BridgeReceiverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC20BridgeReceiverTransactorSession struct

+ Contract *IERC20BridgeReceiverTransactor

+ TransactOpts bind.TransactOpts

+ func (_IERC20BridgeReceiver *IERC20BridgeReceiverTransactorSession) OnERC20Received(_from common.Address, _to common.Address, _amount *big.Int, _feeLimit *big.Int, ...) (*types.Transaction, error)

+ type IERC20Caller struct

+ func NewIERC20Caller(address common.Address, caller bind.ContractCaller) (*IERC20Caller, error)

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

+ func (_IERC20 *IERC20Caller) BalanceOf(opts *bind.CallOpts, who common.Address) (*big.Int, error)

+ func (_IERC20 *IERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type IERC20CallerRaw struct

+ Contract *IERC20Caller

+ func (_IERC20 *IERC20CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type IERC20CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC20Caller

+ func (_IERC20 *IERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_IERC20 *IERC20CallerSession) BalanceOf(who common.Address) (*big.Int, error)

+ func (_IERC20 *IERC20CallerSession) TotalSupply() (*big.Int, error)

+ type IERC20Filterer struct

+ func NewIERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC20Filterer, error)

+ func (_IERC20 *IERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*IERC20ApprovalIterator, error)

+ func (_IERC20 *IERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*IERC20TransferIterator, error)

+ func (_IERC20 *IERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC20Approval, owner []common.Address, ...) (event.Subscription, error)

+ func (_IERC20 *IERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC20Transfer, from []common.Address, ...) (event.Subscription, error)

+ type IERC20Raw struct

+ Contract *IERC20

+ func (_IERC20 *IERC20Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_IERC20 *IERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC20Session struct

+ CallOpts bind.CallOpts

+ Contract *IERC20

+ TransactOpts bind.TransactOpts

+ func (_IERC20 *IERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_IERC20 *IERC20Session) Approve(spender common.Address, value *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20Session) BalanceOf(who common.Address) (*big.Int, error)

+ func (_IERC20 *IERC20Session) TotalSupply() (*big.Int, error)

+ func (_IERC20 *IERC20Session) Transfer(to common.Address, value *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20Session) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error)

+ type IERC20Transactor struct

+ func NewIERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC20Transactor, error)

+ func (_IERC20 *IERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, value *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20Transactor) Transfer(opts *bind.TransactOpts, to common.Address, value *big.Int) (*types.Transaction, error)

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

+ type IERC20TransactorRaw struct

+ Contract *IERC20Transactor

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

+ func (_IERC20 *IERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC20TransactorSession struct

+ Contract *IERC20Transactor

+ TransactOpts bind.TransactOpts

+ func (_IERC20 *IERC20TransactorSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20TransactorSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20TransactorSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error)

+ type IERC20Transfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type IERC20TransferIterator struct

+ Event *IERC20Transfer

+ func (it *IERC20TransferIterator) Close() error

+ func (it *IERC20TransferIterator) Error() error

+ func (it *IERC20TransferIterator) Next() bool

+ type IERC721 struct

+ func DeployIERC721(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *IERC721, error)

+ func NewIERC721(address common.Address, backend bind.ContractBackend) (*IERC721, error)

+ type IERC721Approval struct

+ Approved common.Address

+ Owner common.Address

+ Raw types.Log

+ TokenId *big.Int

+ type IERC721ApprovalForAll struct

+ Approved bool

+ Operator common.Address

+ Owner common.Address

+ Raw types.Log

+ type IERC721ApprovalForAllIterator struct

+ Event *IERC721ApprovalForAll

+ func (it *IERC721ApprovalForAllIterator) Close() error

+ func (it *IERC721ApprovalForAllIterator) Error() error

+ func (it *IERC721ApprovalForAllIterator) Next() bool

+ type IERC721ApprovalIterator struct

+ Event *IERC721Approval

+ func (it *IERC721ApprovalIterator) Close() error

+ func (it *IERC721ApprovalIterator) Error() error

+ func (it *IERC721ApprovalIterator) Next() bool

+ type IERC721BridgeReceiver struct

+ func DeployIERC721BridgeReceiver(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *IERC721BridgeReceiver, error)

+ func NewIERC721BridgeReceiver(address common.Address, backend bind.ContractBackend) (*IERC721BridgeReceiver, error)

+ type IERC721BridgeReceiverCaller struct

+ func NewIERC721BridgeReceiverCaller(address common.Address, caller bind.ContractCaller) (*IERC721BridgeReceiverCaller, error)

+ type IERC721BridgeReceiverCallerRaw struct

+ Contract *IERC721BridgeReceiverCaller

+ func (_IERC721BridgeReceiver *IERC721BridgeReceiverCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type IERC721BridgeReceiverCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC721BridgeReceiverCaller

+ type IERC721BridgeReceiverFilterer struct

+ func NewIERC721BridgeReceiverFilterer(address common.Address, filterer bind.ContractFilterer) (*IERC721BridgeReceiverFilterer, error)

+ type IERC721BridgeReceiverRaw struct

+ Contract *IERC721BridgeReceiver

+ func (_IERC721BridgeReceiver *IERC721BridgeReceiverRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_IERC721BridgeReceiver *IERC721BridgeReceiverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC721BridgeReceiverSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC721BridgeReceiver

+ TransactOpts bind.TransactOpts

+ func (_IERC721BridgeReceiver *IERC721BridgeReceiverSession) OnERC721Received(_from common.Address, _tokenId *big.Int, _to common.Address, ...) (*types.Transaction, error)

+ type IERC721BridgeReceiverTransactor struct

+ func NewIERC721BridgeReceiverTransactor(address common.Address, transactor bind.ContractTransactor) (*IERC721BridgeReceiverTransactor, error)

+ func (_IERC721BridgeReceiver *IERC721BridgeReceiverTransactor) OnERC721Received(opts *bind.TransactOpts, _from common.Address, _tokenId *big.Int, ...) (*types.Transaction, error)

+ type IERC721BridgeReceiverTransactorRaw struct

+ Contract *IERC721BridgeReceiverTransactor

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

+ func (_IERC721BridgeReceiver *IERC721BridgeReceiverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC721BridgeReceiverTransactorSession struct

+ Contract *IERC721BridgeReceiverTransactor

+ TransactOpts bind.TransactOpts

+ func (_IERC721BridgeReceiver *IERC721BridgeReceiverTransactorSession) OnERC721Received(_from common.Address, _tokenId *big.Int, _to common.Address, ...) (*types.Transaction, error)

+ type IERC721Caller struct

+ func NewIERC721Caller(address common.Address, caller bind.ContractCaller) (*IERC721Caller, error)

+ func (_IERC721 *IERC721Caller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_IERC721 *IERC721Caller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_IERC721 *IERC721Caller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error)

+ func (_IERC721 *IERC721Caller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_IERC721 *IERC721Caller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ type IERC721CallerRaw struct

+ Contract *IERC721Caller

+ func (_IERC721 *IERC721CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type IERC721CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC721Caller

+ func (_IERC721 *IERC721CallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_IERC721 *IERC721CallerSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_IERC721 *IERC721CallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_IERC721 *IERC721CallerSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_IERC721 *IERC721CallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ type IERC721Filterer struct

+ func NewIERC721Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC721Filterer, error)

+ func (_IERC721 *IERC721Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, ...) (*IERC721ApprovalIterator, error)

+ func (_IERC721 *IERC721Filterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*IERC721ApprovalForAllIterator, error)

+ func (_IERC721 *IERC721Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, ...) (*IERC721TransferIterator, error)

+ func (_IERC721 *IERC721Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC721Approval, owner []common.Address, ...) (event.Subscription, error)

+ func (_IERC721 *IERC721Filterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *IERC721ApprovalForAll, ...) (event.Subscription, error)

+ func (_IERC721 *IERC721Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC721Transfer, from []common.Address, ...) (event.Subscription, error)

+ type IERC721Metadata struct

+ func DeployIERC721Metadata(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *IERC721Metadata, error)

+ func NewIERC721Metadata(address common.Address, backend bind.ContractBackend) (*IERC721Metadata, error)

+ type IERC721MetadataApproval struct

+ Approved common.Address

+ Owner common.Address

+ Raw types.Log

+ TokenId *big.Int

+ type IERC721MetadataApprovalForAll struct

+ Approved bool

+ Operator common.Address

+ Owner common.Address

+ Raw types.Log

+ type IERC721MetadataApprovalForAllIterator struct

+ Event *IERC721MetadataApprovalForAll

+ func (it *IERC721MetadataApprovalForAllIterator) Close() error

+ func (it *IERC721MetadataApprovalForAllIterator) Error() error

+ func (it *IERC721MetadataApprovalForAllIterator) Next() bool

+ type IERC721MetadataApprovalIterator struct

+ Event *IERC721MetadataApproval

+ func (it *IERC721MetadataApprovalIterator) Close() error

+ func (it *IERC721MetadataApprovalIterator) Error() error

+ func (it *IERC721MetadataApprovalIterator) Next() bool

+ type IERC721MetadataCaller struct

+ func NewIERC721MetadataCaller(address common.Address, caller bind.ContractCaller) (*IERC721MetadataCaller, error)

+ func (_IERC721Metadata *IERC721MetadataCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_IERC721Metadata *IERC721MetadataCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_IERC721Metadata *IERC721MetadataCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error)

+ func (_IERC721Metadata *IERC721MetadataCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_IERC721Metadata *IERC721MetadataCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_IERC721Metadata *IERC721MetadataCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ func (_IERC721Metadata *IERC721MetadataCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_IERC721Metadata *IERC721MetadataCaller) TokenURI(opts *bind.CallOpts, tokenId *big.Int) (string, error)

+ type IERC721MetadataCallerRaw struct

+ Contract *IERC721MetadataCaller

+ func (_IERC721Metadata *IERC721MetadataCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type IERC721MetadataCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC721MetadataCaller

+ func (_IERC721Metadata *IERC721MetadataCallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_IERC721Metadata *IERC721MetadataCallerSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_IERC721Metadata *IERC721MetadataCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_IERC721Metadata *IERC721MetadataCallerSession) Name() (string, error)

+ func (_IERC721Metadata *IERC721MetadataCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_IERC721Metadata *IERC721MetadataCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_IERC721Metadata *IERC721MetadataCallerSession) Symbol() (string, error)

+ func (_IERC721Metadata *IERC721MetadataCallerSession) TokenURI(tokenId *big.Int) (string, error)

+ type IERC721MetadataFilterer struct

+ func NewIERC721MetadataFilterer(address common.Address, filterer bind.ContractFilterer) (*IERC721MetadataFilterer, error)

+ func (_IERC721Metadata *IERC721MetadataFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, ...) (*IERC721MetadataApprovalIterator, error)

+ func (_IERC721Metadata *IERC721MetadataFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*IERC721MetadataApprovalForAllIterator, error)

+ func (_IERC721Metadata *IERC721MetadataFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, ...) (*IERC721MetadataTransferIterator, error)

+ func (_IERC721Metadata *IERC721MetadataFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC721MetadataApproval, ...) (event.Subscription, error)

+ func (_IERC721Metadata *IERC721MetadataFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *IERC721MetadataApprovalForAll, ...) (event.Subscription, error)

+ func (_IERC721Metadata *IERC721MetadataFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC721MetadataTransfer, ...) (event.Subscription, error)

+ type IERC721MetadataRaw struct

+ Contract *IERC721Metadata

+ func (_IERC721Metadata *IERC721MetadataRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_IERC721Metadata *IERC721MetadataRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC721MetadataSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC721Metadata

+ TransactOpts bind.TransactOpts

+ func (_IERC721Metadata *IERC721MetadataSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_IERC721Metadata *IERC721MetadataSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_IERC721Metadata *IERC721MetadataSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_IERC721Metadata *IERC721MetadataSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_IERC721Metadata *IERC721MetadataSession) Name() (string, error)

+ func (_IERC721Metadata *IERC721MetadataSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_IERC721Metadata *IERC721MetadataSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

+ func (_IERC721Metadata *IERC721MetadataSession) SetApprovalForAll(operator common.Address, _approved bool) (*types.Transaction, error)

+ func (_IERC721Metadata *IERC721MetadataSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_IERC721Metadata *IERC721MetadataSession) Symbol() (string, error)

+ func (_IERC721Metadata *IERC721MetadataSession) TokenURI(tokenId *big.Int) (string, error)

+ func (_IERC721Metadata *IERC721MetadataSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type IERC721MetadataTransactor struct

+ func NewIERC721MetadataTransactor(address common.Address, transactor bind.ContractTransactor) (*IERC721MetadataTransactor, error)

+ func (_IERC721Metadata *IERC721MetadataTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_IERC721Metadata *IERC721MetadataTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_IERC721Metadata *IERC721MetadataTransactor) SetApprovalForAll(opts *bind.TransactOpts, operator common.Address, _approved bool) (*types.Transaction, error)

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

+ type IERC721MetadataTransactorRaw struct

+ Contract *IERC721MetadataTransactor

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

+ func (_IERC721Metadata *IERC721MetadataTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC721MetadataTransactorSession struct

+ Contract *IERC721MetadataTransactor

+ TransactOpts bind.TransactOpts

+ func (_IERC721Metadata *IERC721MetadataTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_IERC721Metadata *IERC721MetadataTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

+ func (_IERC721Metadata *IERC721MetadataTransactorSession) SetApprovalForAll(operator common.Address, _approved bool) (*types.Transaction, error)

+ func (_IERC721Metadata *IERC721MetadataTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type IERC721MetadataTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ TokenId *big.Int

+ type IERC721MetadataTransferIterator struct

+ Event *IERC721MetadataTransfer

+ func (it *IERC721MetadataTransferIterator) Close() error

+ func (it *IERC721MetadataTransferIterator) Error() error

+ func (it *IERC721MetadataTransferIterator) Next() bool

+ type IERC721Raw struct

+ Contract *IERC721

+ func (_IERC721 *IERC721Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_IERC721 *IERC721Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC721Receiver struct

+ func DeployIERC721Receiver(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *IERC721Receiver, error)

+ func NewIERC721Receiver(address common.Address, backend bind.ContractBackend) (*IERC721Receiver, error)

+ type IERC721ReceiverCaller struct

+ func NewIERC721ReceiverCaller(address common.Address, caller bind.ContractCaller) (*IERC721ReceiverCaller, error)

+ type IERC721ReceiverCallerRaw struct

+ Contract *IERC721ReceiverCaller

+ func (_IERC721Receiver *IERC721ReceiverCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type IERC721ReceiverCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC721ReceiverCaller

+ type IERC721ReceiverFilterer struct

+ func NewIERC721ReceiverFilterer(address common.Address, filterer bind.ContractFilterer) (*IERC721ReceiverFilterer, error)

+ type IERC721ReceiverRaw struct

+ Contract *IERC721Receiver

+ func (_IERC721Receiver *IERC721ReceiverRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_IERC721Receiver *IERC721ReceiverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC721ReceiverSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC721Receiver

+ TransactOpts bind.TransactOpts

+ func (_IERC721Receiver *IERC721ReceiverSession) OnERC721Received(operator common.Address, from common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

+ type IERC721ReceiverTransactor struct

+ func NewIERC721ReceiverTransactor(address common.Address, transactor bind.ContractTransactor) (*IERC721ReceiverTransactor, error)

+ func (_IERC721Receiver *IERC721ReceiverTransactor) OnERC721Received(opts *bind.TransactOpts, operator common.Address, from common.Address, ...) (*types.Transaction, error)

+ type IERC721ReceiverTransactorRaw struct

+ Contract *IERC721ReceiverTransactor

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

+ func (_IERC721Receiver *IERC721ReceiverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC721ReceiverTransactorSession struct

+ Contract *IERC721ReceiverTransactor

+ TransactOpts bind.TransactOpts

+ func (_IERC721Receiver *IERC721ReceiverTransactorSession) OnERC721Received(operator common.Address, from common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

+ type IERC721Session struct

+ CallOpts bind.CallOpts

+ Contract *IERC721

+ TransactOpts bind.TransactOpts

+ func (_IERC721 *IERC721Session) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_IERC721 *IERC721Session) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_IERC721 *IERC721Session) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_IERC721 *IERC721Session) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_IERC721 *IERC721Session) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_IERC721 *IERC721Session) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

+ func (_IERC721 *IERC721Session) SetApprovalForAll(operator common.Address, _approved bool) (*types.Transaction, error)

+ func (_IERC721 *IERC721Session) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_IERC721 *IERC721Session) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type IERC721Transactor struct

+ func NewIERC721Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC721Transactor, error)

+ func (_IERC721 *IERC721Transactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_IERC721 *IERC721Transactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_IERC721 *IERC721Transactor) SetApprovalForAll(opts *bind.TransactOpts, operator common.Address, _approved bool) (*types.Transaction, error)

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

+ type IERC721TransactorRaw struct

+ Contract *IERC721Transactor

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

+ func (_IERC721 *IERC721TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC721TransactorSession struct

+ Contract *IERC721Transactor

+ TransactOpts bind.TransactOpts

+ func (_IERC721 *IERC721TransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_IERC721 *IERC721TransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

+ func (_IERC721 *IERC721TransactorSession) SetApprovalForAll(operator common.Address, _approved bool) (*types.Transaction, error)

+ func (_IERC721 *IERC721TransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type IERC721Transfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ TokenId *big.Int

+ type IERC721TransferIterator struct

+ Event *IERC721Transfer

+ func (it *IERC721TransferIterator) Close() error

+ func (it *IERC721TransferIterator) Error() error

+ func (it *IERC721TransferIterator) Next() bool

+ type MinterRole struct

+ func DeployMinterRole(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *MinterRole, error)

+ func NewMinterRole(address common.Address, backend bind.ContractBackend) (*MinterRole, error)

+ type MinterRoleCaller struct

+ func NewMinterRoleCaller(address common.Address, caller bind.ContractCaller) (*MinterRoleCaller, error)

+ func (_MinterRole *MinterRoleCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error)

+ type MinterRoleCallerRaw struct

+ Contract *MinterRoleCaller

+ func (_MinterRole *MinterRoleCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type MinterRoleCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *MinterRoleCaller

+ func (_MinterRole *MinterRoleCallerSession) IsMinter(account common.Address) (bool, error)

+ type MinterRoleFilterer struct

+ func NewMinterRoleFilterer(address common.Address, filterer bind.ContractFilterer) (*MinterRoleFilterer, error)

+ func (_MinterRole *MinterRoleFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*MinterRoleMinterAddedIterator, error)

+ func (_MinterRole *MinterRoleFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*MinterRoleMinterRemovedIterator, error)

+ func (_MinterRole *MinterRoleFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *MinterRoleMinterAdded, ...) (event.Subscription, error)

+ func (_MinterRole *MinterRoleFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *MinterRoleMinterRemoved, ...) (event.Subscription, error)

+ type MinterRoleMinterAdded struct

+ Account common.Address

+ Raw types.Log

+ type MinterRoleMinterAddedIterator struct

+ Event *MinterRoleMinterAdded

+ func (it *MinterRoleMinterAddedIterator) Close() error

+ func (it *MinterRoleMinterAddedIterator) Error() error

+ func (it *MinterRoleMinterAddedIterator) Next() bool

+ type MinterRoleMinterRemoved struct

+ Account common.Address

+ Raw types.Log

+ type MinterRoleMinterRemovedIterator struct

+ Event *MinterRoleMinterRemoved

+ func (it *MinterRoleMinterRemovedIterator) Close() error

+ func (it *MinterRoleMinterRemovedIterator) Error() error

+ func (it *MinterRoleMinterRemovedIterator) Next() bool

+ type MinterRoleRaw struct

+ Contract *MinterRole

+ func (_MinterRole *MinterRoleRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_MinterRole *MinterRoleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MinterRoleSession struct

+ CallOpts bind.CallOpts

+ Contract *MinterRole

+ TransactOpts bind.TransactOpts

+ func (_MinterRole *MinterRoleSession) AddMinter(account common.Address) (*types.Transaction, error)

+ func (_MinterRole *MinterRoleSession) IsMinter(account common.Address) (bool, error)

+ func (_MinterRole *MinterRoleSession) RenounceMinter() (*types.Transaction, error)

+ type MinterRoleTransactor struct

+ func NewMinterRoleTransactor(address common.Address, transactor bind.ContractTransactor) (*MinterRoleTransactor, error)

+ func (_MinterRole *MinterRoleTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error)

+ func (_MinterRole *MinterRoleTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MinterRoleTransactorRaw struct

+ Contract *MinterRoleTransactor

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

+ func (_MinterRole *MinterRoleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MinterRoleTransactorSession struct

+ Contract *MinterRoleTransactor

+ TransactOpts bind.TransactOpts

+ func (_MinterRole *MinterRoleTransactorSession) AddMinter(account common.Address) (*types.Transaction, error)

+ func (_MinterRole *MinterRoleTransactorSession) RenounceMinter() (*types.Transaction, error)

+ type Ownable struct

+ func DeployOwnable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Ownable, error)

+ func NewOwnable(address common.Address, backend bind.ContractBackend) (*Ownable, error)

+ type OwnableCaller struct

+ func NewOwnableCaller(address common.Address, caller bind.ContractCaller) (*OwnableCaller, error)

+ func (_Ownable *OwnableCaller) IsOwner(opts *bind.CallOpts) (bool, error)

+ func (_Ownable *OwnableCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ type OwnableCallerRaw struct

+ Contract *OwnableCaller

+ func (_Ownable *OwnableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type OwnableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OwnableCaller

+ func (_Ownable *OwnableCallerSession) IsOwner() (bool, error)

+ func (_Ownable *OwnableCallerSession) Owner() (common.Address, error)

+ type OwnableFilterer struct

+ func NewOwnableFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableFilterer, error)

+ func (_Ownable *OwnableFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*OwnableOwnershipTransferredIterator, error)

+ func (_Ownable *OwnableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OwnableOwnershipTransferred, ...) (event.Subscription, error)

+ type OwnableOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type OwnableOwnershipTransferredIterator struct

+ Event *OwnableOwnershipTransferred

+ func (it *OwnableOwnershipTransferredIterator) Close() error

+ func (it *OwnableOwnershipTransferredIterator) Error() error

+ func (it *OwnableOwnershipTransferredIterator) Next() bool

+ type OwnableRaw struct

+ Contract *Ownable

+ func (_Ownable *OwnableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_Ownable *OwnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OwnableSession struct

+ CallOpts bind.CallOpts

+ Contract *Ownable

+ TransactOpts bind.TransactOpts

+ func (_Ownable *OwnableSession) IsOwner() (bool, error)

+ func (_Ownable *OwnableSession) Owner() (common.Address, error)

+ func (_Ownable *OwnableSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Ownable *OwnableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type OwnableTransactor struct

+ func NewOwnableTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableTransactor, error)

+ func (_Ownable *OwnableTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Ownable *OwnableTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type OwnableTransactorRaw struct

+ Contract *OwnableTransactor

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

+ func (_Ownable *OwnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OwnableTransactorSession struct

+ Contract *OwnableTransactor

+ TransactOpts bind.TransactOpts

+ func (_Ownable *OwnableTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Ownable *OwnableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type Roles struct

+ func DeployRoles(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Roles, error)

+ func NewRoles(address common.Address, backend bind.ContractBackend) (*Roles, error)

+ type RolesCaller struct

+ func NewRolesCaller(address common.Address, caller bind.ContractCaller) (*RolesCaller, error)

+ type RolesCallerRaw struct

+ Contract *RolesCaller

+ func (_Roles *RolesCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type RolesCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *RolesCaller

+ type RolesFilterer struct

+ func NewRolesFilterer(address common.Address, filterer bind.ContractFilterer) (*RolesFilterer, error)

+ type RolesRaw struct

+ Contract *Roles

+ func (_Roles *RolesRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_Roles *RolesRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type RolesSession struct

+ CallOpts bind.CallOpts

+ Contract *Roles

+ TransactOpts bind.TransactOpts

+ type RolesTransactor struct

+ func NewRolesTransactor(address common.Address, transactor bind.ContractTransactor) (*RolesTransactor, error)

+ type RolesTransactorRaw struct

+ Contract *RolesTransactor

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

+ func (_Roles *RolesTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type RolesTransactorSession struct

+ Contract *RolesTransactor

+ TransactOpts bind.TransactOpts

+ type SafeMath struct

+ func DeploySafeMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SafeMath, error)

+ func NewSafeMath(address common.Address, backend bind.ContractBackend) (*SafeMath, error)

+ type SafeMathCaller struct

+ func NewSafeMathCaller(address common.Address, caller bind.ContractCaller) (*SafeMathCaller, error)

+ type SafeMathCallerRaw struct

+ Contract *SafeMathCaller

+ func (_SafeMath *SafeMathCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type SafeMathCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SafeMathCaller

+ type SafeMathFilterer struct

+ func NewSafeMathFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeMathFilterer, error)

+ type SafeMathRaw struct

+ Contract *SafeMath

+ func (_SafeMath *SafeMathRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_SafeMath *SafeMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeMathSession struct

+ CallOpts bind.CallOpts

+ Contract *SafeMath

+ TransactOpts bind.TransactOpts

+ type SafeMathTransactor struct

+ func NewSafeMathTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeMathTransactor, error)

+ type SafeMathTransactorRaw struct

+ Contract *SafeMathTransactor

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

+ func (_SafeMath *SafeMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeMathTransactorSession struct

+ Contract *SafeMathTransactor

+ TransactOpts bind.TransactOpts

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL