bindings

package

Go to main page

Versions in this module

v2

v2.3.1

Jan 7, 2020

Changes in this version

type WalletCaller

+ func (_Wallet *WalletCaller) IsValidSignature(opts *bind.CallOpts, _hashedData [32]byte, _signature []byte) ([4]byte, error)

+ func (_Wallet *WalletCaller) IsValidSignature0(opts *bind.CallOpts, _data []byte, _signature []byte) ([4]byte, error)

type WalletCallerSession

+ func (_Wallet *WalletCallerSession) IsValidSignature(_hashedData [32]byte, _signature []byte) ([4]byte, error)

+ func (_Wallet *WalletCallerSession) IsValidSignature0(_data []byte, _signature []byte) ([4]byte, error)

type WalletSession

+ func (_Wallet *WalletSession) BatchExecuteTransaction(_transactionBatch []byte) (*types.Transaction, error)

+ func (_Wallet *WalletSession) IncreaseRelayNonce() (*types.Transaction, error)

+ func (_Wallet *WalletSession) IsValidSignature(_hashedData [32]byte, _signature []byte) ([4]byte, error)

+ func (_Wallet *WalletSession) IsValidSignature0(_data []byte, _signature []byte) ([4]byte, error)

type WalletTransactor

+ func (_Wallet *WalletTransactor) BatchExecuteTransaction(opts *bind.TransactOpts, _transactionBatch []byte) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) IncreaseRelayNonce(opts *bind.TransactOpts) (*types.Transaction, error)

type WalletTransactorSession

+ func (_Wallet *WalletTransactorSession) BatchExecuteTransaction(_transactionBatch []byte) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) IncreaseRelayNonce() (*types.Transaction, error)

v2.3.0

Nov 12, 2019

Changes in this version

+ const WalletCacheABI

type ControllerFilterer

+ func (_Controller *ControllerFilterer) ParseAddedAdmin(log types.Log) (*ControllerAddedAdmin, error)

+ func (_Controller *ControllerFilterer) ParseAddedController(log types.Log) (*ControllerAddedController, error)

+ func (_Controller *ControllerFilterer) ParseClaimed(log types.Log) (*ControllerClaimed, error)

+ func (_Controller *ControllerFilterer) ParseLockedOwnership(log types.Log) (*ControllerLockedOwnership, error)

+ func (_Controller *ControllerFilterer) ParseRemovedAdmin(log types.Log) (*ControllerRemovedAdmin, error)

+ func (_Controller *ControllerFilterer) ParseRemovedController(log types.Log) (*ControllerRemovedController, error)

+ func (_Controller *ControllerFilterer) ParseStarted(log types.Log) (*ControllerStarted, error)

+ func (_Controller *ControllerFilterer) ParseStopped(log types.Log) (*ControllerStopped, error)

+ func (_Controller *ControllerFilterer) ParseTransferredOwnership(log types.Log) (*ControllerTransferredOwnership, error)

type HolderFilterer

+ func (_Holder *HolderFilterer) ParseCashAndBurned(log types.Log) (*HolderCashAndBurned, error)

+ func (_Holder *HolderFilterer) ParseClaimed(log types.Log) (*HolderClaimed, error)

+ func (_Holder *HolderFilterer) ParseReceived(log types.Log) (*HolderReceived, error)

type LicenceFilterer

+ func (_Licence *LicenceFilterer) ParseClaimed(log types.Log) (*LicenceClaimed, error)

+ func (_Licence *LicenceFilterer) ParseTransferredToCryptoFloat(log types.Log) (*LicenceTransferredToCryptoFloat, error)

+ func (_Licence *LicenceFilterer) ParseTransferredToTokenHolder(log types.Log) (*LicenceTransferredToTokenHolder, error)

+ func (_Licence *LicenceFilterer) ParseUpdatedCryptoFloat(log types.Log) (*LicenceUpdatedCryptoFloat, error)

+ func (_Licence *LicenceFilterer) ParseUpdatedLicenceAmount(log types.Log) (*LicenceUpdatedLicenceAmount, error)

+ func (_Licence *LicenceFilterer) ParseUpdatedLicenceDAO(log types.Log) (*LicenceUpdatedLicenceDAO, error)

+ func (_Licence *LicenceFilterer) ParseUpdatedTKNContractAddress(log types.Log) (*LicenceUpdatedTKNContractAddress, error)

+ func (_Licence *LicenceFilterer) ParseUpdatedTokenHolder(log types.Log) (*LicenceUpdatedTokenHolder, error)

type OracleFilterer

+ func (_Oracle *OracleFilterer) ParseClaimed(log types.Log) (*OracleClaimed, error)

+ func (_Oracle *OracleFilterer) ParseFailedUpdateRequest(log types.Log) (*OracleFailedUpdateRequest, error)

+ func (_Oracle *OracleFilterer) ParseRequestedUpdate(log types.Log) (*OracleRequestedUpdate, error)

+ func (_Oracle *OracleFilterer) ParseSetCryptoComparePublicKey(log types.Log) (*OracleSetCryptoComparePublicKey, error)

+ func (_Oracle *OracleFilterer) ParseSetGasPrice(log types.Log) (*OracleSetGasPrice, error)

+ func (_Oracle *OracleFilterer) ParseVerifiedProof(log types.Log) (*OracleVerifiedProof, error)

type TokenWhitelistFilterer

+ func (_TokenWhitelist *TokenWhitelistFilterer) ParseAddedExclusiveMethod(log types.Log) (*TokenWhitelistAddedExclusiveMethod, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) ParseAddedMethodId(log types.Log) (*TokenWhitelistAddedMethodId, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) ParseAddedToken(log types.Log) (*TokenWhitelistAddedToken, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) ParseClaimed(log types.Log) (*TokenWhitelistClaimed, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) ParseRemovedExclusiveMethod(log types.Log) (*TokenWhitelistRemovedExclusiveMethod, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) ParseRemovedMethodId(log types.Log) (*TokenWhitelistRemovedMethodId, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) ParseRemovedToken(log types.Log) (*TokenWhitelistRemovedToken, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) ParseUpdatedTokenLoadable(log types.Log) (*TokenWhitelistUpdatedTokenLoadable, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) ParseUpdatedTokenRate(log types.Log) (*TokenWhitelistUpdatedTokenRate, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) ParseUpdatedTokenRedeemable(log types.Log) (*TokenWhitelistUpdatedTokenRedeemable, error)

+ type WalletCache struct

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

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

+ type WalletCacheCachedWallet struct

+ Raw types.Log

+ Wallet common.Address

+ type WalletCacheCachedWalletIterator struct

+ Event *WalletCacheCachedWallet

+ func (it *WalletCacheCachedWalletIterator) Close() error

+ func (it *WalletCacheCachedWalletIterator) Error() error

+ func (it *WalletCacheCachedWalletIterator) Next() bool

+ type WalletCacheCaller struct

+ func NewWalletCacheCaller(address common.Address, caller bind.ContractCaller) (*WalletCacheCaller, error)

+ func (_WalletCache *WalletCacheCaller) CachedWallets(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error)

+ func (_WalletCache *WalletCacheCaller) CachedWalletsCount(opts *bind.CallOpts) (*big.Int, error)

+ func (_WalletCache *WalletCacheCaller) ControllerNode(opts *bind.CallOpts) ([32]byte, error)

+ func (_WalletCache *WalletCacheCaller) DefaultSpendLimit(opts *bind.CallOpts) (*big.Int, error)

+ func (_WalletCache *WalletCacheCaller) Ens(opts *bind.CallOpts) (common.Address, error)

+ func (_WalletCache *WalletCacheCaller) EnsRegistry(opts *bind.CallOpts) (common.Address, error)

+ func (_WalletCache *WalletCacheCaller) LicenceNode(opts *bind.CallOpts) ([32]byte, error)

+ func (_WalletCache *WalletCacheCaller) TokenWhitelistNode(opts *bind.CallOpts) ([32]byte, error)

+ func (_WalletCache *WalletCacheCaller) WalletDeployerNode(opts *bind.CallOpts) ([32]byte, error)

+ type WalletCacheCallerRaw struct

+ Contract *WalletCacheCaller

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

+ type WalletCacheCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *WalletCacheCaller

+ func (_WalletCache *WalletCacheCallerSession) CachedWallets(arg0 *big.Int) (common.Address, error)

+ func (_WalletCache *WalletCacheCallerSession) CachedWalletsCount() (*big.Int, error)

+ func (_WalletCache *WalletCacheCallerSession) ControllerNode() ([32]byte, error)

+ func (_WalletCache *WalletCacheCallerSession) DefaultSpendLimit() (*big.Int, error)

+ func (_WalletCache *WalletCacheCallerSession) Ens() (common.Address, error)

+ func (_WalletCache *WalletCacheCallerSession) EnsRegistry() (common.Address, error)

+ func (_WalletCache *WalletCacheCallerSession) LicenceNode() ([32]byte, error)

+ func (_WalletCache *WalletCacheCallerSession) TokenWhitelistNode() ([32]byte, error)

+ func (_WalletCache *WalletCacheCallerSession) WalletDeployerNode() ([32]byte, error)

+ type WalletCacheFilterer struct

+ func NewWalletCacheFilterer(address common.Address, filterer bind.ContractFilterer) (*WalletCacheFilterer, error)

+ func (_WalletCache *WalletCacheFilterer) FilterCachedWallet(opts *bind.FilterOpts) (*WalletCacheCachedWalletIterator, error)

+ func (_WalletCache *WalletCacheFilterer) ParseCachedWallet(log types.Log) (*WalletCacheCachedWallet, error)

+ func (_WalletCache *WalletCacheFilterer) WatchCachedWallet(opts *bind.WatchOpts, sink chan<- *WalletCacheCachedWallet) (event.Subscription, error)

+ type WalletCacheRaw struct

+ Contract *WalletCache

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

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

+ func (_WalletCache *WalletCacheRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type WalletCacheSession struct

+ CallOpts bind.CallOpts

+ Contract *WalletCache

+ TransactOpts bind.TransactOpts

+ func (_WalletCache *WalletCacheSession) CacheWallet() (*types.Transaction, error)

+ func (_WalletCache *WalletCacheSession) CachedWallets(arg0 *big.Int) (common.Address, error)

+ func (_WalletCache *WalletCacheSession) CachedWalletsCount() (*big.Int, error)

+ func (_WalletCache *WalletCacheSession) ControllerNode() ([32]byte, error)

+ func (_WalletCache *WalletCacheSession) DefaultSpendLimit() (*big.Int, error)

+ func (_WalletCache *WalletCacheSession) Ens() (common.Address, error)

+ func (_WalletCache *WalletCacheSession) EnsRegistry() (common.Address, error)

+ func (_WalletCache *WalletCacheSession) LicenceNode() ([32]byte, error)

+ func (_WalletCache *WalletCacheSession) TokenWhitelistNode() ([32]byte, error)

+ func (_WalletCache *WalletCacheSession) WalletCachePop() (*types.Transaction, error)

+ func (_WalletCache *WalletCacheSession) WalletDeployerNode() ([32]byte, error)

+ type WalletCacheTransactor struct

+ func NewWalletCacheTransactor(address common.Address, transactor bind.ContractTransactor) (*WalletCacheTransactor, error)

+ func (_WalletCache *WalletCacheTransactor) CacheWallet(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_WalletCache *WalletCacheTransactor) WalletCachePop(opts *bind.TransactOpts) (*types.Transaction, error)

+ type WalletCacheTransactorRaw struct

+ Contract *WalletCacheTransactor

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

+ func (_WalletCache *WalletCacheTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type WalletCacheTransactorSession struct

+ Contract *WalletCacheTransactor

+ TransactOpts bind.TransactOpts

+ func (_WalletCache *WalletCacheTransactorSession) CacheWallet() (*types.Transaction, error)

+ func (_WalletCache *WalletCacheTransactorSession) WalletCachePop() (*types.Transaction, error)

type WalletCaller

+ func (_Wallet *WalletCaller) RelayNonce(opts *bind.CallOpts) (*big.Int, error)

type WalletCallerSession

+ func (_Wallet *WalletCallerSession) RelayNonce() (*big.Int, error)

type WalletDeployerCaller

+ func (_WalletDeployer *WalletDeployerCaller) WalletCacheNode(opts *bind.CallOpts) ([32]byte, error)

type WalletDeployerCallerSession

+ func (_WalletDeployer *WalletDeployerCallerSession) WalletCacheNode() ([32]byte, error)

type WalletDeployerFilterer

+ func (_WalletDeployer *WalletDeployerFilterer) ParseDeployedWallet(log types.Log) (*WalletDeployerDeployedWallet, error)

+ func (_WalletDeployer *WalletDeployerFilterer) ParseMigratedWallet(log types.Log) (*WalletDeployerMigratedWallet, error)

type WalletDeployerSession

+ func (_WalletDeployer *WalletDeployerSession) WalletCacheNode() ([32]byte, error)

+ type WalletExecutedRelayedTransaction struct

+ Data []byte

+ Raw types.Log

+ Returndata []byte

+ type WalletExecutedRelayedTransactionIterator struct

+ Event *WalletExecutedRelayedTransaction

+ func (it *WalletExecutedRelayedTransactionIterator) Close() error

+ func (it *WalletExecutedRelayedTransactionIterator) Error() error

+ func (it *WalletExecutedRelayedTransactionIterator) Next() bool

type WalletFilterer

+ func (_Wallet *WalletFilterer) FilterExecutedRelayedTransaction(opts *bind.FilterOpts) (*WalletExecutedRelayedTransactionIterator, error)

+ func (_Wallet *WalletFilterer) ParseAddedToWhitelist(log types.Log) (*WalletAddedToWhitelist, error)

+ func (_Wallet *WalletFilterer) ParseBulkTransferred(log types.Log) (*WalletBulkTransferred, error)

+ func (_Wallet *WalletFilterer) ParseCancelledWhitelistAddition(log types.Log) (*WalletCancelledWhitelistAddition, error)

+ func (_Wallet *WalletFilterer) ParseCancelledWhitelistRemoval(log types.Log) (*WalletCancelledWhitelistRemoval, error)

+ func (_Wallet *WalletFilterer) ParseExecutedRelayedTransaction(log types.Log) (*WalletExecutedRelayedTransaction, error)

+ func (_Wallet *WalletFilterer) ParseExecutedTransaction(log types.Log) (*WalletExecutedTransaction, error)

+ func (_Wallet *WalletFilterer) ParseLoadedTokenCard(log types.Log) (*WalletLoadedTokenCard, error)

+ func (_Wallet *WalletFilterer) ParseLockedOwnership(log types.Log) (*WalletLockedOwnership, error)

+ func (_Wallet *WalletFilterer) ParseReceived(log types.Log) (*WalletReceived, error)

+ func (_Wallet *WalletFilterer) ParseRemovedFromWhitelist(log types.Log) (*WalletRemovedFromWhitelist, error)

+ func (_Wallet *WalletFilterer) ParseSetGasTopUpLimit(log types.Log) (*WalletSetGasTopUpLimit, error)

+ func (_Wallet *WalletFilterer) ParseSetLoadLimit(log types.Log) (*WalletSetLoadLimit, error)

+ func (_Wallet *WalletFilterer) ParseSetSpendLimit(log types.Log) (*WalletSetSpendLimit, error)

+ func (_Wallet *WalletFilterer) ParseSubmittedGasTopUpLimitUpdate(log types.Log) (*WalletSubmittedGasTopUpLimitUpdate, error)

+ func (_Wallet *WalletFilterer) ParseSubmittedLoadLimitUpdate(log types.Log) (*WalletSubmittedLoadLimitUpdate, error)

+ func (_Wallet *WalletFilterer) ParseSubmittedSpendLimitUpdate(log types.Log) (*WalletSubmittedSpendLimitUpdate, error)

+ func (_Wallet *WalletFilterer) ParseSubmittedWhitelistAddition(log types.Log) (*WalletSubmittedWhitelistAddition, error)

+ func (_Wallet *WalletFilterer) ParseSubmittedWhitelistRemoval(log types.Log) (*WalletSubmittedWhitelistRemoval, error)

+ func (_Wallet *WalletFilterer) ParseToppedUpGas(log types.Log) (*WalletToppedUpGas, error)

+ func (_Wallet *WalletFilterer) ParseTransferred(log types.Log) (*WalletTransferred, error)

+ func (_Wallet *WalletFilterer) ParseTransferredOwnership(log types.Log) (*WalletTransferredOwnership, error)

+ func (_Wallet *WalletFilterer) ParseUpdatedAvailableLimit(log types.Log) (*WalletUpdatedAvailableLimit, error)

+ func (_Wallet *WalletFilterer) WatchExecutedRelayedTransaction(opts *bind.WatchOpts, sink chan<- *WalletExecutedRelayedTransaction) (event.Subscription, error)

type WalletSession

+ func (_Wallet *WalletSession) ExecuteRelayedTransaction(_nonce *big.Int, _data []byte, _signature []byte) (*types.Transaction, error)

+ func (_Wallet *WalletSession) ExecuteTransactions(_transactionBatch []byte) (*types.Transaction, error)

+ func (_Wallet *WalletSession) RelayNonce() (*big.Int, error)

type WalletTransactor

+ func (_Wallet *WalletTransactor) ExecuteRelayedTransaction(opts *bind.TransactOpts, _nonce *big.Int, _data []byte, _signature []byte) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) ExecuteTransactions(opts *bind.TransactOpts, _transactionBatch []byte) (*types.Transaction, error)

type WalletTransactorSession

+ func (_Wallet *WalletTransactorSession) ExecuteRelayedTransaction(_nonce *big.Int, _data []byte, _signature []byte) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) ExecuteTransactions(_transactionBatch []byte) (*types.Transaction, error)

