generated

package

Go to main page

Versions in this module

v1

v1.68.4

Sep 13, 2023

v1.68.3

May 24, 2023

v1.68.2

Mar 16, 2023

v1.68.1

Mar 14, 2023

v1.68.0

Feb 21, 2023

v1.67.6

Jan 31, 2023

v1.67.5

Jan 16, 2023

v1.67.4

Oct 11, 2022

v1.67.3

May 27, 2022

v1.67.2

Apr 18, 2022

v1.67.1

Mar 29, 2022

v1.67.0

Mar 21, 2022

v1.66.3

Feb 18, 2022

v1.66.2

Jan 20, 2022

v1.66.1

Jan 10, 2022

v1.66.0

Dec 30, 2021

v1.65.4

Oct 27, 2021

v1.65.3

Oct 19, 2021

Changes in this version

type BridgeBankSession

+ func (_BridgeBank *BridgeBankSession) Fallback(calldata []byte) (*types.Transaction, error)

type BridgeBankTransactor

+ func (_BridgeBank *BridgeBankTransactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error)

type BridgeBankTransactorSession

+ func (_BridgeBank *BridgeBankTransactorSession) Fallback(calldata []byte) (*types.Transaction, error)

v1.65.2

Mar 25, 2021

v1.65.1

Oct 28, 2020

Changes in this version

+ const BridgeBankABI

+ const BridgeRegistryABI

+ const BridgeTokenABI

+ const Chain33BankABI

+ const Chain33BridgeABI

+ const ContextABI

+ const ECDSAABI

+ const ERC20ABI

+ const ERC20BurnableABI

+ const ERC20DetailedABI

+ const ERC20MintableABI

+ const EthereumBankABI

+ const IERC20ABI

+ const MinterRoleABI

+ const OracleABI

+ const RolesABI

+ const SafeMathABI

+ const ValsetABI

+ var BridgeBankFuncSigs = map[string]string

+ var BridgeRegistryFuncSigs = map[string]string

+ var BridgeTokenFuncSigs = map[string]string

+ var Chain33BankBin = "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"

+ var Chain33BankFuncSigs = map[string]string

+ var Chain33BridgeFuncSigs = map[string]string

+ var ECDSABin = "0x604c602c600b82828239805160001a60731460008114601c57601e565bfe5b5030600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea165627a7a723058203623d4f6a499441b3ae37d4d1eb1f5f0fc7a03b1d0df9e4701822380e02e3e640029"

+ var ERC20BurnableFuncSigs = map[string]string

+ var ERC20DetailedFuncSigs = map[string]string

+ var ERC20FuncSigs = map[string]string

+ var ERC20MintableFuncSigs = map[string]string

+ var EthereumBankBin = "0x608060405234801561001057600080fd5b506000805560f1806100236000396000f3fe60806040526004361060485763ffffffff7c0100000000000000000000000000000000000000000000000000000000600035041663b5a9096e8114604d578063b86247d7146071575b600080fd5b348015605857600080fd5b50605f60ad565b60408051918252519081900360200190f35b348015607c57600080fd5b50605f60048036036020811015609157600080fd5b503573ffffffffffffffffffffffffffffffffffffffff1660b3565b60005481565b6001602052600090815260409020548156fea165627a7a723058205d9498785134d794cadc1d89078573b2be0c6dcc476e14f7c4199f6559a896160029"

+ var EthereumBankFuncSigs = map[string]string

+ var IERC20FuncSigs = map[string]string

+ var MinterRoleFuncSigs = map[string]string

+ var OracleFuncSigs = map[string]string

+ var RolesBin = "0x604c602c600b82828239805160001a60731460008114601c57601e565bfe5b5030600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea165627a7a72305820afaa2e1590eeaf759684b1152e6933113be43354182fe0925216d56bdb655df30029"

+ var SafeMathBin = "0x604c602c600b82828239805160001a60731460008114601c57601e565bfe5b5030600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea165627a7a72305820cc39baeecfb3bcd91b5321863e3e66cfaecd36177e02965e5f2eea6a4b5205740029"

+ var ValsetFuncSigs = map[string]string

+ type BridgeBank struct

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

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

+ type BridgeBankCaller struct

+ func NewBridgeBankCaller(address common.Address, caller bind.ContractCaller) (*BridgeBankCaller, error)

+ func (_BridgeBank *BridgeBankCaller) BridgeTokenCount(opts *bind.CallOpts) (*big.Int, error)

