mocks

package

Go to main page

Versions in this module

v2

v2.3.1

Jan 7, 2020

Changes in this version

+ const IsValidSignatureExporterABI

+ var IsValidSignatureExporterBin = "0x608060405234801561001057600080fd5b506040516102833803806102838339818101604052602081101561003357600080fd5b5051600080546001600160a01b039092166001600160a01b031990921691909117905561021e806100656000396000f3fe608060405234801561001057600080fd5b506004361061002b5760003560e01c806320c13b0b14610030575b600080fd5b6100f26004803603604081101561004657600080fd5b81019060208101813564010000000081111561006157600080fd5b82018360208201111561007357600080fd5b8035906020019184600183028401116401000000008311171561009557600080fd5b9193909290916020810190356401000000008111156100b357600080fd5b8201836020820111156100c557600080fd5b803590602001918460018302840111640100000000831117156100e757600080fd5b50909250905061010f565b604080516001600160e01b03199092168252519081900360200190f35b60008054604080516320c13b0b60e01b815260048101918252604481018790526001600160a01b03909216916320c13b0b9188918891889188919081906024810190606401878780828437600083820152601f01601f191690910184810383528581526020019050858580828437600081840152601f19601f820116905080830192505050965050505050505060206040518083038186803b1580156101b457600080fd5b505afa1580156101c8573d6000803e3d6000fd5b505050506040513d60208110156101de57600080fd5b50519594505050505056fea265627a7a7231582015975b857ddf4a32c9d7ceb5b03a24e988f556a44aea878641efda4b6c0be0e164736f6c634300050f0032"

+ type IsValidSignatureExporter struct

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

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

+ type IsValidSignatureExporterCaller struct

+ func NewIsValidSignatureExporterCaller(address common.Address, caller bind.ContractCaller) (*IsValidSignatureExporterCaller, error)

+ func (_IsValidSignatureExporter *IsValidSignatureExporterCaller) IsValidSignature(opts *bind.CallOpts, _data []byte, _signature []byte) ([4]byte, error)

+ type IsValidSignatureExporterCallerRaw struct

+ Contract *IsValidSignatureExporterCaller

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

+ type IsValidSignatureExporterCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IsValidSignatureExporterCaller

+ func (_IsValidSignatureExporter *IsValidSignatureExporterCallerSession) IsValidSignature(_data []byte, _signature []byte) ([4]byte, error)

+ type IsValidSignatureExporterFilterer struct

+ func NewIsValidSignatureExporterFilterer(address common.Address, filterer bind.ContractFilterer) (*IsValidSignatureExporterFilterer, error)

+ type IsValidSignatureExporterRaw struct

+ Contract *IsValidSignatureExporter

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

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

+ func (_IsValidSignatureExporter *IsValidSignatureExporterRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IsValidSignatureExporterSession struct

+ CallOpts bind.CallOpts

+ Contract *IsValidSignatureExporter

+ TransactOpts bind.TransactOpts

+ func (_IsValidSignatureExporter *IsValidSignatureExporterSession) IsValidSignature(_data []byte, _signature []byte) ([4]byte, error)

+ type IsValidSignatureExporterTransactor struct

+ func NewIsValidSignatureExporterTransactor(address common.Address, transactor bind.ContractTransactor) (*IsValidSignatureExporterTransactor, error)

+ type IsValidSignatureExporterTransactorRaw struct

+ Contract *IsValidSignatureExporterTransactor

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

+ func (_IsValidSignatureExporter *IsValidSignatureExporterTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IsValidSignatureExporterTransactorSession struct

+ Contract *IsValidSignatureExporterTransactor

+ TransactOpts bind.TransactOpts

v2.3.0

Nov 12, 2019

Changes in this version

type BurnerTokenFilterer

+ func (_BurnerToken *BurnerTokenFilterer) ParseApproval(log types.Log) (*BurnerTokenApproval, error)

+ func (_BurnerToken *BurnerTokenFilterer) ParseTransfer(log types.Log) (*BurnerTokenTransfer, error)

type NonCompliantTokenFilterer

+ func (_NonCompliantToken *NonCompliantTokenFilterer) ParseApproval(log types.Log) (*NonCompliantTokenApproval, error)

+ func (_NonCompliantToken *NonCompliantTokenFilterer) ParseTransfer(log types.Log) (*NonCompliantTokenTransfer, error)

type OraclizeConnectorCaller

+ func (_OraclizeConnector *OraclizeConnectorCaller) GetPrice0(opts *bind.CallOpts, _datasource string) (*big.Int, error)

type OraclizeConnectorCallerSession

+ func (_OraclizeConnector *OraclizeConnectorCallerSession) GetPrice0(_datasource string) (*big.Int, error)

type OraclizeConnectorSession

+ func (_OraclizeConnector *OraclizeConnectorSession) GetPrice0(_datasource string) (*big.Int, error)

type TokenFilterer

+ func (_Token *TokenFilterer) ParseApproval(log types.Log) (*TokenApproval, error)

+ func (_Token *TokenFilterer) ParseTransfer(log types.Log) (*TokenTransfer, error)

v2.2.1

Aug 15, 2019

v2.2.0

Aug 12, 2019

v2.1.0

Aug 12, 2019

Changes in this version

+ const Base64ExporterABI

+ const Base64ExporterBin

+ const BurnerTokenABI

+ const BurnerTokenBin

+ const BytesUtilsExporterABI

+ const BytesUtilsExporterBin

+ const NonCompliantTokenABI

+ const NonCompliantTokenBin

+ const OraclizeAddrResolverABI

+ const OraclizeAddrResolverBin

+ const OraclizeConnectorABI

+ const OraclizeConnectorBin

+ const ParseIntScientificExporterABI

+ const ParseIntScientificExporterBin

+ const TokenABI

+ const TokenBin

+ const TokenWhitelistableExporterABI

+ const TokenWhitelistableExporterBin

+ type Base64Exporter struct

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

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

+ type Base64ExporterCaller struct

+ func NewBase64ExporterCaller(address common.Address, caller bind.ContractCaller) (*Base64ExporterCaller, error)

+ func (_Base64Exporter *Base64ExporterCaller) Base64decode(opts *bind.CallOpts, _encoded []byte) ([]byte, error)

+ type Base64ExporterCallerRaw struct

+ Contract *Base64ExporterCaller

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

+ type Base64ExporterCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *Base64ExporterCaller

+ func (_Base64Exporter *Base64ExporterCallerSession) Base64decode(_encoded []byte) ([]byte, error)

+ type Base64ExporterFilterer struct

+ func NewBase64ExporterFilterer(address common.Address, filterer bind.ContractFilterer) (*Base64ExporterFilterer, error)

+ type Base64ExporterRaw struct

+ Contract *Base64Exporter

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

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

+ func (_Base64Exporter *Base64ExporterRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type Base64ExporterSession struct

+ CallOpts bind.CallOpts

+ Contract *Base64Exporter

+ TransactOpts bind.TransactOpts

+ func (_Base64Exporter *Base64ExporterSession) Base64decode(_encoded []byte) ([]byte, error)

+ type Base64ExporterTransactor struct

+ func NewBase64ExporterTransactor(address common.Address, transactor bind.ContractTransactor) (*Base64ExporterTransactor, error)

+ type Base64ExporterTransactorRaw struct

+ Contract *Base64ExporterTransactor

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

+ func (_Base64Exporter *Base64ExporterTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type Base64ExporterTransactorSession struct

+ Contract *Base64ExporterTransactor

+ TransactOpts bind.TransactOpts

+ type BurnerToken struct

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

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

+ type BurnerTokenApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type BurnerTokenApprovalIterator struct

+ Event *BurnerTokenApproval

+ func (it *BurnerTokenApprovalIterator) Close() error

+ func (it *BurnerTokenApprovalIterator) Error() error

+ func (it *BurnerTokenApprovalIterator) Next() bool

+ type BurnerTokenCaller struct

+ func NewBurnerTokenCaller(address common.Address, caller bind.ContractCaller) (*BurnerTokenCaller, error)

+ func (_BurnerToken *BurnerTokenCaller) Allowance(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_BurnerToken *BurnerTokenCaller) BalanceOf(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_BurnerToken *BurnerTokenCaller) CurrentSupply(opts *bind.CallOpts) (*big.Int, error)

+ func (_BurnerToken *BurnerTokenCaller) Decimals(opts *bind.CallOpts) (uint8, error)

+ func (_BurnerToken *BurnerTokenCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_BurnerToken *BurnerTokenCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_BurnerToken *BurnerTokenCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_BurnerToken *BurnerTokenCaller) Tokenholder(opts *bind.CallOpts) (common.Address, error)

+ func (_BurnerToken *BurnerTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type BurnerTokenCallerRaw struct

+ Contract *BurnerTokenCaller

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

+ type BurnerTokenCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *BurnerTokenCaller

+ func (_BurnerToken *BurnerTokenCallerSession) Allowance(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_BurnerToken *BurnerTokenCallerSession) BalanceOf(arg0 common.Address) (*big.Int, error)

+ func (_BurnerToken *BurnerTokenCallerSession) CurrentSupply() (*big.Int, error)

+ func (_BurnerToken *BurnerTokenCallerSession) Decimals() (uint8, error)

+ func (_BurnerToken *BurnerTokenCallerSession) Name() (string, error)

+ func (_BurnerToken *BurnerTokenCallerSession) Owner() (common.Address, error)

+ func (_BurnerToken *BurnerTokenCallerSession) Symbol() (string, error)

+ func (_BurnerToken *BurnerTokenCallerSession) Tokenholder() (common.Address, error)

+ func (_BurnerToken *BurnerTokenCallerSession) TotalSupply() (*big.Int, error)

+ type BurnerTokenFilterer struct

+ func NewBurnerTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*BurnerTokenFilterer, error)

+ func (_BurnerToken *BurnerTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*BurnerTokenApprovalIterator, error)

+ func (_BurnerToken *BurnerTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*BurnerTokenTransferIterator, error)

+ func (_BurnerToken *BurnerTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *BurnerTokenApproval, owner []common.Address, ...) (event.Subscription, error)

+ func (_BurnerToken *BurnerTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *BurnerTokenTransfer, from []common.Address, ...) (event.Subscription, error)

+ type BurnerTokenRaw struct

+ Contract *BurnerToken

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

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

+ func (_BurnerToken *BurnerTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BurnerTokenSession struct

+ CallOpts bind.CallOpts

+ Contract *BurnerToken

+ TransactOpts bind.TransactOpts

+ func (_BurnerToken *BurnerTokenSession) Allowance(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_BurnerToken *BurnerTokenSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_BurnerToken *BurnerTokenSession) BalanceOf(arg0 common.Address) (*big.Int, error)

+ func (_BurnerToken *BurnerTokenSession) Burn(_amount *big.Int) (*types.Transaction, error)

+ func (_BurnerToken *BurnerTokenSession) CurrentSupply() (*big.Int, error)

+ func (_BurnerToken *BurnerTokenSession) Decimals() (uint8, error)

+ func (_BurnerToken *BurnerTokenSession) DecreaseApproval(_spender common.Address, _subtractedValue *big.Int) (*types.Transaction, error)

+ func (_BurnerToken *BurnerTokenSession) IncreaseApproval(_spender common.Address, _addedValue *big.Int) (*types.Transaction, error)

+ func (_BurnerToken *BurnerTokenSession) Mint(addr common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_BurnerToken *BurnerTokenSession) Name() (string, error)

+ func (_BurnerToken *BurnerTokenSession) Owner() (common.Address, error)

+ func (_BurnerToken *BurnerTokenSession) SetTokenHolder(_th common.Address) (*types.Transaction, error)

+ func (_BurnerToken *BurnerTokenSession) Symbol() (string, error)

+ func (_BurnerToken *BurnerTokenSession) Tokenholder() (common.Address, error)

+ func (_BurnerToken *BurnerTokenSession) TotalSupply() (*big.Int, error)

+ func (_BurnerToken *BurnerTokenSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_BurnerToken *BurnerTokenSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error)

+ type BurnerTokenTransactor struct

+ func NewBurnerTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*BurnerTokenTransactor, error)

+ func (_BurnerToken *BurnerTokenTransactor) Approve(opts *bind.TransactOpts, _spender common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_BurnerToken *BurnerTokenTransactor) Burn(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error)

+ func (_BurnerToken *BurnerTokenTransactor) DecreaseApproval(opts *bind.TransactOpts, _spender common.Address, _subtractedValue *big.Int) (*types.Transaction, error)

+ func (_BurnerToken *BurnerTokenTransactor) IncreaseApproval(opts *bind.TransactOpts, _spender common.Address, _addedValue *big.Int) (*types.Transaction, error)

+ func (_BurnerToken *BurnerTokenTransactor) Mint(opts *bind.TransactOpts, addr common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_BurnerToken *BurnerTokenTransactor) SetTokenHolder(opts *bind.TransactOpts, _th common.Address) (*types.Transaction, error)

+ func (_BurnerToken *BurnerTokenTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_BurnerToken *BurnerTokenTransactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ type BurnerTokenTransactorRaw struct

+ Contract *BurnerTokenTransactor

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

+ func (_BurnerToken *BurnerTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BurnerTokenTransactorSession struct

+ Contract *BurnerTokenTransactor

+ TransactOpts bind.TransactOpts

+ func (_BurnerToken *BurnerTokenTransactorSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_BurnerToken *BurnerTokenTransactorSession) Burn(_amount *big.Int) (*types.Transaction, error)

+ func (_BurnerToken *BurnerTokenTransactorSession) DecreaseApproval(_spender common.Address, _subtractedValue *big.Int) (*types.Transaction, error)

+ func (_BurnerToken *BurnerTokenTransactorSession) IncreaseApproval(_spender common.Address, _addedValue *big.Int) (*types.Transaction, error)

+ func (_BurnerToken *BurnerTokenTransactorSession) Mint(addr common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_BurnerToken *BurnerTokenTransactorSession) SetTokenHolder(_th common.Address) (*types.Transaction, error)

+ func (_BurnerToken *BurnerTokenTransactorSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_BurnerToken *BurnerTokenTransactorSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error)

+ type BurnerTokenTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type BurnerTokenTransferIterator struct

+ Event *BurnerTokenTransfer

+ func (it *BurnerTokenTransferIterator) Close() error

+ func (it *BurnerTokenTransferIterator) Error() error

+ func (it *BurnerTokenTransferIterator) Next() bool

+ type BytesUtilsExporter struct

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

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

+ type BytesUtilsExporterCaller struct

+ func NewBytesUtilsExporterCaller(address common.Address, caller bind.ContractCaller) (*BytesUtilsExporterCaller, error)

+ func (_BytesUtilsExporter *BytesUtilsExporterCaller) BytesToAddress(opts *bind.CallOpts, _bts []byte, _from *big.Int) (common.Address, error)

+ func (_BytesUtilsExporter *BytesUtilsExporterCaller) BytesToBytes4(opts *bind.CallOpts, _bts []byte, _from *big.Int) ([4]byte, error)

+ func (_BytesUtilsExporter *BytesUtilsExporterCaller) BytesToUint256(opts *bind.CallOpts, _bts []byte, _from *big.Int) (*big.Int, error)

+ type BytesUtilsExporterCallerRaw struct

+ Contract *BytesUtilsExporterCaller

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

+ type BytesUtilsExporterCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *BytesUtilsExporterCaller

+ func (_BytesUtilsExporter *BytesUtilsExporterCallerSession) BytesToAddress(_bts []byte, _from *big.Int) (common.Address, error)

+ func (_BytesUtilsExporter *BytesUtilsExporterCallerSession) BytesToBytes4(_bts []byte, _from *big.Int) ([4]byte, error)

+ func (_BytesUtilsExporter *BytesUtilsExporterCallerSession) BytesToUint256(_bts []byte, _from *big.Int) (*big.Int, error)

+ type BytesUtilsExporterFilterer struct

+ func NewBytesUtilsExporterFilterer(address common.Address, filterer bind.ContractFilterer) (*BytesUtilsExporterFilterer, error)

+ type BytesUtilsExporterRaw struct

+ Contract *BytesUtilsExporter

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

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

+ func (_BytesUtilsExporter *BytesUtilsExporterRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BytesUtilsExporterSession struct

+ CallOpts bind.CallOpts

+ Contract *BytesUtilsExporter

+ TransactOpts bind.TransactOpts

+ func (_BytesUtilsExporter *BytesUtilsExporterSession) BytesToAddress(_bts []byte, _from *big.Int) (common.Address, error)

+ func (_BytesUtilsExporter *BytesUtilsExporterSession) BytesToBytes4(_bts []byte, _from *big.Int) ([4]byte, error)

+ func (_BytesUtilsExporter *BytesUtilsExporterSession) BytesToUint256(_bts []byte, _from *big.Int) (*big.Int, error)

+ type BytesUtilsExporterTransactor struct

+ func NewBytesUtilsExporterTransactor(address common.Address, transactor bind.ContractTransactor) (*BytesUtilsExporterTransactor, error)

+ type BytesUtilsExporterTransactorRaw struct

+ Contract *BytesUtilsExporterTransactor

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

+ func (_BytesUtilsExporter *BytesUtilsExporterTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BytesUtilsExporterTransactorSession struct

+ Contract *BytesUtilsExporterTransactor

+ TransactOpts bind.TransactOpts

+ type NonCompliantToken struct

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

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

+ type NonCompliantTokenApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type NonCompliantTokenApprovalIterator struct

+ Event *NonCompliantTokenApproval

+ func (it *NonCompliantTokenApprovalIterator) Close() error

+ func (it *NonCompliantTokenApprovalIterator) Error() error

+ func (it *NonCompliantTokenApprovalIterator) Next() bool

+ type NonCompliantTokenCaller struct

+ func NewNonCompliantTokenCaller(address common.Address, caller bind.ContractCaller) (*NonCompliantTokenCaller, error)

+ func (_NonCompliantToken *NonCompliantTokenCaller) Allowance(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_NonCompliantToken *NonCompliantTokenCaller) BalanceOf(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_NonCompliantToken *NonCompliantTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type NonCompliantTokenCallerRaw struct

+ Contract *NonCompliantTokenCaller

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

+ type NonCompliantTokenCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *NonCompliantTokenCaller

+ func (_NonCompliantToken *NonCompliantTokenCallerSession) Allowance(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_NonCompliantToken *NonCompliantTokenCallerSession) BalanceOf(arg0 common.Address) (*big.Int, error)

+ func (_NonCompliantToken *NonCompliantTokenCallerSession) TotalSupply() (*big.Int, error)

+ type NonCompliantTokenFilterer struct

+ func NewNonCompliantTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*NonCompliantTokenFilterer, error)

+ func (_NonCompliantToken *NonCompliantTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*NonCompliantTokenApprovalIterator, error)

+ func (_NonCompliantToken *NonCompliantTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*NonCompliantTokenTransferIterator, error)

+ func (_NonCompliantToken *NonCompliantTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *NonCompliantTokenApproval, ...) (event.Subscription, error)

+ func (_NonCompliantToken *NonCompliantTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *NonCompliantTokenTransfer, ...) (event.Subscription, error)

+ type NonCompliantTokenRaw struct

+ Contract *NonCompliantToken

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

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

+ func (_NonCompliantToken *NonCompliantTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type NonCompliantTokenSession struct

+ CallOpts bind.CallOpts

+ Contract *NonCompliantToken

+ TransactOpts bind.TransactOpts

+ func (_NonCompliantToken *NonCompliantTokenSession) Allowance(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_NonCompliantToken *NonCompliantTokenSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_NonCompliantToken *NonCompliantTokenSession) BalanceOf(arg0 common.Address) (*big.Int, error)

+ func (_NonCompliantToken *NonCompliantTokenSession) Credit(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_NonCompliantToken *NonCompliantTokenSession) Debit(from common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_NonCompliantToken *NonCompliantTokenSession) TotalSupply() (*big.Int, error)

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

+ func (_NonCompliantToken *NonCompliantTokenSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error)

+ type NonCompliantTokenTransactor struct

+ func NewNonCompliantTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*NonCompliantTokenTransactor, error)

+ func (_NonCompliantToken *NonCompliantTokenTransactor) Approve(opts *bind.TransactOpts, _spender common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_NonCompliantToken *NonCompliantTokenTransactor) Credit(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_NonCompliantToken *NonCompliantTokenTransactor) Debit(opts *bind.TransactOpts, from common.Address, amount *big.Int) (*types.Transaction, error)

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

+ func (_NonCompliantToken *NonCompliantTokenTransactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ type NonCompliantTokenTransactorRaw struct

+ Contract *NonCompliantTokenTransactor

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

+ func (_NonCompliantToken *NonCompliantTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type NonCompliantTokenTransactorSession struct

+ Contract *NonCompliantTokenTransactor

+ TransactOpts bind.TransactOpts

+ func (_NonCompliantToken *NonCompliantTokenTransactorSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_NonCompliantToken *NonCompliantTokenTransactorSession) Credit(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_NonCompliantToken *NonCompliantTokenTransactorSession) Debit(from common.Address, amount *big.Int) (*types.Transaction, error)

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

+ func (_NonCompliantToken *NonCompliantTokenTransactorSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error)

+ type NonCompliantTokenTransfer struct

+ Amount *big.Int

+ From common.Address

+ Raw types.Log

+ To common.Address

+ type NonCompliantTokenTransferIterator struct

+ Event *NonCompliantTokenTransfer

+ func (it *NonCompliantTokenTransferIterator) Close() error

+ func (it *NonCompliantTokenTransferIterator) Error() error

+ func (it *NonCompliantTokenTransferIterator) Next() bool

+ type OraclizeAddrResolver struct

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

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

+ type OraclizeAddrResolverCaller struct

+ func NewOraclizeAddrResolverCaller(address common.Address, caller bind.ContractCaller) (*OraclizeAddrResolverCaller, error)

+ func (_OraclizeAddrResolver *OraclizeAddrResolverCaller) GetAddress(opts *bind.CallOpts) (common.Address, error)

+ type OraclizeAddrResolverCallerRaw struct

+ Contract *OraclizeAddrResolverCaller

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

+ type OraclizeAddrResolverCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OraclizeAddrResolverCaller

+ func (_OraclizeAddrResolver *OraclizeAddrResolverCallerSession) GetAddress() (common.Address, error)

+ type OraclizeAddrResolverFilterer struct

+ func NewOraclizeAddrResolverFilterer(address common.Address, filterer bind.ContractFilterer) (*OraclizeAddrResolverFilterer, error)

+ type OraclizeAddrResolverRaw struct

+ Contract *OraclizeAddrResolver

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

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

+ func (_OraclizeAddrResolver *OraclizeAddrResolverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OraclizeAddrResolverSession struct

+ CallOpts bind.CallOpts

+ Contract *OraclizeAddrResolver

+ TransactOpts bind.TransactOpts

+ func (_OraclizeAddrResolver *OraclizeAddrResolverSession) GetAddress() (common.Address, error)

+ type OraclizeAddrResolverTransactor struct

+ func NewOraclizeAddrResolverTransactor(address common.Address, transactor bind.ContractTransactor) (*OraclizeAddrResolverTransactor, error)

+ type OraclizeAddrResolverTransactorRaw struct

+ Contract *OraclizeAddrResolverTransactor

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

+ func (_OraclizeAddrResolver *OraclizeAddrResolverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OraclizeAddrResolverTransactorSession struct

+ Contract *OraclizeAddrResolverTransactor

+ TransactOpts bind.TransactOpts

+ type OraclizeConnector struct

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

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

+ type OraclizeConnectorCaller struct

+ func NewOraclizeConnectorCaller(address common.Address, caller bind.ContractCaller) (*OraclizeConnectorCaller, error)

+ func (_OraclizeConnector *OraclizeConnectorCaller) CbAddress(opts *bind.CallOpts) (common.Address, error)

+ func (_OraclizeConnector *OraclizeConnectorCaller) GetPrice(opts *bind.CallOpts, _datasource string) (*big.Int, error)

+ func (_OraclizeConnector *OraclizeConnectorCaller) ProofType(opts *bind.CallOpts) ([1]byte, error)

+ type OraclizeConnectorCallerRaw struct

+ Contract *OraclizeConnectorCaller

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

+ type OraclizeConnectorCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OraclizeConnectorCaller

+ func (_OraclizeConnector *OraclizeConnectorCallerSession) CbAddress() (common.Address, error)

+ func (_OraclizeConnector *OraclizeConnectorCallerSession) GetPrice(_datasource string) (*big.Int, error)

+ func (_OraclizeConnector *OraclizeConnectorCallerSession) ProofType() ([1]byte, error)

+ type OraclizeConnectorFilterer struct

+ func NewOraclizeConnectorFilterer(address common.Address, filterer bind.ContractFilterer) (*OraclizeConnectorFilterer, error)

+ type OraclizeConnectorRaw struct

+ Contract *OraclizeConnector

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

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

+ func (_OraclizeConnector *OraclizeConnectorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OraclizeConnectorSession struct

+ CallOpts bind.CallOpts

+ Contract *OraclizeConnector

+ TransactOpts bind.TransactOpts

+ func (_OraclizeConnector *OraclizeConnectorSession) CbAddress() (common.Address, error)

+ func (_OraclizeConnector *OraclizeConnectorSession) GetPrice(_datasource string) (*big.Int, error)

+ func (_OraclizeConnector *OraclizeConnectorSession) ProofType() ([1]byte, error)

+ func (_OraclizeConnector *OraclizeConnectorSession) Query(_timestamp *big.Int, _datasource string, _arg string) (*types.Transaction, error)

+ func (_OraclizeConnector *OraclizeConnectorSession) QueryWithGasLimit(_timestamp *big.Int, _datasource string, _arg string, _gaslimit *big.Int) (*types.Transaction, error)

+ func (_OraclizeConnector *OraclizeConnectorSession) SetCustomGasPrice(_gasPrice *big.Int) (*types.Transaction, error)

+ func (_OraclizeConnector *OraclizeConnectorSession) SetProofType(_proofType [1]byte) (*types.Transaction, error)

+ type OraclizeConnectorTransactor struct

+ func NewOraclizeConnectorTransactor(address common.Address, transactor bind.ContractTransactor) (*OraclizeConnectorTransactor, error)

+ func (_OraclizeConnector *OraclizeConnectorTransactor) Query(opts *bind.TransactOpts, _timestamp *big.Int, _datasource string, _arg string) (*types.Transaction, error)

+ func (_OraclizeConnector *OraclizeConnectorTransactor) QueryWithGasLimit(opts *bind.TransactOpts, _timestamp *big.Int, _datasource string, _arg string, ...) (*types.Transaction, error)

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

+ func (_OraclizeConnector *OraclizeConnectorTransactor) SetProofType(opts *bind.TransactOpts, _proofType [1]byte) (*types.Transaction, error)

+ type OraclizeConnectorTransactorRaw struct

+ Contract *OraclizeConnectorTransactor

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

+ func (_OraclizeConnector *OraclizeConnectorTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OraclizeConnectorTransactorSession struct

+ Contract *OraclizeConnectorTransactor

+ TransactOpts bind.TransactOpts

+ func (_OraclizeConnector *OraclizeConnectorTransactorSession) Query(_timestamp *big.Int, _datasource string, _arg string) (*types.Transaction, error)

+ func (_OraclizeConnector *OraclizeConnectorTransactorSession) QueryWithGasLimit(_timestamp *big.Int, _datasource string, _arg string, _gaslimit *big.Int) (*types.Transaction, error)

+ func (_OraclizeConnector *OraclizeConnectorTransactorSession) SetCustomGasPrice(_gasPrice *big.Int) (*types.Transaction, error)

+ func (_OraclizeConnector *OraclizeConnectorTransactorSession) SetProofType(_proofType [1]byte) (*types.Transaction, error)

+ type ParseIntScientificExporter struct

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

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

+ type ParseIntScientificExporterCaller struct

+ func NewParseIntScientificExporterCaller(address common.Address, caller bind.ContractCaller) (*ParseIntScientificExporterCaller, error)

+ func (_ParseIntScientificExporter *ParseIntScientificExporterCaller) ParseIntScientific(opts *bind.CallOpts, _a string) (*big.Int, error)

+ func (_ParseIntScientificExporter *ParseIntScientificExporterCaller) ParseIntScientificDecimals(opts *bind.CallOpts, _a string, _b *big.Int) (*big.Int, error)

+ func (_ParseIntScientificExporter *ParseIntScientificExporterCaller) ParseIntScientificWei(opts *bind.CallOpts, _a string) (*big.Int, error)

+ type ParseIntScientificExporterCallerRaw struct

+ Contract *ParseIntScientificExporterCaller

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

+ type ParseIntScientificExporterCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ParseIntScientificExporterCaller

+ func (_ParseIntScientificExporter *ParseIntScientificExporterCallerSession) ParseIntScientific(_a string) (*big.Int, error)

+ func (_ParseIntScientificExporter *ParseIntScientificExporterCallerSession) ParseIntScientificDecimals(_a string, _b *big.Int) (*big.Int, error)

+ func (_ParseIntScientificExporter *ParseIntScientificExporterCallerSession) ParseIntScientificWei(_a string) (*big.Int, error)

+ type ParseIntScientificExporterFilterer struct

+ func NewParseIntScientificExporterFilterer(address common.Address, filterer bind.ContractFilterer) (*ParseIntScientificExporterFilterer, error)

+ type ParseIntScientificExporterRaw struct

+ Contract *ParseIntScientificExporter

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

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

+ func (_ParseIntScientificExporter *ParseIntScientificExporterRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ParseIntScientificExporterSession struct

+ CallOpts bind.CallOpts

+ Contract *ParseIntScientificExporter

+ TransactOpts bind.TransactOpts

+ func (_ParseIntScientificExporter *ParseIntScientificExporterSession) ParseIntScientific(_a string) (*big.Int, error)

+ func (_ParseIntScientificExporter *ParseIntScientificExporterSession) ParseIntScientificDecimals(_a string, _b *big.Int) (*big.Int, error)

+ func (_ParseIntScientificExporter *ParseIntScientificExporterSession) ParseIntScientificWei(_a string) (*big.Int, error)

+ type ParseIntScientificExporterTransactor struct

+ func NewParseIntScientificExporterTransactor(address common.Address, transactor bind.ContractTransactor) (*ParseIntScientificExporterTransactor, error)

+ type ParseIntScientificExporterTransactorRaw struct

+ Contract *ParseIntScientificExporterTransactor

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

+ func (_ParseIntScientificExporter *ParseIntScientificExporterTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ParseIntScientificExporterTransactorSession struct

+ Contract *ParseIntScientificExporterTransactor

+ TransactOpts bind.TransactOpts

+ type Token struct

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

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

+ type TokenApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type TokenApprovalIterator struct

+ Event *TokenApproval

+ func (it *TokenApprovalIterator) Close() error

+ func (it *TokenApprovalIterator) Error() error

+ func (it *TokenApprovalIterator) Next() bool

+ type TokenCaller struct

+ func NewTokenCaller(address common.Address, caller bind.ContractCaller) (*TokenCaller, error)

+ func (_Token *TokenCaller) Allowance(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_Token *TokenCaller) BalanceOf(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_Token *TokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type TokenCallerRaw struct

+ Contract *TokenCaller

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

+ type TokenCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *TokenCaller

+ func (_Token *TokenCallerSession) Allowance(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_Token *TokenCallerSession) BalanceOf(arg0 common.Address) (*big.Int, error)

+ func (_Token *TokenCallerSession) TotalSupply() (*big.Int, error)

+ type TokenFilterer struct

+ func NewTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*TokenFilterer, error)

+ func (_Token *TokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*TokenApprovalIterator, error)

+ func (_Token *TokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*TokenTransferIterator, error)

+ func (_Token *TokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *TokenApproval, owner []common.Address, ...) (event.Subscription, error)

+ func (_Token *TokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *TokenTransfer, from []common.Address, ...) (event.Subscription, error)

+ type TokenRaw struct

+ Contract *Token

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

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

+ func (_Token *TokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type TokenSession struct

+ CallOpts bind.CallOpts

+ Contract *Token

+ TransactOpts bind.TransactOpts

+ func (_Token *TokenSession) Allowance(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_Token *TokenSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_Token *TokenSession) BalanceOf(arg0 common.Address) (*big.Int, error)

+ func (_Token *TokenSession) Credit(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_Token *TokenSession) Debit(from common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_Token *TokenSession) TotalSupply() (*big.Int, error)

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

+ func (_Token *TokenSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error)

+ type TokenTransactor struct

+ func NewTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*TokenTransactor, error)

+ func (_Token *TokenTransactor) Approve(opts *bind.TransactOpts, _spender common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_Token *TokenTransactor) Credit(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_Token *TokenTransactor) Debit(opts *bind.TransactOpts, from common.Address, amount *big.Int) (*types.Transaction, error)

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

+ func (_Token *TokenTransactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ type TokenTransactorRaw struct

+ Contract *TokenTransactor

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

+ func (_Token *TokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type TokenTransactorSession struct

+ Contract *TokenTransactor

+ TransactOpts bind.TransactOpts

+ func (_Token *TokenTransactorSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_Token *TokenTransactorSession) Credit(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_Token *TokenTransactorSession) Debit(from common.Address, amount *big.Int) (*types.Transaction, error)

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

+ func (_Token *TokenTransactorSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error)

+ type TokenTransfer struct

+ Amount *big.Int

+ From common.Address

+ Raw types.Log

+ To common.Address

+ type TokenTransferIterator struct

+ Event *TokenTransfer

+ func (it *TokenTransferIterator) Close() error

+ func (it *TokenTransferIterator) Error() error

+ func (it *TokenTransferIterator) Next() bool

+ type TokenWhitelistableExporter struct

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

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

+ type TokenWhitelistableExporterCaller struct

+ func NewTokenWhitelistableExporterCaller(address common.Address, caller bind.ContractCaller) (*TokenWhitelistableExporterCaller, error)

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterCaller) EnsRegistry(opts *bind.CallOpts) (common.Address, error)

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterCaller) GetERC20RecipientAndAmount(opts *bind.CallOpts, _destination common.Address, _data []byte) (common.Address, *big.Int, error)

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

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

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterCaller) IsTokenAvailable(opts *bind.CallOpts, _a common.Address) (bool, error)

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterCaller) IsTokenLoadable(opts *bind.CallOpts, _a common.Address) (bool, error)

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterCaller) IsTokenRedeemable(opts *bind.CallOpts, _a common.Address) (bool, error)

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

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

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

+ type TokenWhitelistableExporterCallerRaw struct

+ Contract *TokenWhitelistableExporterCaller

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

+ type TokenWhitelistableExporterCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *TokenWhitelistableExporterCaller

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterCallerSession) EnsRegistry() (common.Address, error)

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterCallerSession) GetERC20RecipientAndAmount(_destination common.Address, _data []byte) (common.Address, *big.Int, error)

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterCallerSession) GetStablecoinInfo() (string, *big.Int, *big.Int, bool, bool, bool, *big.Int, error)

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

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterCallerSession) IsTokenAvailable(_a common.Address) (bool, error)

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterCallerSession) IsTokenLoadable(_a common.Address) (bool, error)

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterCallerSession) IsTokenRedeemable(_a common.Address) (bool, error)

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterCallerSession) RedeemableTokens() ([]common.Address, error)

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterCallerSession) TokenAddressArray() ([]common.Address, error)

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterCallerSession) TokenWhitelistNode() ([32]byte, error)

+ type TokenWhitelistableExporterFilterer struct

+ func NewTokenWhitelistableExporterFilterer(address common.Address, filterer bind.ContractFilterer) (*TokenWhitelistableExporterFilterer, error)

+ type TokenWhitelistableExporterRaw struct

+ Contract *TokenWhitelistableExporter

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

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

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type TokenWhitelistableExporterSession struct

+ CallOpts bind.CallOpts

+ Contract *TokenWhitelistableExporter

+ TransactOpts bind.TransactOpts

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterSession) EnsRegistry() (common.Address, error)

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterSession) GetERC20RecipientAndAmount(_destination common.Address, _data []byte) (common.Address, *big.Int, error)

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterSession) GetStablecoinInfo() (string, *big.Int, *big.Int, bool, bool, bool, *big.Int, error)

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

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterSession) IsTokenAvailable(_a common.Address) (bool, error)

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterSession) IsTokenLoadable(_a common.Address) (bool, error)

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterSession) IsTokenRedeemable(_a common.Address) (bool, error)

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterSession) RedeemableTokens() ([]common.Address, error)

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterSession) TokenAddressArray() ([]common.Address, error)

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterSession) TokenWhitelistNode() ([32]byte, error)

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

+ type TokenWhitelistableExporterTransactor struct

+ func NewTokenWhitelistableExporterTransactor(address common.Address, transactor bind.ContractTransactor) (*TokenWhitelistableExporterTransactor, error)

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

+ type TokenWhitelistableExporterTransactorRaw struct

+ Contract *TokenWhitelistableExporterTransactor

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

+ func (_TokenWhitelistableExporter *TokenWhitelistableExporterTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type TokenWhitelistableExporterTransactorSession struct

+ Contract *TokenWhitelistableExporterTransactor

+ TransactOpts bind.TransactOpts

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

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