v2.2.1

Aug 15, 2019

v2.2.0

Aug 12, 2019

v2.1.0

Aug 12, 2019

Changes in this version

+ const ControllerABI

+ const ControllerBin

+ const HolderABI

+ const HolderBin

+ const LicenceABI

+ const LicenceBin

+ const OracleABI

+ const OracleBin

+ const TokenWhitelistABI

+ const TokenWhitelistBin

+ const WalletABI

+ const WalletBin

+ const WalletDeployerABI

+ const WalletDeployerBin

+ type Controller struct

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

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

+ type ControllerAddedAdmin struct

+ Admin common.Address

+ Raw types.Log

+ Sender common.Address

+ type ControllerAddedAdminIterator struct

+ Event *ControllerAddedAdmin

+ func (it *ControllerAddedAdminIterator) Close() error

+ func (it *ControllerAddedAdminIterator) Error() error

+ func (it *ControllerAddedAdminIterator) Next() bool

+ type ControllerAddedController struct

+ Controller common.Address

+ Raw types.Log

+ Sender common.Address

+ type ControllerAddedControllerIterator struct

+ Event *ControllerAddedController

+ func (it *ControllerAddedControllerIterator) Close() error

+ func (it *ControllerAddedControllerIterator) Error() error

+ func (it *ControllerAddedControllerIterator) Next() bool

+ type ControllerCaller struct

+ func NewControllerCaller(address common.Address, caller bind.ContractCaller) (*ControllerCaller, error)

+ func (_Controller *ControllerCaller) AdminCount(opts *bind.CallOpts) (*big.Int, error)

+ func (_Controller *ControllerCaller) ControllerCount(opts *bind.CallOpts) (*big.Int, error)

+ func (_Controller *ControllerCaller) IsAdmin(opts *bind.CallOpts, _account common.Address) (bool, error)

+ func (_Controller *ControllerCaller) IsController(opts *bind.CallOpts, _account common.Address) (bool, error)

+ func (_Controller *ControllerCaller) IsStopped(opts *bind.CallOpts) (bool, error)

+ func (_Controller *ControllerCaller) IsTransferable(opts *bind.CallOpts) (bool, error)

+ func (_Controller *ControllerCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ type ControllerCallerRaw struct

+ Contract *ControllerCaller

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

+ type ControllerCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ControllerCaller

+ func (_Controller *ControllerCallerSession) AdminCount() (*big.Int, error)

+ func (_Controller *ControllerCallerSession) ControllerCount() (*big.Int, error)

+ func (_Controller *ControllerCallerSession) IsAdmin(_account common.Address) (bool, error)

+ func (_Controller *ControllerCallerSession) IsController(_account common.Address) (bool, error)

+ func (_Controller *ControllerCallerSession) IsStopped() (bool, error)

+ func (_Controller *ControllerCallerSession) IsTransferable() (bool, error)

+ func (_Controller *ControllerCallerSession) Owner() (common.Address, error)

+ type ControllerClaimed struct

+ Amount *big.Int

+ Asset common.Address

+ Raw types.Log

+ To common.Address

+ type ControllerClaimedIterator struct

+ Event *ControllerClaimed

+ func (it *ControllerClaimedIterator) Close() error

+ func (it *ControllerClaimedIterator) Error() error

+ func (it *ControllerClaimedIterator) Next() bool

+ type ControllerFilterer struct

+ func NewControllerFilterer(address common.Address, filterer bind.ContractFilterer) (*ControllerFilterer, error)

+ func (_Controller *ControllerFilterer) FilterAddedAdmin(opts *bind.FilterOpts) (*ControllerAddedAdminIterator, error)

+ func (_Controller *ControllerFilterer) FilterAddedController(opts *bind.FilterOpts) (*ControllerAddedControllerIterator, error)

+ func (_Controller *ControllerFilterer) FilterClaimed(opts *bind.FilterOpts) (*ControllerClaimedIterator, error)

+ func (_Controller *ControllerFilterer) FilterLockedOwnership(opts *bind.FilterOpts) (*ControllerLockedOwnershipIterator, error)

+ func (_Controller *ControllerFilterer) FilterRemovedAdmin(opts *bind.FilterOpts) (*ControllerRemovedAdminIterator, error)

+ func (_Controller *ControllerFilterer) FilterRemovedController(opts *bind.FilterOpts) (*ControllerRemovedControllerIterator, error)

+ func (_Controller *ControllerFilterer) FilterStarted(opts *bind.FilterOpts) (*ControllerStartedIterator, error)

+ func (_Controller *ControllerFilterer) FilterStopped(opts *bind.FilterOpts) (*ControllerStoppedIterator, error)

+ func (_Controller *ControllerFilterer) FilterTransferredOwnership(opts *bind.FilterOpts) (*ControllerTransferredOwnershipIterator, error)

+ func (_Controller *ControllerFilterer) WatchAddedAdmin(opts *bind.WatchOpts, sink chan<- *ControllerAddedAdmin) (event.Subscription, error)

+ func (_Controller *ControllerFilterer) WatchAddedController(opts *bind.WatchOpts, sink chan<- *ControllerAddedController) (event.Subscription, error)

+ func (_Controller *ControllerFilterer) WatchClaimed(opts *bind.WatchOpts, sink chan<- *ControllerClaimed) (event.Subscription, error)

+ func (_Controller *ControllerFilterer) WatchLockedOwnership(opts *bind.WatchOpts, sink chan<- *ControllerLockedOwnership) (event.Subscription, error)

+ func (_Controller *ControllerFilterer) WatchRemovedAdmin(opts *bind.WatchOpts, sink chan<- *ControllerRemovedAdmin) (event.Subscription, error)

+ func (_Controller *ControllerFilterer) WatchRemovedController(opts *bind.WatchOpts, sink chan<- *ControllerRemovedController) (event.Subscription, error)

+ func (_Controller *ControllerFilterer) WatchStarted(opts *bind.WatchOpts, sink chan<- *ControllerStarted) (event.Subscription, error)

+ func (_Controller *ControllerFilterer) WatchStopped(opts *bind.WatchOpts, sink chan<- *ControllerStopped) (event.Subscription, error)

+ func (_Controller *ControllerFilterer) WatchTransferredOwnership(opts *bind.WatchOpts, sink chan<- *ControllerTransferredOwnership) (event.Subscription, error)

+ type ControllerLockedOwnership struct

+ Locked common.Address

+ Raw types.Log

+ type ControllerLockedOwnershipIterator struct

+ Event *ControllerLockedOwnership

+ func (it *ControllerLockedOwnershipIterator) Close() error

+ func (it *ControllerLockedOwnershipIterator) Error() error

+ func (it *ControllerLockedOwnershipIterator) Next() bool

+ type ControllerRaw struct

+ Contract *Controller

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

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

+ func (_Controller *ControllerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ControllerRemovedAdmin struct

+ Admin common.Address

+ Raw types.Log

+ Sender common.Address

+ type ControllerRemovedAdminIterator struct

+ Event *ControllerRemovedAdmin

+ func (it *ControllerRemovedAdminIterator) Close() error

+ func (it *ControllerRemovedAdminIterator) Error() error

+ func (it *ControllerRemovedAdminIterator) Next() bool

+ type ControllerRemovedController struct

+ Controller common.Address

+ Raw types.Log

+ Sender common.Address

+ type ControllerRemovedControllerIterator struct

+ Event *ControllerRemovedController

+ func (it *ControllerRemovedControllerIterator) Close() error

+ func (it *ControllerRemovedControllerIterator) Error() error

+ func (it *ControllerRemovedControllerIterator) Next() bool

+ type ControllerSession struct

+ CallOpts bind.CallOpts

+ Contract *Controller

+ TransactOpts bind.TransactOpts

+ func (_Controller *ControllerSession) AddAdmin(_account common.Address) (*types.Transaction, error)

+ func (_Controller *ControllerSession) AddController(_account common.Address) (*types.Transaction, error)

+ func (_Controller *ControllerSession) AdminCount() (*big.Int, error)

+ func (_Controller *ControllerSession) Claim(_to common.Address, _asset common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Controller *ControllerSession) ControllerCount() (*big.Int, error)

+ func (_Controller *ControllerSession) IsAdmin(_account common.Address) (bool, error)

+ func (_Controller *ControllerSession) IsController(_account common.Address) (bool, error)

+ func (_Controller *ControllerSession) IsStopped() (bool, error)

+ func (_Controller *ControllerSession) IsTransferable() (bool, error)

+ func (_Controller *ControllerSession) Owner() (common.Address, error)

+ func (_Controller *ControllerSession) RemoveAdmin(_account common.Address) (*types.Transaction, error)

+ func (_Controller *ControllerSession) RemoveController(_account common.Address) (*types.Transaction, error)

+ func (_Controller *ControllerSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Controller *ControllerSession) Start() (*types.Transaction, error)

+ func (_Controller *ControllerSession) Stop() (*types.Transaction, error)

+ func (_Controller *ControllerSession) TransferOwnership(_account common.Address, _transferable bool) (*types.Transaction, error)

+ type ControllerStarted struct

+ Raw types.Log

+ Sender common.Address

+ type ControllerStartedIterator struct

+ Event *ControllerStarted

+ func (it *ControllerStartedIterator) Close() error

+ func (it *ControllerStartedIterator) Error() error

+ func (it *ControllerStartedIterator) Next() bool

+ type ControllerStopped struct

+ Raw types.Log

+ Sender common.Address

+ type ControllerStoppedIterator struct

+ Event *ControllerStopped

+ func (it *ControllerStoppedIterator) Close() error

+ func (it *ControllerStoppedIterator) Error() error

+ func (it *ControllerStoppedIterator) Next() bool

+ type ControllerTransactor struct

+ func NewControllerTransactor(address common.Address, transactor bind.ContractTransactor) (*ControllerTransactor, error)

+ func (_Controller *ControllerTransactor) AddAdmin(opts *bind.TransactOpts, _account common.Address) (*types.Transaction, error)

+ func (_Controller *ControllerTransactor) AddController(opts *bind.TransactOpts, _account common.Address) (*types.Transaction, error)

+ func (_Controller *ControllerTransactor) Claim(opts *bind.TransactOpts, _to common.Address, _asset common.Address, ...) (*types.Transaction, error)

+ func (_Controller *ControllerTransactor) RemoveAdmin(opts *bind.TransactOpts, _account common.Address) (*types.Transaction, error)

+ func (_Controller *ControllerTransactor) RemoveController(opts *bind.TransactOpts, _account common.Address) (*types.Transaction, error)

+ func (_Controller *ControllerTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Controller *ControllerTransactor) Start(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Controller *ControllerTransactor) Stop(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Controller *ControllerTransactor) TransferOwnership(opts *bind.TransactOpts, _account common.Address, _transferable bool) (*types.Transaction, error)

+ type ControllerTransactorRaw struct

+ Contract *ControllerTransactor

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

+ func (_Controller *ControllerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ControllerTransactorSession struct

+ Contract *ControllerTransactor

+ TransactOpts bind.TransactOpts

+ func (_Controller *ControllerTransactorSession) AddAdmin(_account common.Address) (*types.Transaction, error)

+ func (_Controller *ControllerTransactorSession) AddController(_account common.Address) (*types.Transaction, error)

+ func (_Controller *ControllerTransactorSession) Claim(_to common.Address, _asset common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Controller *ControllerTransactorSession) RemoveAdmin(_account common.Address) (*types.Transaction, error)

+ func (_Controller *ControllerTransactorSession) RemoveController(_account common.Address) (*types.Transaction, error)

+ func (_Controller *ControllerTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Controller *ControllerTransactorSession) Start() (*types.Transaction, error)

+ func (_Controller *ControllerTransactorSession) Stop() (*types.Transaction, error)

+ func (_Controller *ControllerTransactorSession) TransferOwnership(_account common.Address, _transferable bool) (*types.Transaction, error)

+ type ControllerTransferredOwnership struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ type ControllerTransferredOwnershipIterator struct

+ Event *ControllerTransferredOwnership

+ func (it *ControllerTransferredOwnershipIterator) Close() error

+ func (it *ControllerTransferredOwnershipIterator) Error() error

+ func (it *ControllerTransferredOwnershipIterator) Next() bool

+ type Holder struct

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

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

+ type HolderCaller struct

+ func NewHolderCaller(address common.Address, caller bind.ContractCaller) (*HolderCaller, error)

+ func (_Holder *HolderCaller) Burner(opts *bind.CallOpts) (common.Address, error)

+ func (_Holder *HolderCaller) ControllerNode(opts *bind.CallOpts) ([32]byte, error)

+ func (_Holder *HolderCaller) EnsRegistry(opts *bind.CallOpts) (common.Address, error)

+ func (_Holder *HolderCaller) TokenWhitelistNode(opts *bind.CallOpts) ([32]byte, error)

+ type HolderCallerRaw struct

+ Contract *HolderCaller

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

+ type HolderCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *HolderCaller

+ func (_Holder *HolderCallerSession) Burner() (common.Address, error)

+ func (_Holder *HolderCallerSession) ControllerNode() ([32]byte, error)

+ func (_Holder *HolderCallerSession) EnsRegistry() (common.Address, error)

+ func (_Holder *HolderCallerSession) TokenWhitelistNode() ([32]byte, error)

+ type HolderCashAndBurned struct

+ Amount *big.Int

+ Asset common.Address

+ Raw types.Log

+ To common.Address

+ type HolderCashAndBurnedIterator struct

+ Event *HolderCashAndBurned

+ func (it *HolderCashAndBurnedIterator) Close() error

+ func (it *HolderCashAndBurnedIterator) Error() error

+ func (it *HolderCashAndBurnedIterator) Next() bool

+ type HolderClaimed struct

+ Amount *big.Int

+ Asset common.Address

+ Raw types.Log

+ To common.Address

+ type HolderClaimedIterator struct

+ Event *HolderClaimed

+ func (it *HolderClaimedIterator) Close() error

+ func (it *HolderClaimedIterator) Error() error

+ func (it *HolderClaimedIterator) Next() bool

+ type HolderFilterer struct

+ func NewHolderFilterer(address common.Address, filterer bind.ContractFilterer) (*HolderFilterer, error)

+ func (_Holder *HolderFilterer) FilterCashAndBurned(opts *bind.FilterOpts) (*HolderCashAndBurnedIterator, error)

+ func (_Holder *HolderFilterer) FilterClaimed(opts *bind.FilterOpts) (*HolderClaimedIterator, error)

+ func (_Holder *HolderFilterer) FilterReceived(opts *bind.FilterOpts) (*HolderReceivedIterator, error)

+ func (_Holder *HolderFilterer) WatchCashAndBurned(opts *bind.WatchOpts, sink chan<- *HolderCashAndBurned) (event.Subscription, error)

+ func (_Holder *HolderFilterer) WatchClaimed(opts *bind.WatchOpts, sink chan<- *HolderClaimed) (event.Subscription, error)

+ func (_Holder *HolderFilterer) WatchReceived(opts *bind.WatchOpts, sink chan<- *HolderReceived) (event.Subscription, error)

+ type HolderRaw struct

+ Contract *Holder

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

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

+ func (_Holder *HolderRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type HolderReceived struct

+ Amount *big.Int

+ From common.Address

+ Raw types.Log

+ type HolderReceivedIterator struct

+ Event *HolderReceived

+ func (it *HolderReceivedIterator) Close() error

+ func (it *HolderReceivedIterator) Error() error

+ func (it *HolderReceivedIterator) Next() bool

+ type HolderSession struct

+ CallOpts bind.CallOpts

+ Contract *Holder

+ TransactOpts bind.TransactOpts

+ func (_Holder *HolderSession) Burn(_to common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Holder *HolderSession) Burner() (common.Address, error)

+ func (_Holder *HolderSession) ControllerNode() ([32]byte, error)

+ func (_Holder *HolderSession) EnsRegistry() (common.Address, error)

+ func (_Holder *HolderSession) NonRedeemableTokenClaim(_to common.Address, _nonRedeemableAddresses []common.Address) (*types.Transaction, error)

+ func (_Holder *HolderSession) TokenWhitelistNode() ([32]byte, error)

+ type HolderTransactor struct

+ func NewHolderTransactor(address common.Address, transactor bind.ContractTransactor) (*HolderTransactor, error)

+ func (_Holder *HolderTransactor) Burn(opts *bind.TransactOpts, _to common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Holder *HolderTransactor) NonRedeemableTokenClaim(opts *bind.TransactOpts, _to common.Address, ...) (*types.Transaction, error)

+ type HolderTransactorRaw struct

+ Contract *HolderTransactor

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

+ func (_Holder *HolderTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type HolderTransactorSession struct

+ Contract *HolderTransactor

+ TransactOpts bind.TransactOpts

+ func (_Holder *HolderTransactorSession) Burn(_to common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Holder *HolderTransactorSession) NonRedeemableTokenClaim(_to common.Address, _nonRedeemableAddresses []common.Address) (*types.Transaction, error)

+ type Licence struct

+ func DeployLicence(auth *bind.TransactOpts, backend bind.ContractBackend, _licence_ *big.Int, ...) (common.Address, *types.Transaction, *Licence, error)

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

+ type LicenceCaller struct

+ func NewLicenceCaller(address common.Address, caller bind.ContractCaller) (*LicenceCaller, error)

+ func (_Licence *LicenceCaller) ControllerNode(opts *bind.CallOpts) ([32]byte, error)

+ func (_Licence *LicenceCaller) CryptoFloat(opts *bind.CallOpts) (common.Address, error)

+ func (_Licence *LicenceCaller) EnsRegistry(opts *bind.CallOpts) (common.Address, error)

+ func (_Licence *LicenceCaller) FloatLocked(opts *bind.CallOpts) (bool, error)

+ func (_Licence *LicenceCaller) HolderLocked(opts *bind.CallOpts) (bool, error)

+ func (_Licence *LicenceCaller) LicenceAmountScaled(opts *bind.CallOpts) (*big.Int, error)

+ func (_Licence *LicenceCaller) LicenceDAO(opts *bind.CallOpts) (common.Address, error)

+ func (_Licence *LicenceCaller) LicenceDAOLocked(opts *bind.CallOpts) (bool, error)

+ func (_Licence *LicenceCaller) MAXAMOUNTSCALE(opts *bind.CallOpts) (*big.Int, error)

+ func (_Licence *LicenceCaller) MINAMOUNTSCALE(opts *bind.CallOpts) (*big.Int, error)

+ func (_Licence *LicenceCaller) TknContractAddress(opts *bind.CallOpts) (common.Address, error)

+ func (_Licence *LicenceCaller) TknContractAddressLocked(opts *bind.CallOpts) (bool, error)

+ func (_Licence *LicenceCaller) TokenHolder(opts *bind.CallOpts) (common.Address, error)

+ type LicenceCallerRaw struct

+ Contract *LicenceCaller

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

+ type LicenceCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *LicenceCaller

+ func (_Licence *LicenceCallerSession) ControllerNode() ([32]byte, error)

+ func (_Licence *LicenceCallerSession) CryptoFloat() (common.Address, error)

+ func (_Licence *LicenceCallerSession) EnsRegistry() (common.Address, error)

+ func (_Licence *LicenceCallerSession) FloatLocked() (bool, error)

+ func (_Licence *LicenceCallerSession) HolderLocked() (bool, error)

+ func (_Licence *LicenceCallerSession) LicenceAmountScaled() (*big.Int, error)

+ func (_Licence *LicenceCallerSession) LicenceDAO() (common.Address, error)

+ func (_Licence *LicenceCallerSession) LicenceDAOLocked() (bool, error)

+ func (_Licence *LicenceCallerSession) MAXAMOUNTSCALE() (*big.Int, error)

+ func (_Licence *LicenceCallerSession) MINAMOUNTSCALE() (*big.Int, error)

+ func (_Licence *LicenceCallerSession) TknContractAddress() (common.Address, error)

+ func (_Licence *LicenceCallerSession) TknContractAddressLocked() (bool, error)

+ func (_Licence *LicenceCallerSession) TokenHolder() (common.Address, error)

+ type LicenceClaimed struct

+ Amount *big.Int

+ Asset common.Address

+ Raw types.Log

+ To common.Address

+ type LicenceClaimedIterator struct

+ Event *LicenceClaimed

+ func (it *LicenceClaimedIterator) Close() error

+ func (it *LicenceClaimedIterator) Error() error

+ func (it *LicenceClaimedIterator) Next() bool

+ type LicenceFilterer struct

+ func NewLicenceFilterer(address common.Address, filterer bind.ContractFilterer) (*LicenceFilterer, error)

+ func (_Licence *LicenceFilterer) FilterClaimed(opts *bind.FilterOpts) (*LicenceClaimedIterator, error)

+ func (_Licence *LicenceFilterer) FilterTransferredToCryptoFloat(opts *bind.FilterOpts) (*LicenceTransferredToCryptoFloatIterator, error)

+ func (_Licence *LicenceFilterer) FilterTransferredToTokenHolder(opts *bind.FilterOpts) (*LicenceTransferredToTokenHolderIterator, error)

+ func (_Licence *LicenceFilterer) FilterUpdatedCryptoFloat(opts *bind.FilterOpts) (*LicenceUpdatedCryptoFloatIterator, error)

+ func (_Licence *LicenceFilterer) FilterUpdatedLicenceAmount(opts *bind.FilterOpts) (*LicenceUpdatedLicenceAmountIterator, error)

+ func (_Licence *LicenceFilterer) FilterUpdatedLicenceDAO(opts *bind.FilterOpts) (*LicenceUpdatedLicenceDAOIterator, error)

+ func (_Licence *LicenceFilterer) FilterUpdatedTKNContractAddress(opts *bind.FilterOpts) (*LicenceUpdatedTKNContractAddressIterator, error)

+ func (_Licence *LicenceFilterer) FilterUpdatedTokenHolder(opts *bind.FilterOpts) (*LicenceUpdatedTokenHolderIterator, error)

+ func (_Licence *LicenceFilterer) WatchClaimed(opts *bind.WatchOpts, sink chan<- *LicenceClaimed) (event.Subscription, error)

+ func (_Licence *LicenceFilterer) WatchTransferredToCryptoFloat(opts *bind.WatchOpts, sink chan<- *LicenceTransferredToCryptoFloat) (event.Subscription, error)

+ func (_Licence *LicenceFilterer) WatchTransferredToTokenHolder(opts *bind.WatchOpts, sink chan<- *LicenceTransferredToTokenHolder) (event.Subscription, error)

+ func (_Licence *LicenceFilterer) WatchUpdatedCryptoFloat(opts *bind.WatchOpts, sink chan<- *LicenceUpdatedCryptoFloat) (event.Subscription, error)

+ func (_Licence *LicenceFilterer) WatchUpdatedLicenceAmount(opts *bind.WatchOpts, sink chan<- *LicenceUpdatedLicenceAmount) (event.Subscription, error)

+ func (_Licence *LicenceFilterer) WatchUpdatedLicenceDAO(opts *bind.WatchOpts, sink chan<- *LicenceUpdatedLicenceDAO) (event.Subscription, error)

+ func (_Licence *LicenceFilterer) WatchUpdatedTKNContractAddress(opts *bind.WatchOpts, sink chan<- *LicenceUpdatedTKNContractAddress) (event.Subscription, error)

+ func (_Licence *LicenceFilterer) WatchUpdatedTokenHolder(opts *bind.WatchOpts, sink chan<- *LicenceUpdatedTokenHolder) (event.Subscription, error)

+ type LicenceRaw struct

+ Contract *Licence

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

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

+ func (_Licence *LicenceRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type LicenceSession struct

+ CallOpts bind.CallOpts

+ Contract *Licence

+ TransactOpts bind.TransactOpts

+ func (_Licence *LicenceSession) Claim(_to common.Address, _asset common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Licence *LicenceSession) ControllerNode() ([32]byte, error)

+ func (_Licence *LicenceSession) CryptoFloat() (common.Address, error)

+ func (_Licence *LicenceSession) EnsRegistry() (common.Address, error)

+ func (_Licence *LicenceSession) FloatLocked() (bool, error)

+ func (_Licence *LicenceSession) HolderLocked() (bool, error)

+ func (_Licence *LicenceSession) LicenceAmountScaled() (*big.Int, error)

+ func (_Licence *LicenceSession) LicenceDAO() (common.Address, error)

+ func (_Licence *LicenceSession) LicenceDAOLocked() (bool, error)

+ func (_Licence *LicenceSession) Load(_asset common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Licence *LicenceSession) LockFloat() (*types.Transaction, error)

+ func (_Licence *LicenceSession) LockHolder() (*types.Transaction, error)

+ func (_Licence *LicenceSession) LockLicenceDAO() (*types.Transaction, error)

+ func (_Licence *LicenceSession) LockTKNContractAddress() (*types.Transaction, error)

+ func (_Licence *LicenceSession) MAXAMOUNTSCALE() (*big.Int, error)

+ func (_Licence *LicenceSession) MINAMOUNTSCALE() (*big.Int, error)

+ func (_Licence *LicenceSession) TknContractAddress() (common.Address, error)

+ func (_Licence *LicenceSession) TknContractAddressLocked() (bool, error)

+ func (_Licence *LicenceSession) TokenHolder() (common.Address, error)

+ func (_Licence *LicenceSession) UpdateFloat(_newFloat common.Address) (*types.Transaction, error)

+ func (_Licence *LicenceSession) UpdateHolder(_newHolder common.Address) (*types.Transaction, error)

+ func (_Licence *LicenceSession) UpdateLicenceAmount(_newAmount *big.Int) (*types.Transaction, error)

+ func (_Licence *LicenceSession) UpdateLicenceDAO(_newDAO common.Address) (*types.Transaction, error)

+ func (_Licence *LicenceSession) UpdateTKNContractAddress(_newTKN common.Address) (*types.Transaction, error)

+ type LicenceTransactor struct

+ func NewLicenceTransactor(address common.Address, transactor bind.ContractTransactor) (*LicenceTransactor, error)

+ func (_Licence *LicenceTransactor) Claim(opts *bind.TransactOpts, _to common.Address, _asset common.Address, ...) (*types.Transaction, error)

+ func (_Licence *LicenceTransactor) Load(opts *bind.TransactOpts, _asset common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Licence *LicenceTransactor) LockFloat(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Licence *LicenceTransactor) LockHolder(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Licence *LicenceTransactor) LockLicenceDAO(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Licence *LicenceTransactor) LockTKNContractAddress(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Licence *LicenceTransactor) UpdateFloat(opts *bind.TransactOpts, _newFloat common.Address) (*types.Transaction, error)

+ func (_Licence *LicenceTransactor) UpdateHolder(opts *bind.TransactOpts, _newHolder common.Address) (*types.Transaction, error)

+ func (_Licence *LicenceTransactor) UpdateLicenceAmount(opts *bind.TransactOpts, _newAmount *big.Int) (*types.Transaction, error)

+ func (_Licence *LicenceTransactor) UpdateLicenceDAO(opts *bind.TransactOpts, _newDAO common.Address) (*types.Transaction, error)

+ func (_Licence *LicenceTransactor) UpdateTKNContractAddress(opts *bind.TransactOpts, _newTKN common.Address) (*types.Transaction, error)

+ type LicenceTransactorRaw struct

+ Contract *LicenceTransactor

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

+ func (_Licence *LicenceTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type LicenceTransactorSession struct

+ Contract *LicenceTransactor

+ TransactOpts bind.TransactOpts

+ func (_Licence *LicenceTransactorSession) Claim(_to common.Address, _asset common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Licence *LicenceTransactorSession) Load(_asset common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Licence *LicenceTransactorSession) LockFloat() (*types.Transaction, error)

+ func (_Licence *LicenceTransactorSession) LockHolder() (*types.Transaction, error)

+ func (_Licence *LicenceTransactorSession) LockLicenceDAO() (*types.Transaction, error)

+ func (_Licence *LicenceTransactorSession) LockTKNContractAddress() (*types.Transaction, error)

+ func (_Licence *LicenceTransactorSession) UpdateFloat(_newFloat common.Address) (*types.Transaction, error)

+ func (_Licence *LicenceTransactorSession) UpdateHolder(_newHolder common.Address) (*types.Transaction, error)

+ func (_Licence *LicenceTransactorSession) UpdateLicenceAmount(_newAmount *big.Int) (*types.Transaction, error)

+ func (_Licence *LicenceTransactorSession) UpdateLicenceDAO(_newDAO common.Address) (*types.Transaction, error)

+ func (_Licence *LicenceTransactorSession) UpdateTKNContractAddress(_newTKN common.Address) (*types.Transaction, error)

+ type LicenceTransferredToCryptoFloat struct

+ Amount *big.Int

+ Asset common.Address

+ From common.Address

+ Raw types.Log

+ To common.Address

+ type LicenceTransferredToCryptoFloatIterator struct

+ Event *LicenceTransferredToCryptoFloat

+ func (it *LicenceTransferredToCryptoFloatIterator) Close() error

+ func (it *LicenceTransferredToCryptoFloatIterator) Error() error

+ func (it *LicenceTransferredToCryptoFloatIterator) Next() bool

+ type LicenceTransferredToTokenHolder struct

+ Amount *big.Int

+ Asset common.Address

+ From common.Address

+ Raw types.Log

+ To common.Address

+ type LicenceTransferredToTokenHolderIterator struct

+ Event *LicenceTransferredToTokenHolder

+ func (it *LicenceTransferredToTokenHolderIterator) Close() error

+ func (it *LicenceTransferredToTokenHolderIterator) Error() error

+ func (it *LicenceTransferredToTokenHolderIterator) Next() bool

+ type LicenceUpdatedCryptoFloat struct

+ NewFloat common.Address

+ Raw types.Log

+ type LicenceUpdatedCryptoFloatIterator struct

+ Event *LicenceUpdatedCryptoFloat

+ func (it *LicenceUpdatedCryptoFloatIterator) Close() error

+ func (it *LicenceUpdatedCryptoFloatIterator) Error() error

+ func (it *LicenceUpdatedCryptoFloatIterator) Next() bool

+ type LicenceUpdatedLicenceAmount struct

+ NewAmount *big.Int

+ Raw types.Log

+ type LicenceUpdatedLicenceAmountIterator struct

+ Event *LicenceUpdatedLicenceAmount

+ func (it *LicenceUpdatedLicenceAmountIterator) Close() error

+ func (it *LicenceUpdatedLicenceAmountIterator) Error() error

+ func (it *LicenceUpdatedLicenceAmountIterator) Next() bool

+ type LicenceUpdatedLicenceDAO struct

+ NewDAO common.Address

+ Raw types.Log

+ type LicenceUpdatedLicenceDAOIterator struct

+ Event *LicenceUpdatedLicenceDAO

+ func (it *LicenceUpdatedLicenceDAOIterator) Close() error

+ func (it *LicenceUpdatedLicenceDAOIterator) Error() error

+ func (it *LicenceUpdatedLicenceDAOIterator) Next() bool

+ type LicenceUpdatedTKNContractAddress struct

+ NewTKN common.Address

+ Raw types.Log

+ type LicenceUpdatedTKNContractAddressIterator struct

+ Event *LicenceUpdatedTKNContractAddress

+ func (it *LicenceUpdatedTKNContractAddressIterator) Close() error

+ func (it *LicenceUpdatedTKNContractAddressIterator) Error() error

+ func (it *LicenceUpdatedTKNContractAddressIterator) Next() bool

+ type LicenceUpdatedTokenHolder struct

+ NewHolder common.Address

+ Raw types.Log

+ type LicenceUpdatedTokenHolderIterator struct

+ Event *LicenceUpdatedTokenHolder

+ func (it *LicenceUpdatedTokenHolderIterator) Close() error

+ func (it *LicenceUpdatedTokenHolderIterator) Error() error

+ func (it *LicenceUpdatedTokenHolderIterator) Next() bool

+ 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) ControllerNode(opts *bind.CallOpts) ([32]byte, error)

+ func (_Oracle *OracleCaller) CryptoCompareAPIPublicKey(opts *bind.CallOpts) ([]byte, error)

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

+ func (_Oracle *OracleCaller) TokenWhitelistNode(opts *bind.CallOpts) ([32]byte, 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) ControllerNode() ([32]byte, error)

+ func (_Oracle *OracleCallerSession) CryptoCompareAPIPublicKey() ([]byte, error)

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

+ func (_Oracle *OracleCallerSession) TokenWhitelistNode() ([32]byte, error)

+ type OracleClaimed struct

+ Amount *big.Int

+ Asset common.Address

+ Raw types.Log

+ To common.Address

+ type OracleClaimedIterator struct

+ Event *OracleClaimed

+ func (it *OracleClaimedIterator) Close() error

+ func (it *OracleClaimedIterator) Error() error

+ func (it *OracleClaimedIterator) Next() bool

+ type OracleFailedUpdateRequest struct

+ Raw types.Log

+ Reason string

+ type OracleFailedUpdateRequestIterator struct

+ Event *OracleFailedUpdateRequest

+ func (it *OracleFailedUpdateRequestIterator) Close() error

+ func (it *OracleFailedUpdateRequestIterator) Error() error

+ func (it *OracleFailedUpdateRequestIterator) Next() bool

+ type OracleFilterer struct

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

+ func (_Oracle *OracleFilterer) FilterClaimed(opts *bind.FilterOpts) (*OracleClaimedIterator, error)

+ func (_Oracle *OracleFilterer) FilterFailedUpdateRequest(opts *bind.FilterOpts) (*OracleFailedUpdateRequestIterator, error)

+ func (_Oracle *OracleFilterer) FilterRequestedUpdate(opts *bind.FilterOpts) (*OracleRequestedUpdateIterator, error)

+ func (_Oracle *OracleFilterer) FilterSetCryptoComparePublicKey(opts *bind.FilterOpts) (*OracleSetCryptoComparePublicKeyIterator, error)

+ func (_Oracle *OracleFilterer) FilterSetGasPrice(opts *bind.FilterOpts) (*OracleSetGasPriceIterator, error)

+ func (_Oracle *OracleFilterer) FilterVerifiedProof(opts *bind.FilterOpts) (*OracleVerifiedProofIterator, error)

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

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

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

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

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

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

+ 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 OracleRequestedUpdate struct

+ QueryID [32]byte

+ Raw types.Log

+ Symbol string

+ type OracleRequestedUpdateIterator struct

+ Event *OracleRequestedUpdate

+ func (it *OracleRequestedUpdateIterator) Close() error

+ func (it *OracleRequestedUpdateIterator) Error() error

+ func (it *OracleRequestedUpdateIterator) Next() bool

+ type OracleSession struct

+ CallOpts bind.CallOpts

+ Contract *Oracle

+ TransactOpts bind.TransactOpts

+ func (_Oracle *OracleSession) Callback(_queryID [32]byte, _result string, _proof []byte) (*types.Transaction, error)

+ func (_Oracle *OracleSession) Claim(_to common.Address, _asset common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Oracle *OracleSession) ControllerNode() ([32]byte, error)

+ func (_Oracle *OracleSession) CryptoCompareAPIPublicKey() ([]byte, error)

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

+ func (_Oracle *OracleSession) SetCustomGasPrice(_gasPrice *big.Int) (*types.Transaction, error)

+ func (_Oracle *OracleSession) TokenWhitelistNode() ([32]byte, error)

+ func (_Oracle *OracleSession) UpdateCryptoCompareAPIPublicKey(_publicKey []byte) (*types.Transaction, error)

+ func (_Oracle *OracleSession) UpdateTokenRates(_gasLimit *big.Int) (*types.Transaction, error)

+ func (_Oracle *OracleSession) UpdateTokenRatesList(_gasLimit *big.Int, _tokenList []common.Address) (*types.Transaction, error)

+ type OracleSetCryptoComparePublicKey struct

+ PublicKey []byte

+ Raw types.Log

+ Sender common.Address

+ type OracleSetCryptoComparePublicKeyIterator struct

+ Event *OracleSetCryptoComparePublicKey

+ func (it *OracleSetCryptoComparePublicKeyIterator) Close() error

+ func (it *OracleSetCryptoComparePublicKeyIterator) Error() error

+ func (it *OracleSetCryptoComparePublicKeyIterator) Next() bool

+ type OracleSetGasPrice struct

+ GasPrice *big.Int

+ Raw types.Log

+ Sender common.Address

+ type OracleSetGasPriceIterator struct

+ Event *OracleSetGasPrice

+ func (it *OracleSetGasPriceIterator) Close() error

+ func (it *OracleSetGasPriceIterator) Error() error

+ func (it *OracleSetGasPriceIterator) Next() bool

+ type OracleTransactor struct

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

+ func (_Oracle *OracleTransactor) Callback(opts *bind.TransactOpts, _queryID [32]byte, _result string, _proof []byte) (*types.Transaction, error)

+ func (_Oracle *OracleTransactor) Claim(opts *bind.TransactOpts, _to common.Address, _asset common.Address, ...) (*types.Transaction, error)

+ func (_Oracle *OracleTransactor) SetCustomGasPrice(opts *bind.TransactOpts, _gasPrice *big.Int) (*types.Transaction, error)

+ func (_Oracle *OracleTransactor) UpdateCryptoCompareAPIPublicKey(opts *bind.TransactOpts, _publicKey []byte) (*types.Transaction, error)

+ func (_Oracle *OracleTransactor) UpdateTokenRates(opts *bind.TransactOpts, _gasLimit *big.Int) (*types.Transaction, error)

+ func (_Oracle *OracleTransactor) UpdateTokenRatesList(opts *bind.TransactOpts, _gasLimit *big.Int, _tokenList []common.Address) (*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) Callback(_queryID [32]byte, _result string, _proof []byte) (*types.Transaction, error)

+ func (_Oracle *OracleTransactorSession) Claim(_to common.Address, _asset common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Oracle *OracleTransactorSession) SetCustomGasPrice(_gasPrice *big.Int) (*types.Transaction, error)

+ func (_Oracle *OracleTransactorSession) UpdateCryptoCompareAPIPublicKey(_publicKey []byte) (*types.Transaction, error)

+ func (_Oracle *OracleTransactorSession) UpdateTokenRates(_gasLimit *big.Int) (*types.Transaction, error)

+ func (_Oracle *OracleTransactorSession) UpdateTokenRatesList(_gasLimit *big.Int, _tokenList []common.Address) (*types.Transaction, error)

+ type OracleVerifiedProof struct

+ PublicKey []byte

+ Raw types.Log

+ Result string

+ type OracleVerifiedProofIterator struct

+ Event *OracleVerifiedProof

+ func (it *OracleVerifiedProofIterator) Close() error

+ func (it *OracleVerifiedProofIterator) Error() error

+ func (it *OracleVerifiedProofIterator) Next() bool

+ type TokenWhitelist struct

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

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

+ type TokenWhitelistAddedExclusiveMethod struct

+ MethodId [4]byte

+ Raw types.Log

+ Token common.Address

+ type TokenWhitelistAddedExclusiveMethodIterator struct

+ Event *TokenWhitelistAddedExclusiveMethod

+ func (it *TokenWhitelistAddedExclusiveMethodIterator) Close() error

+ func (it *TokenWhitelistAddedExclusiveMethodIterator) Error() error

+ func (it *TokenWhitelistAddedExclusiveMethodIterator) Next() bool

+ type TokenWhitelistAddedMethodId struct

+ MethodId [4]byte

+ Raw types.Log

+ type TokenWhitelistAddedMethodIdIterator struct

+ Event *TokenWhitelistAddedMethodId

+ func (it *TokenWhitelistAddedMethodIdIterator) Close() error

+ func (it *TokenWhitelistAddedMethodIdIterator) Error() error

+ func (it *TokenWhitelistAddedMethodIdIterator) Next() bool

+ type TokenWhitelistAddedToken struct

+ Loadable bool

+ Magnitude *big.Int

+ Raw types.Log

+ Redeemable bool

+ Sender common.Address

+ Symbol string

+ Token common.Address

+ type TokenWhitelistAddedTokenIterator struct

+ Event *TokenWhitelistAddedToken

+ func (it *TokenWhitelistAddedTokenIterator) Close() error

+ func (it *TokenWhitelistAddedTokenIterator) Error() error

+ func (it *TokenWhitelistAddedTokenIterator) Next() bool

+ type TokenWhitelistCaller struct

+ func NewTokenWhitelistCaller(address common.Address, caller bind.ContractCaller) (*TokenWhitelistCaller, error)

+ func (_TokenWhitelist *TokenWhitelistCaller) ControllerNode(opts *bind.CallOpts) ([32]byte, error)

+ func (_TokenWhitelist *TokenWhitelistCaller) EnsRegistry(opts *bind.CallOpts) (common.Address, error)

+ func (_TokenWhitelist *TokenWhitelistCaller) GetERC20RecipientAndAmount(opts *bind.CallOpts, _token common.Address, _data []byte) (common.Address, *big.Int, error)

+ func (_TokenWhitelist *TokenWhitelistCaller) GetStablecoinInfo(opts *bind.CallOpts) (string, *big.Int, *big.Int, bool, bool, bool, *big.Int, error)

+ func (_TokenWhitelist *TokenWhitelistCaller) GetTokenInfo(opts *bind.CallOpts, _a common.Address) (string, *big.Int, *big.Int, bool, bool, bool, *big.Int, error)

+ func (_TokenWhitelist *TokenWhitelistCaller) IsERC20MethodSupported(opts *bind.CallOpts, _token common.Address, _methodId [4]byte) (bool, error)

+ func (_TokenWhitelist *TokenWhitelistCaller) IsERC20MethodWhitelisted(opts *bind.CallOpts, _methodId [4]byte) (bool, error)

+ func (_TokenWhitelist *TokenWhitelistCaller) OracleNode(opts *bind.CallOpts) ([32]byte, error)

+ func (_TokenWhitelist *TokenWhitelistCaller) RedeemableCounter(opts *bind.CallOpts) (*big.Int, error)

+ func (_TokenWhitelist *TokenWhitelistCaller) RedeemableTokens(opts *bind.CallOpts) ([]common.Address, error)

+ func (_TokenWhitelist *TokenWhitelistCaller) Stablecoin(opts *bind.CallOpts) (common.Address, error)

+ func (_TokenWhitelist *TokenWhitelistCaller) TokenAddressArray(opts *bind.CallOpts) ([]common.Address, error)

+ type TokenWhitelistCallerRaw struct

+ Contract *TokenWhitelistCaller

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

+ type TokenWhitelistCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *TokenWhitelistCaller

+ func (_TokenWhitelist *TokenWhitelistCallerSession) ControllerNode() ([32]byte, error)

+ func (_TokenWhitelist *TokenWhitelistCallerSession) EnsRegistry() (common.Address, error)

+ func (_TokenWhitelist *TokenWhitelistCallerSession) GetERC20RecipientAndAmount(_token common.Address, _data []byte) (common.Address, *big.Int, error)

+ func (_TokenWhitelist *TokenWhitelistCallerSession) GetStablecoinInfo() (string, *big.Int, *big.Int, bool, bool, bool, *big.Int, error)

+ func (_TokenWhitelist *TokenWhitelistCallerSession) GetTokenInfo(_a common.Address) (string, *big.Int, *big.Int, bool, bool, bool, *big.Int, error)

+ func (_TokenWhitelist *TokenWhitelistCallerSession) IsERC20MethodSupported(_token common.Address, _methodId [4]byte) (bool, error)

+ func (_TokenWhitelist *TokenWhitelistCallerSession) IsERC20MethodWhitelisted(_methodId [4]byte) (bool, error)

+ func (_TokenWhitelist *TokenWhitelistCallerSession) OracleNode() ([32]byte, error)

+ func (_TokenWhitelist *TokenWhitelistCallerSession) RedeemableCounter() (*big.Int, error)

+ func (_TokenWhitelist *TokenWhitelistCallerSession) RedeemableTokens() ([]common.Address, error)

+ func (_TokenWhitelist *TokenWhitelistCallerSession) Stablecoin() (common.Address, error)

+ func (_TokenWhitelist *TokenWhitelistCallerSession) TokenAddressArray() ([]common.Address, error)

+ type TokenWhitelistClaimed struct

+ Amount *big.Int

+ Asset common.Address

+ Raw types.Log

+ To common.Address

+ type TokenWhitelistClaimedIterator struct

+ Event *TokenWhitelistClaimed

+ func (it *TokenWhitelistClaimedIterator) Close() error

+ func (it *TokenWhitelistClaimedIterator) Error() error

+ func (it *TokenWhitelistClaimedIterator) Next() bool

+ type TokenWhitelistFilterer struct

+ func NewTokenWhitelistFilterer(address common.Address, filterer bind.ContractFilterer) (*TokenWhitelistFilterer, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) FilterAddedExclusiveMethod(opts *bind.FilterOpts) (*TokenWhitelistAddedExclusiveMethodIterator, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) FilterAddedMethodId(opts *bind.FilterOpts) (*TokenWhitelistAddedMethodIdIterator, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) FilterAddedToken(opts *bind.FilterOpts) (*TokenWhitelistAddedTokenIterator, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) FilterClaimed(opts *bind.FilterOpts) (*TokenWhitelistClaimedIterator, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) FilterRemovedExclusiveMethod(opts *bind.FilterOpts) (*TokenWhitelistRemovedExclusiveMethodIterator, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) FilterRemovedMethodId(opts *bind.FilterOpts) (*TokenWhitelistRemovedMethodIdIterator, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) FilterRemovedToken(opts *bind.FilterOpts) (*TokenWhitelistRemovedTokenIterator, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) FilterUpdatedTokenLoadable(opts *bind.FilterOpts) (*TokenWhitelistUpdatedTokenLoadableIterator, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) FilterUpdatedTokenRate(opts *bind.FilterOpts) (*TokenWhitelistUpdatedTokenRateIterator, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) FilterUpdatedTokenRedeemable(opts *bind.FilterOpts) (*TokenWhitelistUpdatedTokenRedeemableIterator, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) WatchAddedExclusiveMethod(opts *bind.WatchOpts, sink chan<- *TokenWhitelistAddedExclusiveMethod) (event.Subscription, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) WatchAddedMethodId(opts *bind.WatchOpts, sink chan<- *TokenWhitelistAddedMethodId) (event.Subscription, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) WatchAddedToken(opts *bind.WatchOpts, sink chan<- *TokenWhitelistAddedToken) (event.Subscription, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) WatchClaimed(opts *bind.WatchOpts, sink chan<- *TokenWhitelistClaimed) (event.Subscription, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) WatchRemovedExclusiveMethod(opts *bind.WatchOpts, sink chan<- *TokenWhitelistRemovedExclusiveMethod) (event.Subscription, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) WatchRemovedMethodId(opts *bind.WatchOpts, sink chan<- *TokenWhitelistRemovedMethodId) (event.Subscription, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) WatchRemovedToken(opts *bind.WatchOpts, sink chan<- *TokenWhitelistRemovedToken) (event.Subscription, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) WatchUpdatedTokenLoadable(opts *bind.WatchOpts, sink chan<- *TokenWhitelistUpdatedTokenLoadable) (event.Subscription, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) WatchUpdatedTokenRate(opts *bind.WatchOpts, sink chan<- *TokenWhitelistUpdatedTokenRate) (event.Subscription, error)

+ func (_TokenWhitelist *TokenWhitelistFilterer) WatchUpdatedTokenRedeemable(opts *bind.WatchOpts, sink chan<- *TokenWhitelistUpdatedTokenRedeemable) (event.Subscription, error)

+ type TokenWhitelistRaw struct

+ Contract *TokenWhitelist

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

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

+ func (_TokenWhitelist *TokenWhitelistRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type TokenWhitelistRemovedExclusiveMethod struct

+ MethodId [4]byte

+ Raw types.Log

+ Token common.Address

+ type TokenWhitelistRemovedExclusiveMethodIterator struct

+ Event *TokenWhitelistRemovedExclusiveMethod

+ func (it *TokenWhitelistRemovedExclusiveMethodIterator) Close() error

+ func (it *TokenWhitelistRemovedExclusiveMethodIterator) Error() error

+ func (it *TokenWhitelistRemovedExclusiveMethodIterator) Next() bool

+ type TokenWhitelistRemovedMethodId struct

+ MethodId [4]byte

+ Raw types.Log

+ type TokenWhitelistRemovedMethodIdIterator struct

+ Event *TokenWhitelistRemovedMethodId

+ func (it *TokenWhitelistRemovedMethodIdIterator) Close() error

+ func (it *TokenWhitelistRemovedMethodIdIterator) Error() error

+ func (it *TokenWhitelistRemovedMethodIdIterator) Next() bool

+ type TokenWhitelistRemovedToken struct

+ Raw types.Log

+ Sender common.Address

+ Token common.Address

+ type TokenWhitelistRemovedTokenIterator struct

+ Event *TokenWhitelistRemovedToken

+ func (it *TokenWhitelistRemovedTokenIterator) Close() error

+ func (it *TokenWhitelistRemovedTokenIterator) Error() error

+ func (it *TokenWhitelistRemovedTokenIterator) Next() bool

+ type TokenWhitelistSession struct

+ CallOpts bind.CallOpts

+ Contract *TokenWhitelist

+ TransactOpts bind.TransactOpts

+ func (_TokenWhitelist *TokenWhitelistSession) AddTokens(_tokens []common.Address, _symbols [][32]byte, _magnitude []*big.Int, ...) (*types.Transaction, error)

+ func (_TokenWhitelist *TokenWhitelistSession) Claim(_to common.Address, _asset common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_TokenWhitelist *TokenWhitelistSession) ControllerNode() ([32]byte, error)

+ func (_TokenWhitelist *TokenWhitelistSession) EnsRegistry() (common.Address, error)

+ func (_TokenWhitelist *TokenWhitelistSession) GetERC20RecipientAndAmount(_token common.Address, _data []byte) (common.Address, *big.Int, error)

+ func (_TokenWhitelist *TokenWhitelistSession) GetStablecoinInfo() (string, *big.Int, *big.Int, bool, bool, bool, *big.Int, error)

+ func (_TokenWhitelist *TokenWhitelistSession) GetTokenInfo(_a common.Address) (string, *big.Int, *big.Int, bool, bool, bool, *big.Int, error)

+ func (_TokenWhitelist *TokenWhitelistSession) IsERC20MethodSupported(_token common.Address, _methodId [4]byte) (bool, error)

+ func (_TokenWhitelist *TokenWhitelistSession) IsERC20MethodWhitelisted(_methodId [4]byte) (bool, error)

+ func (_TokenWhitelist *TokenWhitelistSession) OracleNode() ([32]byte, error)

+ func (_TokenWhitelist *TokenWhitelistSession) RedeemableCounter() (*big.Int, error)

+ func (_TokenWhitelist *TokenWhitelistSession) RedeemableTokens() ([]common.Address, error)

+ func (_TokenWhitelist *TokenWhitelistSession) RemoveTokens(_tokens []common.Address) (*types.Transaction, error)

+ func (_TokenWhitelist *TokenWhitelistSession) SetTokenLoadable(_token common.Address, _loadable bool) (*types.Transaction, error)

+ func (_TokenWhitelist *TokenWhitelistSession) SetTokenRedeemable(_token common.Address, _redeemable bool) (*types.Transaction, error)

+ func (_TokenWhitelist *TokenWhitelistSession) Stablecoin() (common.Address, error)

+ func (_TokenWhitelist *TokenWhitelistSession) TokenAddressArray() ([]common.Address, error)

+ func (_TokenWhitelist *TokenWhitelistSession) UpdateTokenRate(_token common.Address, _rate *big.Int, _updateDate *big.Int) (*types.Transaction, error)

+ type TokenWhitelistTransactor struct

+ func NewTokenWhitelistTransactor(address common.Address, transactor bind.ContractTransactor) (*TokenWhitelistTransactor, error)

+ func (_TokenWhitelist *TokenWhitelistTransactor) AddTokens(opts *bind.TransactOpts, _tokens []common.Address, _symbols [][32]byte, ...) (*types.Transaction, error)

+ func (_TokenWhitelist *TokenWhitelistTransactor) Claim(opts *bind.TransactOpts, _to common.Address, _asset common.Address, ...) (*types.Transaction, error)

+ func (_TokenWhitelist *TokenWhitelistTransactor) RemoveTokens(opts *bind.TransactOpts, _tokens []common.Address) (*types.Transaction, error)

+ func (_TokenWhitelist *TokenWhitelistTransactor) SetTokenLoadable(opts *bind.TransactOpts, _token common.Address, _loadable bool) (*types.Transaction, error)

+ func (_TokenWhitelist *TokenWhitelistTransactor) SetTokenRedeemable(opts *bind.TransactOpts, _token common.Address, _redeemable bool) (*types.Transaction, error)

+ func (_TokenWhitelist *TokenWhitelistTransactor) UpdateTokenRate(opts *bind.TransactOpts, _token common.Address, _rate *big.Int, ...) (*types.Transaction, error)

+ type TokenWhitelistTransactorRaw struct

+ Contract *TokenWhitelistTransactor

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

+ func (_TokenWhitelist *TokenWhitelistTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type TokenWhitelistTransactorSession struct

+ Contract *TokenWhitelistTransactor

+ TransactOpts bind.TransactOpts

+ func (_TokenWhitelist *TokenWhitelistTransactorSession) AddTokens(_tokens []common.Address, _symbols [][32]byte, _magnitude []*big.Int, ...) (*types.Transaction, error)

+ func (_TokenWhitelist *TokenWhitelistTransactorSession) Claim(_to common.Address, _asset common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_TokenWhitelist *TokenWhitelistTransactorSession) RemoveTokens(_tokens []common.Address) (*types.Transaction, error)

+ func (_TokenWhitelist *TokenWhitelistTransactorSession) SetTokenLoadable(_token common.Address, _loadable bool) (*types.Transaction, error)

+ func (_TokenWhitelist *TokenWhitelistTransactorSession) SetTokenRedeemable(_token common.Address, _redeemable bool) (*types.Transaction, error)

+ func (_TokenWhitelist *TokenWhitelistTransactorSession) UpdateTokenRate(_token common.Address, _rate *big.Int, _updateDate *big.Int) (*types.Transaction, error)

+ type TokenWhitelistUpdatedTokenLoadable struct

+ Loadable bool

+ Raw types.Log

+ Sender common.Address

+ Token common.Address

+ type TokenWhitelistUpdatedTokenLoadableIterator struct

+ Event *TokenWhitelistUpdatedTokenLoadable

+ func (it *TokenWhitelistUpdatedTokenLoadableIterator) Close() error

+ func (it *TokenWhitelistUpdatedTokenLoadableIterator) Error() error

+ func (it *TokenWhitelistUpdatedTokenLoadableIterator) Next() bool

+ type TokenWhitelistUpdatedTokenRate struct

+ Rate *big.Int

+ Raw types.Log

+ Sender common.Address

+ Token common.Address

+ type TokenWhitelistUpdatedTokenRateIterator struct

+ Event *TokenWhitelistUpdatedTokenRate

+ func (it *TokenWhitelistUpdatedTokenRateIterator) Close() error

+ func (it *TokenWhitelistUpdatedTokenRateIterator) Error() error

+ func (it *TokenWhitelistUpdatedTokenRateIterator) Next() bool

+ type TokenWhitelistUpdatedTokenRedeemable struct

+ Raw types.Log

+ Redeemable bool

+ Sender common.Address

+ Token common.Address

+ type TokenWhitelistUpdatedTokenRedeemableIterator struct

+ Event *TokenWhitelistUpdatedTokenRedeemable

+ func (it *TokenWhitelistUpdatedTokenRedeemableIterator) Close() error

+ func (it *TokenWhitelistUpdatedTokenRedeemableIterator) Error() error

+ func (it *TokenWhitelistUpdatedTokenRedeemableIterator) Next() bool

+ type Wallet struct

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

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

+ type WalletAddedToWhitelist struct

+ Addresses []common.Address

+ Raw types.Log

+ Sender common.Address

+ type WalletAddedToWhitelistIterator struct

+ Event *WalletAddedToWhitelist

+ func (it *WalletAddedToWhitelistIterator) Close() error

+ func (it *WalletAddedToWhitelistIterator) Error() error

+ func (it *WalletAddedToWhitelistIterator) Next() bool

+ type WalletBulkTransferred struct

+ Assets []common.Address

+ Raw types.Log

+ To common.Address

+ type WalletBulkTransferredIterator struct

+ Event *WalletBulkTransferred

+ func (it *WalletBulkTransferredIterator) Close() error

+ func (it *WalletBulkTransferredIterator) Error() error

+ func (it *WalletBulkTransferredIterator) Next() bool

+ type WalletCaller struct

+ func NewWalletCaller(address common.Address, caller bind.ContractCaller) (*WalletCaller, error)

+ func (_Wallet *WalletCaller) CalculateHash(opts *bind.CallOpts, _addresses []common.Address) ([32]byte, error)

+ func (_Wallet *WalletCaller) ControllerNode(opts *bind.CallOpts) ([32]byte, error)

+ func (_Wallet *WalletCaller) ConvertToEther(opts *bind.CallOpts, _token common.Address, _amount *big.Int) (*big.Int, error)

+ func (_Wallet *WalletCaller) ConvertToStablecoin(opts *bind.CallOpts, _token common.Address, _amount *big.Int) (*big.Int, error)

+ func (_Wallet *WalletCaller) EnsRegistry(opts *bind.CallOpts) (common.Address, error)

+ func (_Wallet *WalletCaller) GasTopUpLimitAvailable(opts *bind.CallOpts) (*big.Int, error)

+ func (_Wallet *WalletCaller) GasTopUpLimitPending(opts *bind.CallOpts) (*big.Int, error)

+ func (_Wallet *WalletCaller) GasTopUpLimitUpdateable(opts *bind.CallOpts) (bool, error)

+ func (_Wallet *WalletCaller) GasTopUpLimitValue(opts *bind.CallOpts) (*big.Int, error)

+ func (_Wallet *WalletCaller) IsSetWhitelist(opts *bind.CallOpts) (bool, error)

+ func (_Wallet *WalletCaller) IsTransferable(opts *bind.CallOpts) (bool, error)

+ func (_Wallet *WalletCaller) LicenceNode(opts *bind.CallOpts) ([32]byte, error)

+ func (_Wallet *WalletCaller) LoadLimitAvailable(opts *bind.CallOpts) (*big.Int, error)

+ func (_Wallet *WalletCaller) LoadLimitPending(opts *bind.CallOpts) (*big.Int, error)

+ func (_Wallet *WalletCaller) LoadLimitUpdateable(opts *bind.CallOpts) (bool, error)

+ func (_Wallet *WalletCaller) LoadLimitValue(opts *bind.CallOpts) (*big.Int, error)

+ func (_Wallet *WalletCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_Wallet *WalletCaller) PendingWhitelistAddition(opts *bind.CallOpts) ([]common.Address, error)

+ func (_Wallet *WalletCaller) PendingWhitelistRemoval(opts *bind.CallOpts) ([]common.Address, error)

+ func (_Wallet *WalletCaller) SpendLimitAvailable(opts *bind.CallOpts) (*big.Int, error)

+ func (_Wallet *WalletCaller) SpendLimitPending(opts *bind.CallOpts) (*big.Int, error)

+ func (_Wallet *WalletCaller) SpendLimitUpdateable(opts *bind.CallOpts) (bool, error)

+ func (_Wallet *WalletCaller) SpendLimitValue(opts *bind.CallOpts) (*big.Int, error)

+ func (_Wallet *WalletCaller) SubmittedWhitelistAddition(opts *bind.CallOpts) (bool, error)

+ func (_Wallet *WalletCaller) SubmittedWhitelistRemoval(opts *bind.CallOpts) (bool, error)

+ func (_Wallet *WalletCaller) SupportsInterface(opts *bind.CallOpts, _interfaceID [4]byte) (bool, error)

+ func (_Wallet *WalletCaller) TokenWhitelistNode(opts *bind.CallOpts) ([32]byte, error)

+ func (_Wallet *WalletCaller) WALLETVERSION(opts *bind.CallOpts) (string, error)

+ func (_Wallet *WalletCaller) WhitelistArray(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error)

+ func (_Wallet *WalletCaller) WhitelistMap(opts *bind.CallOpts, arg0 common.Address) (bool, error)

+ type WalletCallerRaw struct

+ Contract *WalletCaller

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

+ type WalletCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *WalletCaller

+ func (_Wallet *WalletCallerSession) CalculateHash(_addresses []common.Address) ([32]byte, error)

+ func (_Wallet *WalletCallerSession) ControllerNode() ([32]byte, error)

+ func (_Wallet *WalletCallerSession) ConvertToEther(_token common.Address, _amount *big.Int) (*big.Int, error)

+ func (_Wallet *WalletCallerSession) ConvertToStablecoin(_token common.Address, _amount *big.Int) (*big.Int, error)

+ func (_Wallet *WalletCallerSession) EnsRegistry() (common.Address, error)

+ func (_Wallet *WalletCallerSession) GasTopUpLimitAvailable() (*big.Int, error)

+ func (_Wallet *WalletCallerSession) GasTopUpLimitPending() (*big.Int, error)

+ func (_Wallet *WalletCallerSession) GasTopUpLimitUpdateable() (bool, error)

+ func (_Wallet *WalletCallerSession) GasTopUpLimitValue() (*big.Int, error)

+ func (_Wallet *WalletCallerSession) IsSetWhitelist() (bool, error)

+ func (_Wallet *WalletCallerSession) IsTransferable() (bool, error)

+ func (_Wallet *WalletCallerSession) LicenceNode() ([32]byte, error)

+ func (_Wallet *WalletCallerSession) LoadLimitAvailable() (*big.Int, error)

+ func (_Wallet *WalletCallerSession) LoadLimitPending() (*big.Int, error)

+ func (_Wallet *WalletCallerSession) LoadLimitUpdateable() (bool, error)

+ func (_Wallet *WalletCallerSession) LoadLimitValue() (*big.Int, error)

+ func (_Wallet *WalletCallerSession) Owner() (common.Address, error)

+ func (_Wallet *WalletCallerSession) PendingWhitelistAddition() ([]common.Address, error)

+ func (_Wallet *WalletCallerSession) PendingWhitelistRemoval() ([]common.Address, error)

+ func (_Wallet *WalletCallerSession) SpendLimitAvailable() (*big.Int, error)

+ func (_Wallet *WalletCallerSession) SpendLimitPending() (*big.Int, error)

+ func (_Wallet *WalletCallerSession) SpendLimitUpdateable() (bool, error)

+ func (_Wallet *WalletCallerSession) SpendLimitValue() (*big.Int, error)

+ func (_Wallet *WalletCallerSession) SubmittedWhitelistAddition() (bool, error)

+ func (_Wallet *WalletCallerSession) SubmittedWhitelistRemoval() (bool, error)

+ func (_Wallet *WalletCallerSession) SupportsInterface(_interfaceID [4]byte) (bool, error)

+ func (_Wallet *WalletCallerSession) TokenWhitelistNode() ([32]byte, error)

+ func (_Wallet *WalletCallerSession) WALLETVERSION() (string, error)

+ func (_Wallet *WalletCallerSession) WhitelistArray(arg0 *big.Int) (common.Address, error)

+ func (_Wallet *WalletCallerSession) WhitelistMap(arg0 common.Address) (bool, error)

+ type WalletCancelledWhitelistAddition struct

+ Hash [32]byte

+ Raw types.Log

+ Sender common.Address

+ type WalletCancelledWhitelistAdditionIterator struct

+ Event *WalletCancelledWhitelistAddition

+ func (it *WalletCancelledWhitelistAdditionIterator) Close() error

+ func (it *WalletCancelledWhitelistAdditionIterator) Error() error

+ func (it *WalletCancelledWhitelistAdditionIterator) Next() bool

+ type WalletCancelledWhitelistRemoval struct

+ Hash [32]byte

+ Raw types.Log

+ Sender common.Address

+ type WalletCancelledWhitelistRemovalIterator struct

+ Event *WalletCancelledWhitelistRemoval

+ func (it *WalletCancelledWhitelistRemovalIterator) Close() error

+ func (it *WalletCancelledWhitelistRemovalIterator) Error() error

+ func (it *WalletCancelledWhitelistRemovalIterator) Next() bool

+ type WalletDeployer struct

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

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

+ type WalletDeployerCachedWallet struct

+ Raw types.Log

+ Wallet common.Address

+ type WalletDeployerCachedWalletIterator struct

+ Event *WalletDeployerCachedWallet

+ func (it *WalletDeployerCachedWalletIterator) Close() error

+ func (it *WalletDeployerCachedWalletIterator) Error() error

+ func (it *WalletDeployerCachedWalletIterator) Next() bool

+ type WalletDeployerCaller struct

+ func NewWalletDeployerCaller(address common.Address, caller bind.ContractCaller) (*WalletDeployerCaller, error)

+ func (_WalletDeployer *WalletDeployerCaller) CachedWallets(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error)

+ func (_WalletDeployer *WalletDeployerCaller) CachedWalletsCount(opts *bind.CallOpts) (*big.Int, error)

+ func (_WalletDeployer *WalletDeployerCaller) ControllerNode(opts *bind.CallOpts) ([32]byte, error)

+ func (_WalletDeployer *WalletDeployerCaller) DefaultSpendLimit(opts *bind.CallOpts) (*big.Int, error)

+ func (_WalletDeployer *WalletDeployerCaller) DeployedWallets(opts *bind.CallOpts, arg0 common.Address) (common.Address, error)

+ func (_WalletDeployer *WalletDeployerCaller) Ens(opts *bind.CallOpts) (common.Address, error)

+ func (_WalletDeployer *WalletDeployerCaller) EnsRegistry(opts *bind.CallOpts) (common.Address, error)

+ func (_WalletDeployer *WalletDeployerCaller) LicenceNode(opts *bind.CallOpts) ([32]byte, error)

+ func (_WalletDeployer *WalletDeployerCaller) TokenWhitelistNode(opts *bind.CallOpts) ([32]byte, error)

+ type WalletDeployerCallerRaw struct

+ Contract *WalletDeployerCaller

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

+ type WalletDeployerCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *WalletDeployerCaller

+ func (_WalletDeployer *WalletDeployerCallerSession) CachedWallets(arg0 *big.Int) (common.Address, error)

+ func (_WalletDeployer *WalletDeployerCallerSession) CachedWalletsCount() (*big.Int, error)

+ func (_WalletDeployer *WalletDeployerCallerSession) ControllerNode() ([32]byte, error)

+ func (_WalletDeployer *WalletDeployerCallerSession) DefaultSpendLimit() (*big.Int, error)

+ func (_WalletDeployer *WalletDeployerCallerSession) DeployedWallets(arg0 common.Address) (common.Address, error)

+ func (_WalletDeployer *WalletDeployerCallerSession) Ens() (common.Address, error)

+ func (_WalletDeployer *WalletDeployerCallerSession) EnsRegistry() (common.Address, error)

+ func (_WalletDeployer *WalletDeployerCallerSession) LicenceNode() ([32]byte, error)

+ func (_WalletDeployer *WalletDeployerCallerSession) TokenWhitelistNode() ([32]byte, error)

+ type WalletDeployerDeployedWallet struct

+ Owner common.Address

+ Raw types.Log

+ Wallet common.Address

+ type WalletDeployerDeployedWalletIterator struct

+ Event *WalletDeployerDeployedWallet

+ func (it *WalletDeployerDeployedWalletIterator) Close() error

+ func (it *WalletDeployerDeployedWalletIterator) Error() error

+ func (it *WalletDeployerDeployedWalletIterator) Next() bool

+ type WalletDeployerFilterer struct

+ func NewWalletDeployerFilterer(address common.Address, filterer bind.ContractFilterer) (*WalletDeployerFilterer, error)

+ func (_WalletDeployer *WalletDeployerFilterer) FilterCachedWallet(opts *bind.FilterOpts) (*WalletDeployerCachedWalletIterator, error)

+ func (_WalletDeployer *WalletDeployerFilterer) FilterDeployedWallet(opts *bind.FilterOpts) (*WalletDeployerDeployedWalletIterator, error)

+ func (_WalletDeployer *WalletDeployerFilterer) FilterMigratedWallet(opts *bind.FilterOpts) (*WalletDeployerMigratedWalletIterator, error)

+ func (_WalletDeployer *WalletDeployerFilterer) WatchCachedWallet(opts *bind.WatchOpts, sink chan<- *WalletDeployerCachedWallet) (event.Subscription, error)

+ func (_WalletDeployer *WalletDeployerFilterer) WatchDeployedWallet(opts *bind.WatchOpts, sink chan<- *WalletDeployerDeployedWallet) (event.Subscription, error)

+ func (_WalletDeployer *WalletDeployerFilterer) WatchMigratedWallet(opts *bind.WatchOpts, sink chan<- *WalletDeployerMigratedWallet) (event.Subscription, error)

+ type WalletDeployerMigratedWallet struct

+ OldWallet common.Address

+ Owner common.Address

+ Raw types.Log

+ Wallet common.Address

+ type WalletDeployerMigratedWalletIterator struct

+ Event *WalletDeployerMigratedWallet

+ func (it *WalletDeployerMigratedWalletIterator) Close() error

+ func (it *WalletDeployerMigratedWalletIterator) Error() error

+ func (it *WalletDeployerMigratedWalletIterator) Next() bool

+ type WalletDeployerRaw struct

+ Contract *WalletDeployer

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

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

+ func (_WalletDeployer *WalletDeployerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type WalletDeployerSession struct

+ CallOpts bind.CallOpts

+ Contract *WalletDeployer

+ TransactOpts bind.TransactOpts

+ func (_WalletDeployer *WalletDeployerSession) CacheWallet() (*types.Transaction, error)

+ func (_WalletDeployer *WalletDeployerSession) CachedWallets(arg0 *big.Int) (common.Address, error)

+ func (_WalletDeployer *WalletDeployerSession) CachedWalletsCount() (*big.Int, error)

+ func (_WalletDeployer *WalletDeployerSession) ControllerNode() ([32]byte, error)

+ func (_WalletDeployer *WalletDeployerSession) DefaultSpendLimit() (*big.Int, error)

+ func (_WalletDeployer *WalletDeployerSession) DeployWallet(_owner common.Address) (*types.Transaction, error)

+ func (_WalletDeployer *WalletDeployerSession) DeployedWallets(arg0 common.Address) (common.Address, error)

+ func (_WalletDeployer *WalletDeployerSession) Ens() (common.Address, error)

+ func (_WalletDeployer *WalletDeployerSession) EnsRegistry() (common.Address, error)

+ func (_WalletDeployer *WalletDeployerSession) LicenceNode() ([32]byte, error)

+ func (_WalletDeployer *WalletDeployerSession) MigrateWallet(_owner common.Address, _oldWallet common.Address, _initializedSpendLimit bool, ...) (*types.Transaction, error)

+ func (_WalletDeployer *WalletDeployerSession) TokenWhitelistNode() ([32]byte, error)

+ type WalletDeployerTransactor struct

+ func NewWalletDeployerTransactor(address common.Address, transactor bind.ContractTransactor) (*WalletDeployerTransactor, error)

+ func (_WalletDeployer *WalletDeployerTransactor) CacheWallet(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_WalletDeployer *WalletDeployerTransactor) DeployWallet(opts *bind.TransactOpts, _owner common.Address) (*types.Transaction, error)

+ func (_WalletDeployer *WalletDeployerTransactor) MigrateWallet(opts *bind.TransactOpts, _owner common.Address, _oldWallet common.Address, ...) (*types.Transaction, error)

+ type WalletDeployerTransactorRaw struct

+ Contract *WalletDeployerTransactor

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

+ func (_WalletDeployer *WalletDeployerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type WalletDeployerTransactorSession struct

+ Contract *WalletDeployerTransactor

+ TransactOpts bind.TransactOpts

+ func (_WalletDeployer *WalletDeployerTransactorSession) CacheWallet() (*types.Transaction, error)

+ func (_WalletDeployer *WalletDeployerTransactorSession) DeployWallet(_owner common.Address) (*types.Transaction, error)

+ func (_WalletDeployer *WalletDeployerTransactorSession) MigrateWallet(_owner common.Address, _oldWallet common.Address, _initializedSpendLimit bool, ...) (*types.Transaction, error)

+ type WalletExecutedTransaction struct

+ Data []byte

+ Destination common.Address

+ Raw types.Log

+ Returndata []byte

+ Value *big.Int

+ type WalletExecutedTransactionIterator struct

+ Event *WalletExecutedTransaction

+ func (it *WalletExecutedTransactionIterator) Close() error

+ func (it *WalletExecutedTransactionIterator) Error() error

+ func (it *WalletExecutedTransactionIterator) Next() bool

+ type WalletFilterer struct

+ func NewWalletFilterer(address common.Address, filterer bind.ContractFilterer) (*WalletFilterer, error)

+ func (_Wallet *WalletFilterer) FilterAddedToWhitelist(opts *bind.FilterOpts) (*WalletAddedToWhitelistIterator, error)

+ func (_Wallet *WalletFilterer) FilterBulkTransferred(opts *bind.FilterOpts) (*WalletBulkTransferredIterator, error)

+ func (_Wallet *WalletFilterer) FilterCancelledWhitelistAddition(opts *bind.FilterOpts) (*WalletCancelledWhitelistAdditionIterator, error)

+ func (_Wallet *WalletFilterer) FilterCancelledWhitelistRemoval(opts *bind.FilterOpts) (*WalletCancelledWhitelistRemovalIterator, error)

+ func (_Wallet *WalletFilterer) FilterExecutedTransaction(opts *bind.FilterOpts) (*WalletExecutedTransactionIterator, error)

+ func (_Wallet *WalletFilterer) FilterLoadedTokenCard(opts *bind.FilterOpts) (*WalletLoadedTokenCardIterator, error)

+ func (_Wallet *WalletFilterer) FilterLockedOwnership(opts *bind.FilterOpts) (*WalletLockedOwnershipIterator, error)

+ func (_Wallet *WalletFilterer) FilterReceived(opts *bind.FilterOpts) (*WalletReceivedIterator, error)

+ func (_Wallet *WalletFilterer) FilterRemovedFromWhitelist(opts *bind.FilterOpts) (*WalletRemovedFromWhitelistIterator, error)

+ func (_Wallet *WalletFilterer) FilterSetGasTopUpLimit(opts *bind.FilterOpts) (*WalletSetGasTopUpLimitIterator, error)

+ func (_Wallet *WalletFilterer) FilterSetLoadLimit(opts *bind.FilterOpts) (*WalletSetLoadLimitIterator, error)

+ func (_Wallet *WalletFilterer) FilterSetSpendLimit(opts *bind.FilterOpts) (*WalletSetSpendLimitIterator, error)

+ func (_Wallet *WalletFilterer) FilterSubmittedGasTopUpLimitUpdate(opts *bind.FilterOpts) (*WalletSubmittedGasTopUpLimitUpdateIterator, error)

+ func (_Wallet *WalletFilterer) FilterSubmittedLoadLimitUpdate(opts *bind.FilterOpts) (*WalletSubmittedLoadLimitUpdateIterator, error)

+ func (_Wallet *WalletFilterer) FilterSubmittedSpendLimitUpdate(opts *bind.FilterOpts) (*WalletSubmittedSpendLimitUpdateIterator, error)

+ func (_Wallet *WalletFilterer) FilterSubmittedWhitelistAddition(opts *bind.FilterOpts) (*WalletSubmittedWhitelistAdditionIterator, error)

+ func (_Wallet *WalletFilterer) FilterSubmittedWhitelistRemoval(opts *bind.FilterOpts) (*WalletSubmittedWhitelistRemovalIterator, error)

+ func (_Wallet *WalletFilterer) FilterToppedUpGas(opts *bind.FilterOpts) (*WalletToppedUpGasIterator, error)

+ func (_Wallet *WalletFilterer) FilterTransferred(opts *bind.FilterOpts) (*WalletTransferredIterator, error)

+ func (_Wallet *WalletFilterer) FilterTransferredOwnership(opts *bind.FilterOpts) (*WalletTransferredOwnershipIterator, error)

+ func (_Wallet *WalletFilterer) FilterUpdatedAvailableLimit(opts *bind.FilterOpts) (*WalletUpdatedAvailableLimitIterator, error)

+ func (_Wallet *WalletFilterer) WatchAddedToWhitelist(opts *bind.WatchOpts, sink chan<- *WalletAddedToWhitelist) (event.Subscription, error)

+ func (_Wallet *WalletFilterer) WatchBulkTransferred(opts *bind.WatchOpts, sink chan<- *WalletBulkTransferred) (event.Subscription, error)

+ func (_Wallet *WalletFilterer) WatchCancelledWhitelistAddition(opts *bind.WatchOpts, sink chan<- *WalletCancelledWhitelistAddition) (event.Subscription, error)

+ func (_Wallet *WalletFilterer) WatchCancelledWhitelistRemoval(opts *bind.WatchOpts, sink chan<- *WalletCancelledWhitelistRemoval) (event.Subscription, error)

+ func (_Wallet *WalletFilterer) WatchExecutedTransaction(opts *bind.WatchOpts, sink chan<- *WalletExecutedTransaction) (event.Subscription, error)

+ func (_Wallet *WalletFilterer) WatchLoadedTokenCard(opts *bind.WatchOpts, sink chan<- *WalletLoadedTokenCard) (event.Subscription, error)

+ func (_Wallet *WalletFilterer) WatchLockedOwnership(opts *bind.WatchOpts, sink chan<- *WalletLockedOwnership) (event.Subscription, error)

+ func (_Wallet *WalletFilterer) WatchReceived(opts *bind.WatchOpts, sink chan<- *WalletReceived) (event.Subscription, error)

+ func (_Wallet *WalletFilterer) WatchRemovedFromWhitelist(opts *bind.WatchOpts, sink chan<- *WalletRemovedFromWhitelist) (event.Subscription, error)

+ func (_Wallet *WalletFilterer) WatchSetGasTopUpLimit(opts *bind.WatchOpts, sink chan<- *WalletSetGasTopUpLimit) (event.Subscription, error)

+ func (_Wallet *WalletFilterer) WatchSetLoadLimit(opts *bind.WatchOpts, sink chan<- *WalletSetLoadLimit) (event.Subscription, error)

+ func (_Wallet *WalletFilterer) WatchSetSpendLimit(opts *bind.WatchOpts, sink chan<- *WalletSetSpendLimit) (event.Subscription, error)

+ func (_Wallet *WalletFilterer) WatchSubmittedGasTopUpLimitUpdate(opts *bind.WatchOpts, sink chan<- *WalletSubmittedGasTopUpLimitUpdate) (event.Subscription, error)

+ func (_Wallet *WalletFilterer) WatchSubmittedLoadLimitUpdate(opts *bind.WatchOpts, sink chan<- *WalletSubmittedLoadLimitUpdate) (event.Subscription, error)

+ func (_Wallet *WalletFilterer) WatchSubmittedSpendLimitUpdate(opts *bind.WatchOpts, sink chan<- *WalletSubmittedSpendLimitUpdate) (event.Subscription, error)

+ func (_Wallet *WalletFilterer) WatchSubmittedWhitelistAddition(opts *bind.WatchOpts, sink chan<- *WalletSubmittedWhitelistAddition) (event.Subscription, error)

+ func (_Wallet *WalletFilterer) WatchSubmittedWhitelistRemoval(opts *bind.WatchOpts, sink chan<- *WalletSubmittedWhitelistRemoval) (event.Subscription, error)

+ func (_Wallet *WalletFilterer) WatchToppedUpGas(opts *bind.WatchOpts, sink chan<- *WalletToppedUpGas) (event.Subscription, error)

+ func (_Wallet *WalletFilterer) WatchTransferred(opts *bind.WatchOpts, sink chan<- *WalletTransferred) (event.Subscription, error)

+ func (_Wallet *WalletFilterer) WatchTransferredOwnership(opts *bind.WatchOpts, sink chan<- *WalletTransferredOwnership) (event.Subscription, error)

+ func (_Wallet *WalletFilterer) WatchUpdatedAvailableLimit(opts *bind.WatchOpts, sink chan<- *WalletUpdatedAvailableLimit) (event.Subscription, error)

+ type WalletLoadedTokenCard struct

+ Amount *big.Int

+ Asset common.Address

+ Raw types.Log

+ type WalletLoadedTokenCardIterator struct

+ Event *WalletLoadedTokenCard

+ func (it *WalletLoadedTokenCardIterator) Close() error

+ func (it *WalletLoadedTokenCardIterator) Error() error

+ func (it *WalletLoadedTokenCardIterator) Next() bool

+ type WalletLockedOwnership struct

+ Locked common.Address

+ Raw types.Log

+ type WalletLockedOwnershipIterator struct

+ Event *WalletLockedOwnership

+ func (it *WalletLockedOwnershipIterator) Close() error

+ func (it *WalletLockedOwnershipIterator) Error() error

+ func (it *WalletLockedOwnershipIterator) Next() bool

+ type WalletRaw struct

+ Contract *Wallet

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

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

+ func (_Wallet *WalletRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type WalletReceived struct

+ Amount *big.Int

+ From common.Address

+ Raw types.Log

+ type WalletReceivedIterator struct

+ Event *WalletReceived

+ func (it *WalletReceivedIterator) Close() error

+ func (it *WalletReceivedIterator) Error() error

+ func (it *WalletReceivedIterator) Next() bool

+ type WalletRemovedFromWhitelist struct

+ Addresses []common.Address

+ Raw types.Log

+ Sender common.Address

+ type WalletRemovedFromWhitelistIterator struct

+ Event *WalletRemovedFromWhitelist

+ func (it *WalletRemovedFromWhitelistIterator) Close() error

+ func (it *WalletRemovedFromWhitelistIterator) Error() error

+ func (it *WalletRemovedFromWhitelistIterator) Next() bool

+ type WalletSession struct

+ CallOpts bind.CallOpts

+ Contract *Wallet

+ TransactOpts bind.TransactOpts

+ func (_Wallet *WalletSession) BulkTransfer(_to common.Address, _assets []common.Address) (*types.Transaction, error)

+ func (_Wallet *WalletSession) CalculateHash(_addresses []common.Address) ([32]byte, error)

+ func (_Wallet *WalletSession) CancelWhitelistAddition(_hash [32]byte) (*types.Transaction, error)

+ func (_Wallet *WalletSession) CancelWhitelistRemoval(_hash [32]byte) (*types.Transaction, error)

+ func (_Wallet *WalletSession) ConfirmGasTopUpLimitUpdate(_amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletSession) ConfirmLoadLimitUpdate(_amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletSession) ConfirmSpendLimitUpdate(_amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletSession) ConfirmWhitelistAddition(_hash [32]byte) (*types.Transaction, error)

+ func (_Wallet *WalletSession) ConfirmWhitelistRemoval(_hash [32]byte) (*types.Transaction, error)

+ func (_Wallet *WalletSession) ControllerNode() ([32]byte, error)

+ func (_Wallet *WalletSession) ConvertToEther(_token common.Address, _amount *big.Int) (*big.Int, error)

+ func (_Wallet *WalletSession) ConvertToStablecoin(_token common.Address, _amount *big.Int) (*big.Int, error)

+ func (_Wallet *WalletSession) EnsRegistry() (common.Address, error)

+ func (_Wallet *WalletSession) ExecuteTransaction(_destination common.Address, _value *big.Int, _data []byte) (*types.Transaction, error)

+ func (_Wallet *WalletSession) GasTopUpLimitAvailable() (*big.Int, error)

+ func (_Wallet *WalletSession) GasTopUpLimitPending() (*big.Int, error)

+ func (_Wallet *WalletSession) GasTopUpLimitUpdateable() (bool, error)

+ func (_Wallet *WalletSession) GasTopUpLimitValue() (*big.Int, error)

+ func (_Wallet *WalletSession) IsSetWhitelist() (bool, error)

+ func (_Wallet *WalletSession) IsTransferable() (bool, error)

+ func (_Wallet *WalletSession) LicenceNode() ([32]byte, error)

+ func (_Wallet *WalletSession) LoadLimitAvailable() (*big.Int, error)

+ func (_Wallet *WalletSession) LoadLimitPending() (*big.Int, error)

+ func (_Wallet *WalletSession) LoadLimitUpdateable() (bool, error)

+ func (_Wallet *WalletSession) LoadLimitValue() (*big.Int, error)

+ func (_Wallet *WalletSession) LoadTokenCard(_asset common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletSession) Owner() (common.Address, error)

+ func (_Wallet *WalletSession) PendingWhitelistAddition() ([]common.Address, error)

+ func (_Wallet *WalletSession) PendingWhitelistRemoval() ([]common.Address, error)

+ func (_Wallet *WalletSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Wallet *WalletSession) SetGasTopUpLimit(_amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletSession) SetLoadLimit(_amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletSession) SetSpendLimit(_amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletSession) SetWhitelist(_addresses []common.Address) (*types.Transaction, error)

+ func (_Wallet *WalletSession) SpendLimitAvailable() (*big.Int, error)

+ func (_Wallet *WalletSession) SpendLimitPending() (*big.Int, error)

+ func (_Wallet *WalletSession) SpendLimitUpdateable() (bool, error)

+ func (_Wallet *WalletSession) SpendLimitValue() (*big.Int, error)

+ func (_Wallet *WalletSession) SubmitGasTopUpLimitUpdate(_amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletSession) SubmitLoadLimitUpdate(_amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletSession) SubmitSpendLimitUpdate(_amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletSession) SubmitWhitelistAddition(_addresses []common.Address) (*types.Transaction, error)

+ func (_Wallet *WalletSession) SubmitWhitelistRemoval(_addresses []common.Address) (*types.Transaction, error)

+ func (_Wallet *WalletSession) SubmittedWhitelistAddition() (bool, error)

+ func (_Wallet *WalletSession) SubmittedWhitelistRemoval() (bool, error)

+ func (_Wallet *WalletSession) SupportsInterface(_interfaceID [4]byte) (bool, error)

+ func (_Wallet *WalletSession) TokenWhitelistNode() ([32]byte, error)

+ func (_Wallet *WalletSession) TopUpGas(_amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletSession) Transfer(_to common.Address, _asset common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletSession) TransferOwnership(_account common.Address, _transferable bool) (*types.Transaction, error)

+ func (_Wallet *WalletSession) WALLETVERSION() (string, error)

+ func (_Wallet *WalletSession) WhitelistArray(arg0 *big.Int) (common.Address, error)

+ func (_Wallet *WalletSession) WhitelistMap(arg0 common.Address) (bool, error)

+ type WalletSetGasTopUpLimit struct

+ Amount *big.Int

+ Raw types.Log

+ Sender common.Address

+ type WalletSetGasTopUpLimitIterator struct

+ Event *WalletSetGasTopUpLimit

+ func (it *WalletSetGasTopUpLimitIterator) Close() error

+ func (it *WalletSetGasTopUpLimitIterator) Error() error

+ func (it *WalletSetGasTopUpLimitIterator) Next() bool

+ type WalletSetLoadLimit struct

+ Amount *big.Int

+ Raw types.Log

+ Sender common.Address

+ type WalletSetLoadLimitIterator struct

+ Event *WalletSetLoadLimit

+ func (it *WalletSetLoadLimitIterator) Close() error

+ func (it *WalletSetLoadLimitIterator) Error() error

+ func (it *WalletSetLoadLimitIterator) Next() bool

+ type WalletSetSpendLimit struct

+ Amount *big.Int

+ Raw types.Log

+ Sender common.Address

+ type WalletSetSpendLimitIterator struct

+ Event *WalletSetSpendLimit

+ func (it *WalletSetSpendLimitIterator) Close() error

+ func (it *WalletSetSpendLimitIterator) Error() error

+ func (it *WalletSetSpendLimitIterator) Next() bool

+ type WalletSubmittedGasTopUpLimitUpdate struct

+ Amount *big.Int

+ Raw types.Log

+ type WalletSubmittedGasTopUpLimitUpdateIterator struct

+ Event *WalletSubmittedGasTopUpLimitUpdate

+ func (it *WalletSubmittedGasTopUpLimitUpdateIterator) Close() error

+ func (it *WalletSubmittedGasTopUpLimitUpdateIterator) Error() error

+ func (it *WalletSubmittedGasTopUpLimitUpdateIterator) Next() bool

+ type WalletSubmittedLoadLimitUpdate struct

+ Amount *big.Int

+ Raw types.Log

+ type WalletSubmittedLoadLimitUpdateIterator struct

+ Event *WalletSubmittedLoadLimitUpdate

+ func (it *WalletSubmittedLoadLimitUpdateIterator) Close() error

+ func (it *WalletSubmittedLoadLimitUpdateIterator) Error() error

+ func (it *WalletSubmittedLoadLimitUpdateIterator) Next() bool

+ type WalletSubmittedSpendLimitUpdate struct

+ Amount *big.Int

+ Raw types.Log

+ type WalletSubmittedSpendLimitUpdateIterator struct

+ Event *WalletSubmittedSpendLimitUpdate

+ func (it *WalletSubmittedSpendLimitUpdateIterator) Close() error

+ func (it *WalletSubmittedSpendLimitUpdateIterator) Error() error

+ func (it *WalletSubmittedSpendLimitUpdateIterator) Next() bool

+ type WalletSubmittedWhitelistAddition struct

+ Addresses []common.Address

+ Hash [32]byte

+ Raw types.Log

+ type WalletSubmittedWhitelistAdditionIterator struct

+ Event *WalletSubmittedWhitelistAddition

+ func (it *WalletSubmittedWhitelistAdditionIterator) Close() error

+ func (it *WalletSubmittedWhitelistAdditionIterator) Error() error

+ func (it *WalletSubmittedWhitelistAdditionIterator) Next() bool

+ type WalletSubmittedWhitelistRemoval struct

+ Addresses []common.Address

+ Hash [32]byte

+ Raw types.Log

+ type WalletSubmittedWhitelistRemovalIterator struct

+ Event *WalletSubmittedWhitelistRemoval

+ func (it *WalletSubmittedWhitelistRemovalIterator) Close() error

+ func (it *WalletSubmittedWhitelistRemovalIterator) Error() error

+ func (it *WalletSubmittedWhitelistRemovalIterator) Next() bool

+ type WalletToppedUpGas struct

+ Amount *big.Int

+ Owner common.Address

+ Raw types.Log

+ Sender common.Address

+ type WalletToppedUpGasIterator struct

+ Event *WalletToppedUpGas

+ func (it *WalletToppedUpGasIterator) Close() error

+ func (it *WalletToppedUpGasIterator) Error() error

+ func (it *WalletToppedUpGasIterator) Next() bool

+ type WalletTransactor struct

+ func NewWalletTransactor(address common.Address, transactor bind.ContractTransactor) (*WalletTransactor, error)

+ func (_Wallet *WalletTransactor) BulkTransfer(opts *bind.TransactOpts, _to common.Address, _assets []common.Address) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) CancelWhitelistAddition(opts *bind.TransactOpts, _hash [32]byte) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) CancelWhitelistRemoval(opts *bind.TransactOpts, _hash [32]byte) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) ConfirmGasTopUpLimitUpdate(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) ConfirmLoadLimitUpdate(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) ConfirmSpendLimitUpdate(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) ConfirmWhitelistAddition(opts *bind.TransactOpts, _hash [32]byte) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) ConfirmWhitelistRemoval(opts *bind.TransactOpts, _hash [32]byte) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) ExecuteTransaction(opts *bind.TransactOpts, _destination common.Address, _value *big.Int, ...) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) LoadTokenCard(opts *bind.TransactOpts, _asset common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) SetGasTopUpLimit(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) SetLoadLimit(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) SetSpendLimit(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) SetWhitelist(opts *bind.TransactOpts, _addresses []common.Address) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) SubmitGasTopUpLimitUpdate(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) SubmitLoadLimitUpdate(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) SubmitSpendLimitUpdate(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) SubmitWhitelistAddition(opts *bind.TransactOpts, _addresses []common.Address) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) SubmitWhitelistRemoval(opts *bind.TransactOpts, _addresses []common.Address) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) TopUpGas(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _asset common.Address, ...) (*types.Transaction, error)

+ func (_Wallet *WalletTransactor) TransferOwnership(opts *bind.TransactOpts, _account common.Address, _transferable bool) (*types.Transaction, error)

+ type WalletTransactorRaw struct

+ Contract *WalletTransactor

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

+ func (_Wallet *WalletTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type WalletTransactorSession struct

+ Contract *WalletTransactor

+ TransactOpts bind.TransactOpts

+ func (_Wallet *WalletTransactorSession) BulkTransfer(_to common.Address, _assets []common.Address) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) CancelWhitelistAddition(_hash [32]byte) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) CancelWhitelistRemoval(_hash [32]byte) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) ConfirmGasTopUpLimitUpdate(_amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) ConfirmLoadLimitUpdate(_amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) ConfirmSpendLimitUpdate(_amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) ConfirmWhitelistAddition(_hash [32]byte) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) ConfirmWhitelistRemoval(_hash [32]byte) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) ExecuteTransaction(_destination common.Address, _value *big.Int, _data []byte) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) LoadTokenCard(_asset common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) SetGasTopUpLimit(_amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) SetLoadLimit(_amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) SetSpendLimit(_amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) SetWhitelist(_addresses []common.Address) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) SubmitGasTopUpLimitUpdate(_amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) SubmitLoadLimitUpdate(_amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) SubmitSpendLimitUpdate(_amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) SubmitWhitelistAddition(_addresses []common.Address) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) SubmitWhitelistRemoval(_addresses []common.Address) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) TopUpGas(_amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) Transfer(_to common.Address, _asset common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Wallet *WalletTransactorSession) TransferOwnership(_account common.Address, _transferable bool) (*types.Transaction, error)

+ type WalletTransferred struct

+ Amount *big.Int

+ Asset common.Address

+ Raw types.Log

+ To common.Address

+ type WalletTransferredIterator struct

+ Event *WalletTransferred

+ func (it *WalletTransferredIterator) Close() error

+ func (it *WalletTransferredIterator) Error() error

+ func (it *WalletTransferredIterator) Next() bool

+ type WalletTransferredOwnership struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ type WalletTransferredOwnershipIterator struct

+ Event *WalletTransferredOwnership

+ func (it *WalletTransferredOwnershipIterator) Close() error

+ func (it *WalletTransferredOwnershipIterator) Error() error

+ func (it *WalletTransferredOwnershipIterator) Next() bool

+ type WalletUpdatedAvailableLimit struct

+ Raw types.Log

+ type WalletUpdatedAvailableLimitIterator struct

+ Event *WalletUpdatedAvailableLimit

+ func (it *WalletUpdatedAvailableLimitIterator) Close() error

+ func (it *WalletUpdatedAvailableLimitIterator) Error() error

+ func (it *WalletUpdatedAvailableLimitIterator) Next() bool

Other modules containing this package

github.com/tokencard/contracts

github.com/tokencard/contracts/v3

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