+ func (_BridgeBank *BridgeBankCaller) BridgeTokenCreated(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ func (_BridgeBank *BridgeBankCaller) BridgeTokenWhitelist(opts *bind.CallOpts, arg0 common.Address) (bool, error)

+ func (_BridgeBank *BridgeBankCaller) Chain33Bridge(opts *bind.CallOpts) (common.Address, error)

+ func (_BridgeBank *BridgeBankCaller) GetChain33DepositStatus(opts *bind.CallOpts, _id [32]byte) (bool, error)

+ func (_BridgeBank *BridgeBankCaller) GetToken2address(opts *bind.CallOpts, _symbol string) (common.Address, error)

+ func (_BridgeBank *BridgeBankCaller) HasBridgeTokenCreated(opts *bind.CallOpts, _symbol string) (bool, error)

+ func (_BridgeBank *BridgeBankCaller) LockNonce(opts *bind.CallOpts) (*big.Int, error)

+ func (_BridgeBank *BridgeBankCaller) LockedFunds(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_BridgeBank *BridgeBankCaller) Operator(opts *bind.CallOpts) (common.Address, error)

+ func (_BridgeBank *BridgeBankCaller) Oracle(opts *bind.CallOpts) (common.Address, error)

+ func (_BridgeBank *BridgeBankCaller) Token2address(opts *bind.CallOpts, arg0 [32]byte) (common.Address, error)

+ func (_BridgeBank *BridgeBankCaller) ViewChain33Deposit(opts *bind.CallOpts, _id [32]byte) ([]byte, common.Address, common.Address, *big.Int, error)

+ type BridgeBankCallerRaw struct

+ Contract *BridgeBankCaller

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

+ type BridgeBankCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *BridgeBankCaller

+ func (_BridgeBank *BridgeBankCallerSession) BridgeTokenCount() (*big.Int, error)

+ func (_BridgeBank *BridgeBankCallerSession) BridgeTokenCreated(arg0 [32]byte) (bool, error)

+ func (_BridgeBank *BridgeBankCallerSession) BridgeTokenWhitelist(arg0 common.Address) (bool, error)

+ func (_BridgeBank *BridgeBankCallerSession) Chain33Bridge() (common.Address, error)

+ func (_BridgeBank *BridgeBankCallerSession) GetChain33DepositStatus(_id [32]byte) (bool, error)

+ func (_BridgeBank *BridgeBankCallerSession) GetToken2address(_symbol string) (common.Address, error)

+ func (_BridgeBank *BridgeBankCallerSession) HasBridgeTokenCreated(_symbol string) (bool, error)

+ func (_BridgeBank *BridgeBankCallerSession) LockNonce() (*big.Int, error)

+ func (_BridgeBank *BridgeBankCallerSession) LockedFunds(arg0 common.Address) (*big.Int, error)

+ func (_BridgeBank *BridgeBankCallerSession) Operator() (common.Address, error)

+ func (_BridgeBank *BridgeBankCallerSession) Oracle() (common.Address, error)

+ func (_BridgeBank *BridgeBankCallerSession) Token2address(arg0 [32]byte) (common.Address, error)

+ func (_BridgeBank *BridgeBankCallerSession) ViewChain33Deposit(_id [32]byte) ([]byte, common.Address, common.Address, *big.Int, error)

+ type BridgeBankFilterer struct

+ func NewBridgeBankFilterer(address common.Address, filterer bind.ContractFilterer) (*BridgeBankFilterer, error)

+ func (_BridgeBank *BridgeBankFilterer) FilterLogBridgeTokenMint(opts *bind.FilterOpts) (*BridgeBankLogBridgeTokenMintIterator, error)

+ func (_BridgeBank *BridgeBankFilterer) FilterLogChain33TokenBurn(opts *bind.FilterOpts) (*BridgeBankLogChain33TokenBurnIterator, error)

+ func (_BridgeBank *BridgeBankFilterer) FilterLogLock(opts *bind.FilterOpts) (*BridgeBankLogLockIterator, error)

+ func (_BridgeBank *BridgeBankFilterer) FilterLogNewBridgeToken(opts *bind.FilterOpts) (*BridgeBankLogNewBridgeTokenIterator, error)

+ func (_BridgeBank *BridgeBankFilterer) FilterLogUnlock(opts *bind.FilterOpts) (*BridgeBankLogUnlockIterator, error)

+ func (_BridgeBank *BridgeBankFilterer) ParseLogBridgeTokenMint(log types.Log) (*BridgeBankLogBridgeTokenMint, error)

+ func (_BridgeBank *BridgeBankFilterer) ParseLogChain33TokenBurn(log types.Log) (*BridgeBankLogChain33TokenBurn, error)

+ func (_BridgeBank *BridgeBankFilterer) ParseLogLock(log types.Log) (*BridgeBankLogLock, error)

+ func (_BridgeBank *BridgeBankFilterer) ParseLogNewBridgeToken(log types.Log) (*BridgeBankLogNewBridgeToken, error)

+ func (_BridgeBank *BridgeBankFilterer) ParseLogUnlock(log types.Log) (*BridgeBankLogUnlock, error)

+ func (_BridgeBank *BridgeBankFilterer) WatchLogBridgeTokenMint(opts *bind.WatchOpts, sink chan<- *BridgeBankLogBridgeTokenMint) (event.Subscription, error)

+ func (_BridgeBank *BridgeBankFilterer) WatchLogChain33TokenBurn(opts *bind.WatchOpts, sink chan<- *BridgeBankLogChain33TokenBurn) (event.Subscription, error)

+ func (_BridgeBank *BridgeBankFilterer) WatchLogLock(opts *bind.WatchOpts, sink chan<- *BridgeBankLogLock) (event.Subscription, error)

+ func (_BridgeBank *BridgeBankFilterer) WatchLogNewBridgeToken(opts *bind.WatchOpts, sink chan<- *BridgeBankLogNewBridgeToken) (event.Subscription, error)

+ func (_BridgeBank *BridgeBankFilterer) WatchLogUnlock(opts *bind.WatchOpts, sink chan<- *BridgeBankLogUnlock) (event.Subscription, error)

+ type BridgeBankLogBridgeTokenMint struct

+ Amount *big.Int

+ Beneficiary common.Address

+ Raw types.Log

+ Symbol string

+ Token common.Address

+ type BridgeBankLogBridgeTokenMintIterator struct

+ Event *BridgeBankLogBridgeTokenMint

+ func (it *BridgeBankLogBridgeTokenMintIterator) Close() error

+ func (it *BridgeBankLogBridgeTokenMintIterator) Error() error

+ func (it *BridgeBankLogBridgeTokenMintIterator) Next() bool

+ type BridgeBankLogChain33TokenBurn struct

+ Amount *big.Int

+ Chain33Receiver []byte

+ Nonce *big.Int

+ OwnerFrom common.Address

+ Raw types.Log

+ Symbol string

+ Token common.Address

+ type BridgeBankLogChain33TokenBurnIterator struct

+ Event *BridgeBankLogChain33TokenBurn

+ func (it *BridgeBankLogChain33TokenBurnIterator) Close() error

+ func (it *BridgeBankLogChain33TokenBurnIterator) Error() error

+ func (it *BridgeBankLogChain33TokenBurnIterator) Next() bool

+ type BridgeBankLogLock struct

+ From common.Address

+ Nonce *big.Int

+ Raw types.Log

+ Symbol string

+ To []byte

+ Token common.Address

+ Value *big.Int

+ type BridgeBankLogLockIterator struct

+ Event *BridgeBankLogLock

+ func (it *BridgeBankLogLockIterator) Close() error

+ func (it *BridgeBankLogLockIterator) Error() error

+ func (it *BridgeBankLogLockIterator) Next() bool

+ type BridgeBankLogNewBridgeToken struct

+ Raw types.Log

+ Symbol string

+ Token common.Address

+ type BridgeBankLogNewBridgeTokenIterator struct

+ Event *BridgeBankLogNewBridgeToken

+ func (it *BridgeBankLogNewBridgeTokenIterator) Close() error

+ func (it *BridgeBankLogNewBridgeTokenIterator) Error() error

+ func (it *BridgeBankLogNewBridgeTokenIterator) Next() bool

+ type BridgeBankLogUnlock struct

+ Raw types.Log

+ Symbol string

+ To common.Address

+ Token common.Address

+ Value *big.Int

+ type BridgeBankLogUnlockIterator struct

+ Event *BridgeBankLogUnlock

+ func (it *BridgeBankLogUnlockIterator) Close() error

+ func (it *BridgeBankLogUnlockIterator) Error() error

+ func (it *BridgeBankLogUnlockIterator) Next() bool

+ type BridgeBankRaw struct

+ Contract *BridgeBank

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

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

+ func (_BridgeBank *BridgeBankRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BridgeBankSession struct

+ CallOpts bind.CallOpts

+ Contract *BridgeBank

+ TransactOpts bind.TransactOpts

+ func (_BridgeBank *BridgeBankSession) BridgeTokenCount() (*big.Int, error)

+ func (_BridgeBank *BridgeBankSession) BridgeTokenCreated(arg0 [32]byte) (bool, error)

+ func (_BridgeBank *BridgeBankSession) BridgeTokenWhitelist(arg0 common.Address) (bool, error)

+ func (_BridgeBank *BridgeBankSession) BurnBridgeTokens(_chain33Receiver []byte, _chain33TokenAddress common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_BridgeBank *BridgeBankSession) Chain33Bridge() (common.Address, error)

+ func (_BridgeBank *BridgeBankSession) CreateNewBridgeToken(_symbol string) (*types.Transaction, error)

+ func (_BridgeBank *BridgeBankSession) GetChain33DepositStatus(_id [32]byte) (bool, error)

+ func (_BridgeBank *BridgeBankSession) GetToken2address(_symbol string) (common.Address, error)

+ func (_BridgeBank *BridgeBankSession) HasBridgeTokenCreated(_symbol string) (bool, error)

+ func (_BridgeBank *BridgeBankSession) Lock(_recipient []byte, _token common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_BridgeBank *BridgeBankSession) LockNonce() (*big.Int, error)

+ func (_BridgeBank *BridgeBankSession) LockedFunds(arg0 common.Address) (*big.Int, error)

+ func (_BridgeBank *BridgeBankSession) MintBridgeTokens(_chain33Sender []byte, _intendedRecipient common.Address, ...) (*types.Transaction, error)

+ func (_BridgeBank *BridgeBankSession) Operator() (common.Address, error)

+ func (_BridgeBank *BridgeBankSession) Oracle() (common.Address, error)

+ func (_BridgeBank *BridgeBankSession) Token2address(arg0 [32]byte) (common.Address, error)

+ func (_BridgeBank *BridgeBankSession) Unlock(_recipient common.Address, _token common.Address, _symbol string, ...) (*types.Transaction, error)

+ func (_BridgeBank *BridgeBankSession) ViewChain33Deposit(_id [32]byte) ([]byte, common.Address, common.Address, *big.Int, error)

+ type BridgeBankTransactor struct

+ func NewBridgeBankTransactor(address common.Address, transactor bind.ContractTransactor) (*BridgeBankTransactor, error)

+ func (_BridgeBank *BridgeBankTransactor) BurnBridgeTokens(opts *bind.TransactOpts, _chain33Receiver []byte, ...) (*types.Transaction, error)

+ func (_BridgeBank *BridgeBankTransactor) CreateNewBridgeToken(opts *bind.TransactOpts, _symbol string) (*types.Transaction, error)

+ func (_BridgeBank *BridgeBankTransactor) Lock(opts *bind.TransactOpts, _recipient []byte, _token common.Address, ...) (*types.Transaction, error)

+ func (_BridgeBank *BridgeBankTransactor) MintBridgeTokens(opts *bind.TransactOpts, _chain33Sender []byte, ...) (*types.Transaction, error)

+ func (_BridgeBank *BridgeBankTransactor) Unlock(opts *bind.TransactOpts, _recipient common.Address, _token common.Address, ...) (*types.Transaction, error)

+ type BridgeBankTransactorRaw struct

+ Contract *BridgeBankTransactor

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

+ func (_BridgeBank *BridgeBankTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BridgeBankTransactorSession struct

+ Contract *BridgeBankTransactor

+ TransactOpts bind.TransactOpts

+ func (_BridgeBank *BridgeBankTransactorSession) BurnBridgeTokens(_chain33Receiver []byte, _chain33TokenAddress common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_BridgeBank *BridgeBankTransactorSession) CreateNewBridgeToken(_symbol string) (*types.Transaction, error)

+ func (_BridgeBank *BridgeBankTransactorSession) Lock(_recipient []byte, _token common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_BridgeBank *BridgeBankTransactorSession) MintBridgeTokens(_chain33Sender []byte, _intendedRecipient common.Address, ...) (*types.Transaction, error)

+ func (_BridgeBank *BridgeBankTransactorSession) Unlock(_recipient common.Address, _token common.Address, _symbol string, ...) (*types.Transaction, error)

+ type BridgeRegistry struct

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

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

+ type BridgeRegistryCaller struct

+ func NewBridgeRegistryCaller(address common.Address, caller bind.ContractCaller) (*BridgeRegistryCaller, error)

+ func (_BridgeRegistry *BridgeRegistryCaller) BridgeBank(opts *bind.CallOpts) (common.Address, error)

+ func (_BridgeRegistry *BridgeRegistryCaller) Chain33Bridge(opts *bind.CallOpts) (common.Address, error)

+ func (_BridgeRegistry *BridgeRegistryCaller) DeployHeight(opts *bind.CallOpts) (*big.Int, error)

+ func (_BridgeRegistry *BridgeRegistryCaller) Oracle(opts *bind.CallOpts) (common.Address, error)

+ func (_BridgeRegistry *BridgeRegistryCaller) Valset(opts *bind.CallOpts) (common.Address, error)

+ type BridgeRegistryCallerRaw struct

+ Contract *BridgeRegistryCaller

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

+ type BridgeRegistryCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *BridgeRegistryCaller

+ func (_BridgeRegistry *BridgeRegistryCallerSession) BridgeBank() (common.Address, error)

+ func (_BridgeRegistry *BridgeRegistryCallerSession) Chain33Bridge() (common.Address, error)

+ func (_BridgeRegistry *BridgeRegistryCallerSession) DeployHeight() (*big.Int, error)

+ func (_BridgeRegistry *BridgeRegistryCallerSession) Oracle() (common.Address, error)

+ func (_BridgeRegistry *BridgeRegistryCallerSession) Valset() (common.Address, error)

+ type BridgeRegistryFilterer struct

+ func NewBridgeRegistryFilterer(address common.Address, filterer bind.ContractFilterer) (*BridgeRegistryFilterer, error)

+ func (_BridgeRegistry *BridgeRegistryFilterer) FilterLogContractsRegistered(opts *bind.FilterOpts) (*BridgeRegistryLogContractsRegisteredIterator, error)

+ func (_BridgeRegistry *BridgeRegistryFilterer) ParseLogContractsRegistered(log types.Log) (*BridgeRegistryLogContractsRegistered, error)

+ func (_BridgeRegistry *BridgeRegistryFilterer) WatchLogContractsRegistered(opts *bind.WatchOpts, sink chan<- *BridgeRegistryLogContractsRegistered) (event.Subscription, error)

+ type BridgeRegistryLogContractsRegistered struct

+ BridgeBank common.Address

+ Chain33Bridge common.Address

+ Oracle common.Address

+ Raw types.Log

+ Valset common.Address

+ type BridgeRegistryLogContractsRegisteredIterator struct

+ Event *BridgeRegistryLogContractsRegistered

+ func (it *BridgeRegistryLogContractsRegisteredIterator) Close() error

+ func (it *BridgeRegistryLogContractsRegisteredIterator) Error() error

+ func (it *BridgeRegistryLogContractsRegisteredIterator) Next() bool

+ type BridgeRegistryRaw struct

+ Contract *BridgeRegistry

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

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

+ func (_BridgeRegistry *BridgeRegistryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BridgeRegistrySession struct

+ CallOpts bind.CallOpts

+ Contract *BridgeRegistry

+ TransactOpts bind.TransactOpts

+ func (_BridgeRegistry *BridgeRegistrySession) BridgeBank() (common.Address, error)

+ func (_BridgeRegistry *BridgeRegistrySession) Chain33Bridge() (common.Address, error)

+ func (_BridgeRegistry *BridgeRegistrySession) DeployHeight() (*big.Int, error)

+ func (_BridgeRegistry *BridgeRegistrySession) Oracle() (common.Address, error)

+ func (_BridgeRegistry *BridgeRegistrySession) Valset() (common.Address, error)

+ type BridgeRegistryTransactor struct

+ func NewBridgeRegistryTransactor(address common.Address, transactor bind.ContractTransactor) (*BridgeRegistryTransactor, error)

+ type BridgeRegistryTransactorRaw struct

+ Contract *BridgeRegistryTransactor

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

+ func (_BridgeRegistry *BridgeRegistryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BridgeRegistryTransactorSession struct

+ Contract *BridgeRegistryTransactor

+ TransactOpts bind.TransactOpts

+ type BridgeToken struct

+ func DeployBridgeToken(auth *bind.TransactOpts, backend bind.ContractBackend, _symbol string) (common.Address, *types.Transaction, *BridgeToken, error)

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

+ type BridgeTokenApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type BridgeTokenApprovalIterator struct

+ Event *BridgeTokenApproval

+ func (it *BridgeTokenApprovalIterator) Close() error

+ func (it *BridgeTokenApprovalIterator) Error() error

+ func (it *BridgeTokenApprovalIterator) Next() bool

+ type BridgeTokenCaller struct

+ func NewBridgeTokenCaller(address common.Address, caller bind.ContractCaller) (*BridgeTokenCaller, error)

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

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

+ func (_BridgeToken *BridgeTokenCaller) Decimals(opts *bind.CallOpts) (uint8, error)

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

+ func (_BridgeToken *BridgeTokenCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_BridgeToken *BridgeTokenCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_BridgeToken *BridgeTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type BridgeTokenCallerRaw struct

+ Contract *BridgeTokenCaller

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

+ type BridgeTokenCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *BridgeTokenCaller

+ func (_BridgeToken *BridgeTokenCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_BridgeToken *BridgeTokenCallerSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_BridgeToken *BridgeTokenCallerSession) Decimals() (uint8, error)

+ func (_BridgeToken *BridgeTokenCallerSession) IsMinter(account common.Address) (bool, error)

+ func (_BridgeToken *BridgeTokenCallerSession) Name() (string, error)

+ func (_BridgeToken *BridgeTokenCallerSession) Symbol() (string, error)

+ func (_BridgeToken *BridgeTokenCallerSession) TotalSupply() (*big.Int, error)

+ type BridgeTokenFilterer struct

+ func NewBridgeTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*BridgeTokenFilterer, error)

+ func (_BridgeToken *BridgeTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*BridgeTokenApprovalIterator, error)

+ func (_BridgeToken *BridgeTokenFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*BridgeTokenMinterAddedIterator, error)

+ func (_BridgeToken *BridgeTokenFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*BridgeTokenMinterRemovedIterator, error)

+ func (_BridgeToken *BridgeTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*BridgeTokenTransferIterator, error)

+ func (_BridgeToken *BridgeTokenFilterer) ParseApproval(log types.Log) (*BridgeTokenApproval, error)

+ func (_BridgeToken *BridgeTokenFilterer) ParseMinterAdded(log types.Log) (*BridgeTokenMinterAdded, error)

+ func (_BridgeToken *BridgeTokenFilterer) ParseMinterRemoved(log types.Log) (*BridgeTokenMinterRemoved, error)

+ func (_BridgeToken *BridgeTokenFilterer) ParseTransfer(log types.Log) (*BridgeTokenTransfer, error)

+ func (_BridgeToken *BridgeTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *BridgeTokenApproval, owner []common.Address, ...) (event.Subscription, error)

+ func (_BridgeToken *BridgeTokenFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *BridgeTokenMinterAdded, ...) (event.Subscription, error)

+ func (_BridgeToken *BridgeTokenFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *BridgeTokenMinterRemoved, ...) (event.Subscription, error)

+ func (_BridgeToken *BridgeTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *BridgeTokenTransfer, from []common.Address, ...) (event.Subscription, error)

+ type BridgeTokenMinterAdded struct

+ Account common.Address

+ Raw types.Log

+ type BridgeTokenMinterAddedIterator struct

+ Event *BridgeTokenMinterAdded

+ func (it *BridgeTokenMinterAddedIterator) Close() error

+ func (it *BridgeTokenMinterAddedIterator) Error() error

+ func (it *BridgeTokenMinterAddedIterator) Next() bool

+ type BridgeTokenMinterRemoved struct

+ Account common.Address

+ Raw types.Log

+ type BridgeTokenMinterRemovedIterator struct

+ Event *BridgeTokenMinterRemoved

+ func (it *BridgeTokenMinterRemovedIterator) Close() error

+ func (it *BridgeTokenMinterRemovedIterator) Error() error

+ func (it *BridgeTokenMinterRemovedIterator) Next() bool

+ type BridgeTokenRaw struct

+ Contract *BridgeToken

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

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

+ func (_BridgeToken *BridgeTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BridgeTokenSession struct

+ CallOpts bind.CallOpts

+ Contract *BridgeToken

+ TransactOpts bind.TransactOpts

+ func (_BridgeToken *BridgeTokenSession) AddMinter(account common.Address) (*types.Transaction, error)

+ func (_BridgeToken *BridgeTokenSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

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

+ func (_BridgeToken *BridgeTokenSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_BridgeToken *BridgeTokenSession) Burn(amount *big.Int) (*types.Transaction, error)

+ func (_BridgeToken *BridgeTokenSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_BridgeToken *BridgeTokenSession) Decimals() (uint8, error)

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

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

+ func (_BridgeToken *BridgeTokenSession) IsMinter(account common.Address) (bool, error)

+ func (_BridgeToken *BridgeTokenSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_BridgeToken *BridgeTokenSession) Name() (string, error)

+ func (_BridgeToken *BridgeTokenSession) RenounceMinter() (*types.Transaction, error)

+ func (_BridgeToken *BridgeTokenSession) Symbol() (string, error)

+ func (_BridgeToken *BridgeTokenSession) TotalSupply() (*big.Int, error)

+ func (_BridgeToken *BridgeTokenSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_BridgeToken *BridgeTokenSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ type BridgeTokenTransactor struct

+ func NewBridgeTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*BridgeTokenTransactor, error)

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

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

+ func (_BridgeToken *BridgeTokenTransactor) Burn(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error)

+ func (_BridgeToken *BridgeTokenTransactor) BurnFrom(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error)

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

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

+ func (_BridgeToken *BridgeTokenTransactor) Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_BridgeToken *BridgeTokenTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_BridgeToken *BridgeTokenTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_BridgeToken *BridgeTokenTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, ...) (*types.Transaction, error)

+ type BridgeTokenTransactorRaw struct

+ Contract *BridgeTokenTransactor

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

+ func (_BridgeToken *BridgeTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BridgeTokenTransactorSession struct

+ Contract *BridgeTokenTransactor

+ TransactOpts bind.TransactOpts

+ func (_BridgeToken *BridgeTokenTransactorSession) AddMinter(account common.Address) (*types.Transaction, error)

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

+ func (_BridgeToken *BridgeTokenTransactorSession) Burn(amount *big.Int) (*types.Transaction, error)

+ func (_BridgeToken *BridgeTokenTransactorSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error)

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

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

+ func (_BridgeToken *BridgeTokenTransactorSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_BridgeToken *BridgeTokenTransactorSession) RenounceMinter() (*types.Transaction, error)

+ func (_BridgeToken *BridgeTokenTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_BridgeToken *BridgeTokenTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ type BridgeTokenTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type BridgeTokenTransferIterator struct

+ Event *BridgeTokenTransfer

+ func (it *BridgeTokenTransferIterator) Close() error

+ func (it *BridgeTokenTransferIterator) Error() error

+ func (it *BridgeTokenTransferIterator) Next() bool

+ type Chain33Bank struct

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

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

+ type Chain33BankCaller struct

+ func NewChain33BankCaller(address common.Address, caller bind.ContractCaller) (*Chain33BankCaller, error)

+ func (_Chain33Bank *Chain33BankCaller) BridgeTokenCount(opts *bind.CallOpts) (*big.Int, error)

+ func (_Chain33Bank *Chain33BankCaller) BridgeTokenCreated(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ func (_Chain33Bank *Chain33BankCaller) BridgeTokenWhitelist(opts *bind.CallOpts, arg0 common.Address) (bool, error)

+ func (_Chain33Bank *Chain33BankCaller) GetToken2address(opts *bind.CallOpts, _symbol string) (common.Address, error)

+ func (_Chain33Bank *Chain33BankCaller) HasBridgeTokenCreated(opts *bind.CallOpts, _symbol string) (bool, error)

+ func (_Chain33Bank *Chain33BankCaller) Token2address(opts *bind.CallOpts, arg0 [32]byte) (common.Address, error)

+ type Chain33BankCallerRaw struct

+ Contract *Chain33BankCaller

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

+ type Chain33BankCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *Chain33BankCaller

+ func (_Chain33Bank *Chain33BankCallerSession) BridgeTokenCount() (*big.Int, error)

+ func (_Chain33Bank *Chain33BankCallerSession) BridgeTokenCreated(arg0 [32]byte) (bool, error)

+ func (_Chain33Bank *Chain33BankCallerSession) BridgeTokenWhitelist(arg0 common.Address) (bool, error)

+ func (_Chain33Bank *Chain33BankCallerSession) GetToken2address(_symbol string) (common.Address, error)

+ func (_Chain33Bank *Chain33BankCallerSession) HasBridgeTokenCreated(_symbol string) (bool, error)

+ func (_Chain33Bank *Chain33BankCallerSession) Token2address(arg0 [32]byte) (common.Address, error)

+ type Chain33BankFilterer struct

+ func NewChain33BankFilterer(address common.Address, filterer bind.ContractFilterer) (*Chain33BankFilterer, error)

+ func (_Chain33Bank *Chain33BankFilterer) FilterLogBridgeTokenMint(opts *bind.FilterOpts) (*Chain33BankLogBridgeTokenMintIterator, error)

+ func (_Chain33Bank *Chain33BankFilterer) FilterLogChain33TokenBurn(opts *bind.FilterOpts) (*Chain33BankLogChain33TokenBurnIterator, error)

+ func (_Chain33Bank *Chain33BankFilterer) FilterLogNewBridgeToken(opts *bind.FilterOpts) (*Chain33BankLogNewBridgeTokenIterator, error)

+ func (_Chain33Bank *Chain33BankFilterer) ParseLogBridgeTokenMint(log types.Log) (*Chain33BankLogBridgeTokenMint, error)

+ func (_Chain33Bank *Chain33BankFilterer) ParseLogChain33TokenBurn(log types.Log) (*Chain33BankLogChain33TokenBurn, error)

+ func (_Chain33Bank *Chain33BankFilterer) ParseLogNewBridgeToken(log types.Log) (*Chain33BankLogNewBridgeToken, error)

+ func (_Chain33Bank *Chain33BankFilterer) WatchLogBridgeTokenMint(opts *bind.WatchOpts, sink chan<- *Chain33BankLogBridgeTokenMint) (event.Subscription, error)

+ func (_Chain33Bank *Chain33BankFilterer) WatchLogChain33TokenBurn(opts *bind.WatchOpts, sink chan<- *Chain33BankLogChain33TokenBurn) (event.Subscription, error)

+ func (_Chain33Bank *Chain33BankFilterer) WatchLogNewBridgeToken(opts *bind.WatchOpts, sink chan<- *Chain33BankLogNewBridgeToken) (event.Subscription, error)

+ type Chain33BankLogBridgeTokenMint struct

+ Amount *big.Int

+ Beneficiary common.Address

+ Raw types.Log

+ Symbol string

+ Token common.Address

+ type Chain33BankLogBridgeTokenMintIterator struct

+ Event *Chain33BankLogBridgeTokenMint

+ func (it *Chain33BankLogBridgeTokenMintIterator) Close() error

+ func (it *Chain33BankLogBridgeTokenMintIterator) Error() error

+ func (it *Chain33BankLogBridgeTokenMintIterator) Next() bool

+ type Chain33BankLogChain33TokenBurn struct

+ Amount *big.Int

+ Chain33Receiver []byte

+ Nonce *big.Int

+ OwnerFrom common.Address

+ Raw types.Log

+ Symbol string

+ Token common.Address

+ type Chain33BankLogChain33TokenBurnIterator struct

+ Event *Chain33BankLogChain33TokenBurn

+ func (it *Chain33BankLogChain33TokenBurnIterator) Close() error

+ func (it *Chain33BankLogChain33TokenBurnIterator) Error() error

+ func (it *Chain33BankLogChain33TokenBurnIterator) Next() bool

+ type Chain33BankLogNewBridgeToken struct

+ Raw types.Log

+ Symbol string

+ Token common.Address

+ type Chain33BankLogNewBridgeTokenIterator struct

+ Event *Chain33BankLogNewBridgeToken

+ func (it *Chain33BankLogNewBridgeTokenIterator) Close() error

+ func (it *Chain33BankLogNewBridgeTokenIterator) Error() error

+ func (it *Chain33BankLogNewBridgeTokenIterator) Next() bool

+ type Chain33BankRaw struct

+ Contract *Chain33Bank

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

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

+ func (_Chain33Bank *Chain33BankRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type Chain33BankSession struct

+ CallOpts bind.CallOpts

+ Contract *Chain33Bank

+ TransactOpts bind.TransactOpts

+ func (_Chain33Bank *Chain33BankSession) BridgeTokenCount() (*big.Int, error)

+ func (_Chain33Bank *Chain33BankSession) BridgeTokenCreated(arg0 [32]byte) (bool, error)

+ func (_Chain33Bank *Chain33BankSession) BridgeTokenWhitelist(arg0 common.Address) (bool, error)

+ func (_Chain33Bank *Chain33BankSession) GetToken2address(_symbol string) (common.Address, error)

+ func (_Chain33Bank *Chain33BankSession) HasBridgeTokenCreated(_symbol string) (bool, error)

+ func (_Chain33Bank *Chain33BankSession) Token2address(arg0 [32]byte) (common.Address, error)

+ type Chain33BankTransactor struct

+ func NewChain33BankTransactor(address common.Address, transactor bind.ContractTransactor) (*Chain33BankTransactor, error)

+ type Chain33BankTransactorRaw struct

+ Contract *Chain33BankTransactor

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

+ func (_Chain33Bank *Chain33BankTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type Chain33BankTransactorSession struct

+ Contract *Chain33BankTransactor

+ TransactOpts bind.TransactOpts

+ type Chain33Bridge struct

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

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

+ type Chain33BridgeCaller struct

+ func NewChain33BridgeCaller(address common.Address, caller bind.ContractCaller) (*Chain33BridgeCaller, error)

+ func (_Chain33Bridge *Chain33BridgeCaller) BridgeBank(opts *bind.CallOpts) (common.Address, error)

+ func (_Chain33Bridge *Chain33BridgeCaller) HasBridgeBank(opts *bind.CallOpts) (bool, error)

+ func (_Chain33Bridge *Chain33BridgeCaller) HasOracle(opts *bind.CallOpts) (bool, error)

+ func (_Chain33Bridge *Chain33BridgeCaller) IsProphecyClaimActive(opts *bind.CallOpts, _claimID [32]byte) (bool, error)

+ func (_Chain33Bridge *Chain33BridgeCaller) IsProphecyClaimValidatorActive(opts *bind.CallOpts, _claimID [32]byte) (bool, error)

+ func (_Chain33Bridge *Chain33BridgeCaller) IsValidClaimType(opts *bind.CallOpts, _claimType uint8) (bool, error)

+ func (_Chain33Bridge *Chain33BridgeCaller) Operator(opts *bind.CallOpts) (common.Address, error)

+ func (_Chain33Bridge *Chain33BridgeCaller) Oracle(opts *bind.CallOpts) (common.Address, error)

+ func (_Chain33Bridge *Chain33BridgeCaller) ProphecyClaimCount(opts *bind.CallOpts) (*big.Int, error)

+ func (_Chain33Bridge *Chain33BridgeCaller) ProphecyClaims(opts *bind.CallOpts, arg0 [32]byte) (struct{ ... }, error)

+ func (_Chain33Bridge *Chain33BridgeCaller) Valset(opts *bind.CallOpts) (common.Address, error)

+ type Chain33BridgeCallerRaw struct

+ Contract *Chain33BridgeCaller

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

+ type Chain33BridgeCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *Chain33BridgeCaller

+ func (_Chain33Bridge *Chain33BridgeCallerSession) BridgeBank() (common.Address, error)

+ func (_Chain33Bridge *Chain33BridgeCallerSession) HasBridgeBank() (bool, error)

+ func (_Chain33Bridge *Chain33BridgeCallerSession) HasOracle() (bool, error)

+ func (_Chain33Bridge *Chain33BridgeCallerSession) IsProphecyClaimActive(_claimID [32]byte) (bool, error)

+ func (_Chain33Bridge *Chain33BridgeCallerSession) IsProphecyClaimValidatorActive(_claimID [32]byte) (bool, error)

+ func (_Chain33Bridge *Chain33BridgeCallerSession) IsValidClaimType(_claimType uint8) (bool, error)

+ func (_Chain33Bridge *Chain33BridgeCallerSession) Operator() (common.Address, error)

+ func (_Chain33Bridge *Chain33BridgeCallerSession) Oracle() (common.Address, error)

+ func (_Chain33Bridge *Chain33BridgeCallerSession) ProphecyClaimCount() (*big.Int, error)

+ func (_Chain33Bridge *Chain33BridgeCallerSession) ProphecyClaims(arg0 [32]byte) (struct{ ... }, error)

+ func (_Chain33Bridge *Chain33BridgeCallerSession) Valset() (common.Address, error)

+ type Chain33BridgeFilterer struct

+ func NewChain33BridgeFilterer(address common.Address, filterer bind.ContractFilterer) (*Chain33BridgeFilterer, error)

+ func (_Chain33Bridge *Chain33BridgeFilterer) FilterLogBridgeBankSet(opts *bind.FilterOpts) (*Chain33BridgeLogBridgeBankSetIterator, error)

+ func (_Chain33Bridge *Chain33BridgeFilterer) FilterLogNewProphecyClaim(opts *bind.FilterOpts) (*Chain33BridgeLogNewProphecyClaimIterator, error)

+ func (_Chain33Bridge *Chain33BridgeFilterer) FilterLogOracleSet(opts *bind.FilterOpts) (*Chain33BridgeLogOracleSetIterator, error)

+ func (_Chain33Bridge *Chain33BridgeFilterer) FilterLogProphecyCompleted(opts *bind.FilterOpts) (*Chain33BridgeLogProphecyCompletedIterator, error)

+ func (_Chain33Bridge *Chain33BridgeFilterer) ParseLogBridgeBankSet(log types.Log) (*Chain33BridgeLogBridgeBankSet, error)

+ func (_Chain33Bridge *Chain33BridgeFilterer) ParseLogNewProphecyClaim(log types.Log) (*Chain33BridgeLogNewProphecyClaim, error)

+ func (_Chain33Bridge *Chain33BridgeFilterer) ParseLogOracleSet(log types.Log) (*Chain33BridgeLogOracleSet, error)

+ func (_Chain33Bridge *Chain33BridgeFilterer) ParseLogProphecyCompleted(log types.Log) (*Chain33BridgeLogProphecyCompleted, error)

+ func (_Chain33Bridge *Chain33BridgeFilterer) WatchLogBridgeBankSet(opts *bind.WatchOpts, sink chan<- *Chain33BridgeLogBridgeBankSet) (event.Subscription, error)

+ func (_Chain33Bridge *Chain33BridgeFilterer) WatchLogNewProphecyClaim(opts *bind.WatchOpts, sink chan<- *Chain33BridgeLogNewProphecyClaim) (event.Subscription, error)

+ func (_Chain33Bridge *Chain33BridgeFilterer) WatchLogOracleSet(opts *bind.WatchOpts, sink chan<- *Chain33BridgeLogOracleSet) (event.Subscription, error)

+ func (_Chain33Bridge *Chain33BridgeFilterer) WatchLogProphecyCompleted(opts *bind.WatchOpts, sink chan<- *Chain33BridgeLogProphecyCompleted) (event.Subscription, error)

+ type Chain33BridgeLogBridgeBankSet struct

+ BridgeBank common.Address

+ Raw types.Log

+ type Chain33BridgeLogBridgeBankSetIterator struct

+ Event *Chain33BridgeLogBridgeBankSet

+ func (it *Chain33BridgeLogBridgeBankSetIterator) Close() error

+ func (it *Chain33BridgeLogBridgeBankSetIterator) Error() error

+ func (it *Chain33BridgeLogBridgeBankSetIterator) Next() bool

+ type Chain33BridgeLogNewProphecyClaim struct

+ Amount *big.Int

+ Chain33Sender []byte

+ ClaimType uint8

+ EthereumReceiver common.Address

+ ProphecyID *big.Int

+ Raw types.Log

+ Symbol string

+ TokenAddress common.Address

+ ValidatorAddress common.Address

+ type Chain33BridgeLogNewProphecyClaimIterator struct

+ Event *Chain33BridgeLogNewProphecyClaim

+ func (it *Chain33BridgeLogNewProphecyClaimIterator) Close() error

+ func (it *Chain33BridgeLogNewProphecyClaimIterator) Error() error

+ func (it *Chain33BridgeLogNewProphecyClaimIterator) Next() bool

+ type Chain33BridgeLogOracleSet struct

+ Oracle common.Address

+ Raw types.Log

+ type Chain33BridgeLogOracleSetIterator struct

+ Event *Chain33BridgeLogOracleSet

+ func (it *Chain33BridgeLogOracleSetIterator) Close() error

+ func (it *Chain33BridgeLogOracleSetIterator) Error() error

+ func (it *Chain33BridgeLogOracleSetIterator) Next() bool

+ type Chain33BridgeLogProphecyCompleted struct

+ ClaimID [32]byte

+ ClaimType uint8

+ Raw types.Log

+ type Chain33BridgeLogProphecyCompletedIterator struct

+ Event *Chain33BridgeLogProphecyCompleted

+ func (it *Chain33BridgeLogProphecyCompletedIterator) Close() error

+ func (it *Chain33BridgeLogProphecyCompletedIterator) Error() error

+ func (it *Chain33BridgeLogProphecyCompletedIterator) Next() bool

+ type Chain33BridgeRaw struct

+ Contract *Chain33Bridge

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

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

+ func (_Chain33Bridge *Chain33BridgeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type Chain33BridgeSession struct

+ CallOpts bind.CallOpts

+ Contract *Chain33Bridge

+ TransactOpts bind.TransactOpts

+ func (_Chain33Bridge *Chain33BridgeSession) BridgeBank() (common.Address, error)

+ func (_Chain33Bridge *Chain33BridgeSession) CompleteClaim(_claimID [32]byte) (*types.Transaction, error)

+ func (_Chain33Bridge *Chain33BridgeSession) HasBridgeBank() (bool, error)

+ func (_Chain33Bridge *Chain33BridgeSession) HasOracle() (bool, error)

+ func (_Chain33Bridge *Chain33BridgeSession) IsProphecyClaimActive(_claimID [32]byte) (bool, error)

+ func (_Chain33Bridge *Chain33BridgeSession) IsProphecyClaimValidatorActive(_claimID [32]byte) (bool, error)

+ func (_Chain33Bridge *Chain33BridgeSession) IsValidClaimType(_claimType uint8) (bool, error)

+ func (_Chain33Bridge *Chain33BridgeSession) Operator() (common.Address, error)

+ func (_Chain33Bridge *Chain33BridgeSession) Oracle() (common.Address, error)

+ func (_Chain33Bridge *Chain33BridgeSession) ProphecyClaimCount() (*big.Int, error)

+ func (_Chain33Bridge *Chain33BridgeSession) ProphecyClaims(arg0 [32]byte) (struct{ ... }, error)

+ func (_Chain33Bridge *Chain33BridgeSession) SetBridgeBank(_bridgeBank common.Address) (*types.Transaction, error)

+ func (_Chain33Bridge *Chain33BridgeSession) SetNewProphecyClaim(_claimID [32]byte, _claimType uint8, _chain33Sender []byte, ...) (*types.Transaction, error)

+ func (_Chain33Bridge *Chain33BridgeSession) SetOracle(_oracle common.Address) (*types.Transaction, error)

+ func (_Chain33Bridge *Chain33BridgeSession) Valset() (common.Address, error)

+ type Chain33BridgeTransactor struct

+ func NewChain33BridgeTransactor(address common.Address, transactor bind.ContractTransactor) (*Chain33BridgeTransactor, error)

+ func (_Chain33Bridge *Chain33BridgeTransactor) CompleteClaim(opts *bind.TransactOpts, _claimID [32]byte) (*types.Transaction, error)

+ func (_Chain33Bridge *Chain33BridgeTransactor) SetBridgeBank(opts *bind.TransactOpts, _bridgeBank common.Address) (*types.Transaction, error)

+ func (_Chain33Bridge *Chain33BridgeTransactor) SetNewProphecyClaim(opts *bind.TransactOpts, _claimID [32]byte, _claimType uint8, ...) (*types.Transaction, error)

+ func (_Chain33Bridge *Chain33BridgeTransactor) SetOracle(opts *bind.TransactOpts, _oracle common.Address) (*types.Transaction, error)

+ type Chain33BridgeTransactorRaw struct

+ Contract *Chain33BridgeTransactor

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

+ func (_Chain33Bridge *Chain33BridgeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type Chain33BridgeTransactorSession struct

+ Contract *Chain33BridgeTransactor

+ TransactOpts bind.TransactOpts

+ func (_Chain33Bridge *Chain33BridgeTransactorSession) CompleteClaim(_claimID [32]byte) (*types.Transaction, error)

+ func (_Chain33Bridge *Chain33BridgeTransactorSession) SetBridgeBank(_bridgeBank common.Address) (*types.Transaction, error)

+ func (_Chain33Bridge *Chain33BridgeTransactorSession) SetNewProphecyClaim(_claimID [32]byte, _claimType uint8, _chain33Sender []byte, ...) (*types.Transaction, error)

+ func (_Chain33Bridge *Chain33BridgeTransactorSession) SetOracle(_oracle common.Address) (*types.Transaction, error)

+ type Context struct

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

+ type ContextCaller struct

+ func NewContextCaller(address common.Address, caller bind.ContractCaller) (*ContextCaller, error)

+ type ContextCallerRaw struct

+ Contract *ContextCaller

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

+ type ContextCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ContextCaller

+ type ContextFilterer struct

+ func NewContextFilterer(address common.Address, filterer bind.ContractFilterer) (*ContextFilterer, error)

+ type ContextRaw struct

+ Contract *Context

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

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

+ func (_Context *ContextRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ContextSession struct

+ CallOpts bind.CallOpts

+ Contract *Context

+ TransactOpts bind.TransactOpts

+ type ContextTransactor struct

+ func NewContextTransactor(address common.Address, transactor bind.ContractTransactor) (*ContextTransactor, error)

+ type ContextTransactorRaw struct

+ Contract *ContextTransactor

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

+ func (_Context *ContextTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ContextTransactorSession struct

+ Contract *ContextTransactor

+ TransactOpts bind.TransactOpts

+ type ECDSA struct

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

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

+ type ECDSACaller struct

+ func NewECDSACaller(address common.Address, caller bind.ContractCaller) (*ECDSACaller, error)

+ type ECDSACallerRaw struct

+ Contract *ECDSACaller

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

+ type ECDSACallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ECDSACaller

+ type ECDSAFilterer struct

+ func NewECDSAFilterer(address common.Address, filterer bind.ContractFilterer) (*ECDSAFilterer, error)

+ type ECDSARaw struct

+ Contract *ECDSA

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

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

+ func (_ECDSA *ECDSARaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ECDSASession struct

+ CallOpts bind.CallOpts

+ Contract *ECDSA

+ TransactOpts bind.TransactOpts

+ type ECDSATransactor struct

+ func NewECDSATransactor(address common.Address, transactor bind.ContractTransactor) (*ECDSATransactor, error)

+ type ECDSATransactorRaw struct

+ Contract *ECDSATransactor

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

+ func (_ECDSA *ECDSATransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ECDSATransactorSession struct

+ Contract *ECDSATransactor

+ 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, account 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(account 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) ParseApproval(log types.Log) (*ERC20BurnableApproval, error)

+ func (_ERC20Burnable *ERC20BurnableFilterer) ParseTransfer(log types.Log) (*ERC20BurnableTransfer, 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, amount *big.Int) (*types.Transaction, error)

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

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

+ func (_ERC20Burnable *ERC20BurnableSession) BurnFrom(account common.Address, amount *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(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20Burnable *ERC20BurnableSession) TransferFrom(sender common.Address, recipient common.Address, amount *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, amount *big.Int) (*types.Transaction, error)

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

+ func (_ERC20Burnable *ERC20BurnableTransactor) BurnFrom(opts *bind.TransactOpts, account common.Address, amount *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, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20Burnable *ERC20BurnableTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient 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, amount *big.Int) (*types.Transaction, error)

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

+ func (_ERC20Burnable *ERC20BurnableTransactorSession) BurnFrom(account common.Address, amount *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(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20Burnable *ERC20BurnableTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *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, account 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(account common.Address) (*big.Int, error)

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

+ type ERC20Detailed struct

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

+ type ERC20DetailedApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type ERC20DetailedApprovalIterator struct

+ Event *ERC20DetailedApproval

+ func (it *ERC20DetailedApprovalIterator) Close() error

+ func (it *ERC20DetailedApprovalIterator) Error() error

+ func (it *ERC20DetailedApprovalIterator) Next() bool

+ type ERC20DetailedCaller struct

+ func NewERC20DetailedCaller(address common.Address, caller bind.ContractCaller) (*ERC20DetailedCaller, error)

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

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

+ func (_ERC20Detailed *ERC20DetailedCaller) Decimals(opts *bind.CallOpts) (uint8, error)

+ func (_ERC20Detailed *ERC20DetailedCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_ERC20Detailed *ERC20DetailedCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_ERC20Detailed *ERC20DetailedCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type ERC20DetailedCallerRaw struct

+ Contract *ERC20DetailedCaller

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

+ type ERC20DetailedCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC20DetailedCaller

+ func (_ERC20Detailed *ERC20DetailedCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_ERC20Detailed *ERC20DetailedCallerSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_ERC20Detailed *ERC20DetailedCallerSession) Decimals() (uint8, error)

+ func (_ERC20Detailed *ERC20DetailedCallerSession) Name() (string, error)

+ func (_ERC20Detailed *ERC20DetailedCallerSession) Symbol() (string, error)

+ func (_ERC20Detailed *ERC20DetailedCallerSession) TotalSupply() (*big.Int, error)

+ type ERC20DetailedFilterer struct

+ func NewERC20DetailedFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20DetailedFilterer, error)

+ func (_ERC20Detailed *ERC20DetailedFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20DetailedApprovalIterator, error)

+ func (_ERC20Detailed *ERC20DetailedFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20DetailedTransferIterator, error)

+ func (_ERC20Detailed *ERC20DetailedFilterer) ParseApproval(log types.Log) (*ERC20DetailedApproval, error)

+ func (_ERC20Detailed *ERC20DetailedFilterer) ParseTransfer(log types.Log) (*ERC20DetailedTransfer, error)

+ func (_ERC20Detailed *ERC20DetailedFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20DetailedApproval, ...) (event.Subscription, error)

+ func (_ERC20Detailed *ERC20DetailedFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20DetailedTransfer, ...) (event.Subscription, error)

+ type ERC20DetailedRaw struct

+ Contract *ERC20Detailed

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

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

+ func (_ERC20Detailed *ERC20DetailedRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20DetailedSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC20Detailed

+ TransactOpts bind.TransactOpts

+ func (_ERC20Detailed *ERC20DetailedSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

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

+ func (_ERC20Detailed *ERC20DetailedSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_ERC20Detailed *ERC20DetailedSession) Decimals() (uint8, error)

+ func (_ERC20Detailed *ERC20DetailedSession) Name() (string, error)

+ func (_ERC20Detailed *ERC20DetailedSession) Symbol() (string, error)

+ func (_ERC20Detailed *ERC20DetailedSession) TotalSupply() (*big.Int, error)

+ func (_ERC20Detailed *ERC20DetailedSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20Detailed *ERC20DetailedSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ type ERC20DetailedTransactor struct

+ func NewERC20DetailedTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20DetailedTransactor, error)

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

+ func (_ERC20Detailed *ERC20DetailedTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20Detailed *ERC20DetailedTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, ...) (*types.Transaction, error)

+ type ERC20DetailedTransactorRaw struct

+ Contract *ERC20DetailedTransactor

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

+ func (_ERC20Detailed *ERC20DetailedTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20DetailedTransactorSession struct

+ Contract *ERC20DetailedTransactor

+ TransactOpts bind.TransactOpts

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

+ func (_ERC20Detailed *ERC20DetailedTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20Detailed *ERC20DetailedTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ type ERC20DetailedTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type ERC20DetailedTransferIterator struct

+ Event *ERC20DetailedTransfer

+ func (it *ERC20DetailedTransferIterator) Close() error

+ func (it *ERC20DetailedTransferIterator) Error() error

+ func (it *ERC20DetailedTransferIterator) Next() bool

+ 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) ParseApproval(log types.Log) (*ERC20Approval, error)

+ func (_ERC20 *ERC20Filterer) ParseTransfer(log types.Log) (*ERC20Transfer, 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, account 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(account 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) ParseApproval(log types.Log) (*ERC20MintableApproval, error)

+ func (_ERC20Mintable *ERC20MintableFilterer) ParseMinterAdded(log types.Log) (*ERC20MintableMinterAdded, error)

+ func (_ERC20Mintable *ERC20MintableFilterer) ParseMinterRemoved(log types.Log) (*ERC20MintableMinterRemoved, error)

+ func (_ERC20Mintable *ERC20MintableFilterer) ParseTransfer(log types.Log) (*ERC20MintableTransfer, 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, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20Mintable *ERC20MintableSession) BalanceOf(account 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(account common.Address, amount *big.Int) (*types.Transaction, error)

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

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

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

+ func (_ERC20Mintable *ERC20MintableSession) TransferFrom(sender common.Address, recipient common.Address, amount *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, amount *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, account common.Address, amount *big.Int) (*types.Transaction, error)

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

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

+ func (_ERC20Mintable *ERC20MintableTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient 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, amount *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(account common.Address, amount *big.Int) (*types.Transaction, error)

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

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

+ func (_ERC20Mintable *ERC20MintableTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *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, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Session) BalanceOf(account 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(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Session) TransferFrom(sender common.Address, recipient common.Address, amount *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, amount *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, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Transactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient 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, amount *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(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20TransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *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 EthereumBank struct

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

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

+ type EthereumBankCaller struct

+ func NewEthereumBankCaller(address common.Address, caller bind.ContractCaller) (*EthereumBankCaller, error)

+ func (_EthereumBank *EthereumBankCaller) LockNonce(opts *bind.CallOpts) (*big.Int, error)

+ func (_EthereumBank *EthereumBankCaller) LockedFunds(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ type EthereumBankCallerRaw struct

+ Contract *EthereumBankCaller

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

+ type EthereumBankCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *EthereumBankCaller

+ func (_EthereumBank *EthereumBankCallerSession) LockNonce() (*big.Int, error)

+ func (_EthereumBank *EthereumBankCallerSession) LockedFunds(arg0 common.Address) (*big.Int, error)

+ type EthereumBankFilterer struct

+ func NewEthereumBankFilterer(address common.Address, filterer bind.ContractFilterer) (*EthereumBankFilterer, error)

+ func (_EthereumBank *EthereumBankFilterer) FilterLogLock(opts *bind.FilterOpts) (*EthereumBankLogLockIterator, error)

+ func (_EthereumBank *EthereumBankFilterer) FilterLogUnlock(opts *bind.FilterOpts) (*EthereumBankLogUnlockIterator, error)

+ func (_EthereumBank *EthereumBankFilterer) ParseLogLock(log types.Log) (*EthereumBankLogLock, error)

+ func (_EthereumBank *EthereumBankFilterer) ParseLogUnlock(log types.Log) (*EthereumBankLogUnlock, error)

+ func (_EthereumBank *EthereumBankFilterer) WatchLogLock(opts *bind.WatchOpts, sink chan<- *EthereumBankLogLock) (event.Subscription, error)

+ func (_EthereumBank *EthereumBankFilterer) WatchLogUnlock(opts *bind.WatchOpts, sink chan<- *EthereumBankLogUnlock) (event.Subscription, error)

+ type EthereumBankLogLock struct

+ From common.Address

+ Nonce *big.Int

+ Raw types.Log

+ Symbol string

+ To []byte

+ Token common.Address

+ Value *big.Int

+ type EthereumBankLogLockIterator struct

+ Event *EthereumBankLogLock

+ func (it *EthereumBankLogLockIterator) Close() error

+ func (it *EthereumBankLogLockIterator) Error() error

+ func (it *EthereumBankLogLockIterator) Next() bool

+ type EthereumBankLogUnlock struct

+ Raw types.Log

+ Symbol string

+ To common.Address

+ Token common.Address

+ Value *big.Int

+ type EthereumBankLogUnlockIterator struct

+ Event *EthereumBankLogUnlock

+ func (it *EthereumBankLogUnlockIterator) Close() error

+ func (it *EthereumBankLogUnlockIterator) Error() error

+ func (it *EthereumBankLogUnlockIterator) Next() bool

+ type EthereumBankRaw struct

+ Contract *EthereumBank

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

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

+ func (_EthereumBank *EthereumBankRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type EthereumBankSession struct

+ CallOpts bind.CallOpts

+ Contract *EthereumBank

+ TransactOpts bind.TransactOpts

+ func (_EthereumBank *EthereumBankSession) LockNonce() (*big.Int, error)

+ func (_EthereumBank *EthereumBankSession) LockedFunds(arg0 common.Address) (*big.Int, error)

+ type EthereumBankTransactor struct

+ func NewEthereumBankTransactor(address common.Address, transactor bind.ContractTransactor) (*EthereumBankTransactor, error)

+ type EthereumBankTransactorRaw struct

+ Contract *EthereumBankTransactor

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

+ func (_EthereumBank *EthereumBankTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type EthereumBankTransactorSession struct

+ Contract *EthereumBankTransactor

+ TransactOpts bind.TransactOpts

+ type IERC20 struct

+ 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 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, account 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(account 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) ParseApproval(log types.Log) (*IERC20Approval, error)

+ func (_IERC20 *IERC20Filterer) ParseTransfer(log types.Log) (*IERC20Transfer, 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, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20Session) BalanceOf(account common.Address) (*big.Int, error)

+ func (_IERC20 *IERC20Session) TotalSupply() (*big.Int, error)

+ func (_IERC20 *IERC20Session) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20Session) TransferFrom(sender common.Address, recipient common.Address, amount *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, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20Transactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20Transactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient 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, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20TransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20TransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *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 MinterRole struct

+ 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) ParseMinterAdded(log types.Log) (*MinterRoleMinterAdded, error)

+ func (_MinterRole *MinterRoleFilterer) ParseMinterRemoved(log types.Log) (*MinterRoleMinterRemoved, 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 Oracle struct

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

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

+ type OracleCaller struct

+ func NewOracleCaller(address common.Address, caller bind.ContractCaller) (*OracleCaller, error)

+ func (_Oracle *OracleCaller) Chain33Bridge(opts *bind.CallOpts) (common.Address, error)

+ func (_Oracle *OracleCaller) CheckBridgeProphecy(opts *bind.CallOpts, _claimID [32]byte) (bool, *big.Int, *big.Int, error)

+ func (_Oracle *OracleCaller) HasMadeClaim(opts *bind.CallOpts, arg0 [32]byte, arg1 common.Address) (bool, error)

+ func (_Oracle *OracleCaller) Operator(opts *bind.CallOpts) (common.Address, error)

+ func (_Oracle *OracleCaller) OracleClaimValidators(opts *bind.CallOpts, arg0 [32]byte, arg1 *big.Int) (common.Address, error)

+ func (_Oracle *OracleCaller) Valset(opts *bind.CallOpts) (common.Address, error)

+ type OracleCallerRaw struct

+ Contract *OracleCaller

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

+ type OracleCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OracleCaller

+ func (_Oracle *OracleCallerSession) Chain33Bridge() (common.Address, error)

+ func (_Oracle *OracleCallerSession) CheckBridgeProphecy(_claimID [32]byte) (bool, *big.Int, *big.Int, error)

+ func (_Oracle *OracleCallerSession) HasMadeClaim(arg0 [32]byte, arg1 common.Address) (bool, error)

+ func (_Oracle *OracleCallerSession) Operator() (common.Address, error)

+ func (_Oracle *OracleCallerSession) OracleClaimValidators(arg0 [32]byte, arg1 *big.Int) (common.Address, error)

+ func (_Oracle *OracleCallerSession) Valset() (common.Address, error)

+ type OracleFilterer struct

+ func NewOracleFilterer(address common.Address, filterer bind.ContractFilterer) (*OracleFilterer, error)

+ func (_Oracle *OracleFilterer) FilterLogNewOracleClaim(opts *bind.FilterOpts) (*OracleLogNewOracleClaimIterator, error)

+ func (_Oracle *OracleFilterer) FilterLogProphecyProcessed(opts *bind.FilterOpts) (*OracleLogProphecyProcessedIterator, error)

+ func (_Oracle *OracleFilterer) ParseLogNewOracleClaim(log types.Log) (*OracleLogNewOracleClaim, error)

+ func (_Oracle *OracleFilterer) ParseLogProphecyProcessed(log types.Log) (*OracleLogProphecyProcessed, error)

+ func (_Oracle *OracleFilterer) WatchLogNewOracleClaim(opts *bind.WatchOpts, sink chan<- *OracleLogNewOracleClaim) (event.Subscription, error)

+ func (_Oracle *OracleFilterer) WatchLogProphecyProcessed(opts *bind.WatchOpts, sink chan<- *OracleLogProphecyProcessed) (event.Subscription, error)

+ type OracleLogNewOracleClaim struct

+ ClaimID [32]byte

+ Raw types.Log

+ Signature []byte

+ ValidatorAddress common.Address

+ type OracleLogNewOracleClaimIterator struct

+ Event *OracleLogNewOracleClaim

+ func (it *OracleLogNewOracleClaimIterator) Close() error

+ func (it *OracleLogNewOracleClaimIterator) Error() error

+ func (it *OracleLogNewOracleClaimIterator) Next() bool

+ type OracleLogProphecyProcessed struct

+ ClaimID [32]byte

+ Raw types.Log

+ Submitter common.Address

+ WeightedSignedPower *big.Int

+ WeightedTotalPower *big.Int

+ type OracleLogProphecyProcessedIterator struct

+ Event *OracleLogProphecyProcessed

+ func (it *OracleLogProphecyProcessedIterator) Close() error

+ func (it *OracleLogProphecyProcessedIterator) Error() error

+ func (it *OracleLogProphecyProcessedIterator) Next() bool

+ type OracleRaw struct

+ Contract *Oracle

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

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

+ func (_Oracle *OracleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OracleSession struct

+ CallOpts bind.CallOpts

+ Contract *Oracle

+ TransactOpts bind.TransactOpts

+ func (_Oracle *OracleSession) Chain33Bridge() (common.Address, error)

+ func (_Oracle *OracleSession) CheckBridgeProphecy(_claimID [32]byte) (bool, *big.Int, *big.Int, error)

+ func (_Oracle *OracleSession) HasMadeClaim(arg0 [32]byte, arg1 common.Address) (bool, error)

+ func (_Oracle *OracleSession) NewOracleClaim(_claimType uint8, _chain33Sender []byte, _ethereumReceiver common.Address, ...) (*types.Transaction, error)

+ func (_Oracle *OracleSession) Operator() (common.Address, error)

+ func (_Oracle *OracleSession) OracleClaimValidators(arg0 [32]byte, arg1 *big.Int) (common.Address, error)

+ func (_Oracle *OracleSession) Valset() (common.Address, error)

+ type OracleTransactor struct

+ func NewOracleTransactor(address common.Address, transactor bind.ContractTransactor) (*OracleTransactor, error)

+ func (_Oracle *OracleTransactor) NewOracleClaim(opts *bind.TransactOpts, _claimType uint8, _chain33Sender []byte, ...) (*types.Transaction, error)

+ type OracleTransactorRaw struct

+ Contract *OracleTransactor

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

+ func (_Oracle *OracleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OracleTransactorSession struct

+ Contract *OracleTransactor

+ TransactOpts bind.TransactOpts

+ func (_Oracle *OracleTransactorSession) NewOracleClaim(_claimType uint8, _chain33Sender []byte, _ethereumReceiver 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

+ type Valset struct

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

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

+ type ValsetCaller struct

+ func NewValsetCaller(address common.Address, caller bind.ContractCaller) (*ValsetCaller, error)

+ func (_Valset *ValsetCaller) CurrentValsetVersion(opts *bind.CallOpts) (*big.Int, error)

+ func (_Valset *ValsetCaller) DebugEthMessageHash(opts *bind.CallOpts, hash [32]byte) ([32]byte, error)

+ func (_Valset *ValsetCaller) DebugPacked(opts *bind.CallOpts, hash [32]byte) ([]byte, error)

+ func (_Valset *ValsetCaller) GetValidatorPower(opts *bind.CallOpts, _validatorAddress common.Address) (*big.Int, error)

+ func (_Valset *ValsetCaller) IsActiveValidator(opts *bind.CallOpts, _validatorAddress common.Address) (bool, error)

+ func (_Valset *ValsetCaller) Operator(opts *bind.CallOpts) (common.Address, error)

+ func (_Valset *ValsetCaller) Powers(opts *bind.CallOpts, arg0 [32]byte) (*big.Int, error)

+ func (_Valset *ValsetCaller) Recover(opts *bind.CallOpts, _message [32]byte, _signature []byte) (common.Address, error)

+ func (_Valset *ValsetCaller) TotalPower(opts *bind.CallOpts) (*big.Int, error)

+ func (_Valset *ValsetCaller) ValidatorCount(opts *bind.CallOpts) (*big.Int, error)

+ func (_Valset *ValsetCaller) Validators(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ type ValsetCallerRaw struct

+ Contract *ValsetCaller

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

+ type ValsetCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ValsetCaller

+ func (_Valset *ValsetCallerSession) CurrentValsetVersion() (*big.Int, error)

+ func (_Valset *ValsetCallerSession) DebugEthMessageHash(hash [32]byte) ([32]byte, error)

+ func (_Valset *ValsetCallerSession) DebugPacked(hash [32]byte) ([]byte, error)

+ func (_Valset *ValsetCallerSession) GetValidatorPower(_validatorAddress common.Address) (*big.Int, error)

+ func (_Valset *ValsetCallerSession) IsActiveValidator(_validatorAddress common.Address) (bool, error)

+ func (_Valset *ValsetCallerSession) Operator() (common.Address, error)

+ func (_Valset *ValsetCallerSession) Powers(arg0 [32]byte) (*big.Int, error)

+ func (_Valset *ValsetCallerSession) Recover(_message [32]byte, _signature []byte) (common.Address, error)

+ func (_Valset *ValsetCallerSession) TotalPower() (*big.Int, error)

+ func (_Valset *ValsetCallerSession) ValidatorCount() (*big.Int, error)

+ func (_Valset *ValsetCallerSession) Validators(arg0 [32]byte) (bool, error)

+ type ValsetFilterer struct

+ func NewValsetFilterer(address common.Address, filterer bind.ContractFilterer) (*ValsetFilterer, error)

+ func (_Valset *ValsetFilterer) FilterLogValidatorAdded(opts *bind.FilterOpts) (*ValsetLogValidatorAddedIterator, error)

+ func (_Valset *ValsetFilterer) FilterLogValidatorPowerUpdated(opts *bind.FilterOpts) (*ValsetLogValidatorPowerUpdatedIterator, error)

+ func (_Valset *ValsetFilterer) FilterLogValidatorRemoved(opts *bind.FilterOpts) (*ValsetLogValidatorRemovedIterator, error)

+ func (_Valset *ValsetFilterer) FilterLogValsetReset(opts *bind.FilterOpts) (*ValsetLogValsetResetIterator, error)

+ func (_Valset *ValsetFilterer) FilterLogValsetUpdated(opts *bind.FilterOpts) (*ValsetLogValsetUpdatedIterator, error)

+ func (_Valset *ValsetFilterer) ParseLogValidatorAdded(log types.Log) (*ValsetLogValidatorAdded, error)

+ func (_Valset *ValsetFilterer) ParseLogValidatorPowerUpdated(log types.Log) (*ValsetLogValidatorPowerUpdated, error)

+ func (_Valset *ValsetFilterer) ParseLogValidatorRemoved(log types.Log) (*ValsetLogValidatorRemoved, error)

+ func (_Valset *ValsetFilterer) ParseLogValsetReset(log types.Log) (*ValsetLogValsetReset, error)

+ func (_Valset *ValsetFilterer) ParseLogValsetUpdated(log types.Log) (*ValsetLogValsetUpdated, error)

+ func (_Valset *ValsetFilterer) WatchLogValidatorAdded(opts *bind.WatchOpts, sink chan<- *ValsetLogValidatorAdded) (event.Subscription, error)

+ func (_Valset *ValsetFilterer) WatchLogValidatorPowerUpdated(opts *bind.WatchOpts, sink chan<- *ValsetLogValidatorPowerUpdated) (event.Subscription, error)

+ func (_Valset *ValsetFilterer) WatchLogValidatorRemoved(opts *bind.WatchOpts, sink chan<- *ValsetLogValidatorRemoved) (event.Subscription, error)

+ func (_Valset *ValsetFilterer) WatchLogValsetReset(opts *bind.WatchOpts, sink chan<- *ValsetLogValsetReset) (event.Subscription, error)

+ func (_Valset *ValsetFilterer) WatchLogValsetUpdated(opts *bind.WatchOpts, sink chan<- *ValsetLogValsetUpdated) (event.Subscription, error)

+ type ValsetLogValidatorAdded struct

+ CurrentValsetVersion *big.Int

+ Power *big.Int

+ Raw types.Log

+ TotalPower *big.Int

+ Validator common.Address

+ ValidatorCount *big.Int

+ type ValsetLogValidatorAddedIterator struct

+ Event *ValsetLogValidatorAdded

+ func (it *ValsetLogValidatorAddedIterator) Close() error

+ func (it *ValsetLogValidatorAddedIterator) Error() error

+ func (it *ValsetLogValidatorAddedIterator) Next() bool

+ type ValsetLogValidatorPowerUpdated struct

+ CurrentValsetVersion *big.Int

+ Power *big.Int

+ Raw types.Log

+ TotalPower *big.Int

+ Validator common.Address

+ ValidatorCount *big.Int

+ type ValsetLogValidatorPowerUpdatedIterator struct

+ Event *ValsetLogValidatorPowerUpdated

+ func (it *ValsetLogValidatorPowerUpdatedIterator) Close() error

+ func (it *ValsetLogValidatorPowerUpdatedIterator) Error() error

+ func (it *ValsetLogValidatorPowerUpdatedIterator) Next() bool

+ type ValsetLogValidatorRemoved struct

+ CurrentValsetVersion *big.Int

+ Power *big.Int

+ Raw types.Log

+ TotalPower *big.Int

+ Validator common.Address

+ ValidatorCount *big.Int

+ type ValsetLogValidatorRemovedIterator struct

+ Event *ValsetLogValidatorRemoved

+ func (it *ValsetLogValidatorRemovedIterator) Close() error

+ func (it *ValsetLogValidatorRemovedIterator) Error() error

+ func (it *ValsetLogValidatorRemovedIterator) Next() bool

+ type ValsetLogValsetReset struct

+ NewValsetVersion *big.Int

+ Raw types.Log

+ TotalPower *big.Int

+ ValidatorCount *big.Int

+ type ValsetLogValsetResetIterator struct

+ Event *ValsetLogValsetReset

+ func (it *ValsetLogValsetResetIterator) Close() error

+ func (it *ValsetLogValsetResetIterator) Error() error

+ func (it *ValsetLogValsetResetIterator) Next() bool

+ type ValsetLogValsetUpdated struct

+ NewValsetVersion *big.Int

+ Raw types.Log

+ TotalPower *big.Int

+ ValidatorCount *big.Int

+ type ValsetLogValsetUpdatedIterator struct

+ Event *ValsetLogValsetUpdated

+ func (it *ValsetLogValsetUpdatedIterator) Close() error

+ func (it *ValsetLogValsetUpdatedIterator) Error() error

+ func (it *ValsetLogValsetUpdatedIterator) Next() bool

+ type ValsetRaw struct

+ Contract *Valset

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

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

+ func (_Valset *ValsetRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ValsetSession struct

+ CallOpts bind.CallOpts

+ Contract *Valset

+ TransactOpts bind.TransactOpts

+ func (_Valset *ValsetSession) AddValidator(_validatorAddress common.Address, _validatorPower *big.Int) (*types.Transaction, error)

+ func (_Valset *ValsetSession) CurrentValsetVersion() (*big.Int, error)

+ func (_Valset *ValsetSession) DebugEthMessageHash(hash [32]byte) ([32]byte, error)

+ func (_Valset *ValsetSession) DebugPacked(hash [32]byte) ([]byte, error)

+ func (_Valset *ValsetSession) GetValidatorPower(_validatorAddress common.Address) (*big.Int, error)

+ func (_Valset *ValsetSession) IsActiveValidator(_validatorAddress common.Address) (bool, error)

+ func (_Valset *ValsetSession) Operator() (common.Address, error)

+ func (_Valset *ValsetSession) Powers(arg0 [32]byte) (*big.Int, error)

+ func (_Valset *ValsetSession) Recover(_message [32]byte, _signature []byte) (common.Address, error)

+ func (_Valset *ValsetSession) RecoverGas(_valsetVersion *big.Int, _validatorAddress common.Address) (*types.Transaction, error)

+ func (_Valset *ValsetSession) RemoveValidator(_validatorAddress common.Address) (*types.Transaction, error)

+ func (_Valset *ValsetSession) TotalPower() (*big.Int, error)

+ func (_Valset *ValsetSession) UpdateValidatorPower(_validatorAddress common.Address, _newValidatorPower *big.Int) (*types.Transaction, error)

+ func (_Valset *ValsetSession) UpdateValset(_validators []common.Address, _powers []*big.Int) (*types.Transaction, error)

+ func (_Valset *ValsetSession) ValidatorCount() (*big.Int, error)

+ func (_Valset *ValsetSession) Validators(arg0 [32]byte) (bool, error)

+ type ValsetTransactor struct

+ func NewValsetTransactor(address common.Address, transactor bind.ContractTransactor) (*ValsetTransactor, error)

+ func (_Valset *ValsetTransactor) AddValidator(opts *bind.TransactOpts, _validatorAddress common.Address, ...) (*types.Transaction, error)

+ func (_Valset *ValsetTransactor) RecoverGas(opts *bind.TransactOpts, _valsetVersion *big.Int, ...) (*types.Transaction, error)

+ func (_Valset *ValsetTransactor) RemoveValidator(opts *bind.TransactOpts, _validatorAddress common.Address) (*types.Transaction, error)

+ func (_Valset *ValsetTransactor) UpdateValidatorPower(opts *bind.TransactOpts, _validatorAddress common.Address, ...) (*types.Transaction, error)

+ func (_Valset *ValsetTransactor) UpdateValset(opts *bind.TransactOpts, _validators []common.Address, _powers []*big.Int) (*types.Transaction, error)

+ type ValsetTransactorRaw struct

+ Contract *ValsetTransactor

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

+ func (_Valset *ValsetTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ValsetTransactorSession struct

+ Contract *ValsetTransactor

+ TransactOpts bind.TransactOpts

+ func (_Valset *ValsetTransactorSession) AddValidator(_validatorAddress common.Address, _validatorPower *big.Int) (*types.Transaction, error)

+ func (_Valset *ValsetTransactorSession) RecoverGas(_valsetVersion *big.Int, _validatorAddress common.Address) (*types.Transaction, error)

+ func (_Valset *ValsetTransactorSession) RemoveValidator(_validatorAddress common.Address) (*types.Transaction, error)

+ func (_Valset *ValsetTransactorSession) UpdateValidatorPower(_validatorAddress common.Address, _newValidatorPower *big.Int) (*types.Transaction, error)

+ func (_Valset *ValsetTransactorSession) UpdateValset(_validators []common.Address, _powers []*big.Int) (*types.Transaction, error)

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL