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

contracts

package

Go to main page

Versions in this module

v1

v1.1.0

May 27, 2018

v1.0.2

May 17, 2018

v1.0.1

May 12, 2018

v1.0.0

May 2, 2018

Changes in this version

+ const ERC20ABI

+ const ERC20Bin

+ const ExchangeABI

+ const ExchangeBin

+ const VaultABI

+ const VaultBin

+ const VaultInterfaceABI

+ const VaultInterfaceBin

+ type ERC20 struct

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

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

+ type ERC20Caller struct

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

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

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

+ func (_ERC20 *ERC20Caller) Decimals(opts *bind.CallOpts) (uint8, error)

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

+ type ERC20CallerRaw struct

+ Contract *ERC20Caller

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

+ type ERC20CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC20Caller

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

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

+ func (_ERC20 *ERC20CallerSession) Decimals() (uint8, error)

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

+ type ERC20Filterer struct

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

+ type ERC20Raw struct

+ Contract *ERC20

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

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

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

+ type ERC20Session struct

+ CallOpts bind.CallOpts

+ Contract *ERC20

+ TransactOpts bind.TransactOpts

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

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

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

+ func (_ERC20 *ERC20Session) Decimals() (uint8, error)

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

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

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

+ type ERC20Transactor struct

+ func NewERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*ERC20Transactor, error)

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

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

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

+ type ERC20TransactorRaw struct

+ Contract *ERC20Transactor

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

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

+ type ERC20TransactorSession struct

+ Contract *ERC20Transactor

+ TransactOpts bind.TransactOpts

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

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

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

+ type Exchange struct

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

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

+ type ExchangeCaller struct

+ func NewExchangeCaller(address common.Address, caller bind.ContractCaller) (*ExchangeCaller, error)

+ func (_Exchange *ExchangeCaller) AvailableAmount(opts *bind.CallOpts, addresses [3]common.Address, values [4]*big.Int) (*big.Int, error)

+ func (_Exchange *ExchangeCaller) CanTrade(opts *bind.CallOpts, addresses [3]common.Address, values [4]*big.Int, ...) (bool, error)

+ func (_Exchange *ExchangeCaller) Filled(opts *bind.CallOpts, hash [32]byte) (*big.Int, error)

+ func (_Exchange *ExchangeCaller) IsOrdered(opts *bind.CallOpts, user common.Address, hash [32]byte) (bool, error)

+ func (_Exchange *ExchangeCaller) Vault(opts *bind.CallOpts) (common.Address, error)

+ type ExchangeCallerRaw struct

+ Contract *ExchangeCaller

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

+ type ExchangeCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ExchangeCaller

+ func (_Exchange *ExchangeCallerSession) AvailableAmount(addresses [3]common.Address, values [4]*big.Int) (*big.Int, error)

+ func (_Exchange *ExchangeCallerSession) CanTrade(addresses [3]common.Address, values [4]*big.Int, signature []byte) (bool, error)

+ func (_Exchange *ExchangeCallerSession) Filled(hash [32]byte) (*big.Int, error)

+ func (_Exchange *ExchangeCallerSession) IsOrdered(user common.Address, hash [32]byte) (bool, error)

+ func (_Exchange *ExchangeCallerSession) Vault() (common.Address, error)

+ type ExchangeCancelled struct

+ Hash [32]byte

+ Raw types.Log

+ type ExchangeCancelledIterator struct

+ Event *ExchangeCancelled

+ func (it *ExchangeCancelledIterator) Close() error

+ func (it *ExchangeCancelledIterator) Error() error

+ func (it *ExchangeCancelledIterator) Next() bool

+ type ExchangeFilterer struct

+ func NewExchangeFilterer(address common.Address, filterer bind.ContractFilterer) (*ExchangeFilterer, error)

+ func (_Exchange *ExchangeFilterer) FilterCancelled(opts *bind.FilterOpts, hash [][32]byte) (*ExchangeCancelledIterator, error)

+ func (_Exchange *ExchangeFilterer) FilterOrdered(opts *bind.FilterOpts) (*ExchangeOrderedIterator, error)

+ func (_Exchange *ExchangeFilterer) FilterTraded(opts *bind.FilterOpts, hash [][32]byte) (*ExchangeTradedIterator, error)

+ func (_Exchange *ExchangeFilterer) WatchCancelled(opts *bind.WatchOpts, sink chan<- *ExchangeCancelled, hash [][32]byte) (event.Subscription, error)

+ func (_Exchange *ExchangeFilterer) WatchOrdered(opts *bind.WatchOpts, sink chan<- *ExchangeOrdered) (event.Subscription, error)

+ func (_Exchange *ExchangeFilterer) WatchTraded(opts *bind.WatchOpts, sink chan<- *ExchangeTraded, hash [][32]byte) (event.Subscription, error)

+ type ExchangeOrdered struct

+ Expires *big.Int

+ Maker common.Address

+ MakerToken common.Address

+ MakerTokenAmount *big.Int

+ Nonce *big.Int

+ Raw types.Log

+ TakerToken common.Address

+ TakerTokenAmount *big.Int

+ type ExchangeOrderedIterator struct

+ Event *ExchangeOrdered

+ func (it *ExchangeOrderedIterator) Close() error

+ func (it *ExchangeOrderedIterator) Error() error

+ func (it *ExchangeOrderedIterator) Next() bool

+ type ExchangeRaw struct

+ Contract *Exchange

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

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

+ func (_Exchange *ExchangeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ExchangeSession struct

+ CallOpts bind.CallOpts

+ Contract *Exchange

+ TransactOpts bind.TransactOpts

+ func (_Exchange *ExchangeSession) AvailableAmount(addresses [3]common.Address, values [4]*big.Int) (*big.Int, error)

+ func (_Exchange *ExchangeSession) CanTrade(addresses [3]common.Address, values [4]*big.Int, signature []byte) (bool, error)

+ func (_Exchange *ExchangeSession) Cancel(addresses [3]common.Address, values [4]*big.Int) (*types.Transaction, error)

+ func (_Exchange *ExchangeSession) Filled(hash [32]byte) (*big.Int, error)

+ func (_Exchange *ExchangeSession) IsOrdered(user common.Address, hash [32]byte) (bool, error)

+ func (_Exchange *ExchangeSession) Order(addresses [2]common.Address, values [4]*big.Int) (*types.Transaction, error)

+ func (_Exchange *ExchangeSession) Trade(addresses [3]common.Address, values [4]*big.Int, signature []byte, ...) (*types.Transaction, error)

+ func (_Exchange *ExchangeSession) Vault() (common.Address, error)

+ type ExchangeTraded struct

+ Hash [32]byte

+ Maker common.Address

+ MakerToken common.Address

+ MakerTokenAmount *big.Int

+ Raw types.Log

+ Taker common.Address

+ TakerToken common.Address

+ TakerTokenAmount *big.Int

+ type ExchangeTradedIterator struct

+ Event *ExchangeTraded

+ func (it *ExchangeTradedIterator) Close() error

+ func (it *ExchangeTradedIterator) Error() error

+ func (it *ExchangeTradedIterator) Next() bool

+ type ExchangeTransactor struct

+ func NewExchangeTransactor(address common.Address, transactor bind.ContractTransactor) (*ExchangeTransactor, error)

+ func (_Exchange *ExchangeTransactor) Cancel(opts *bind.TransactOpts, addresses [3]common.Address, values [4]*big.Int) (*types.Transaction, error)

+ func (_Exchange *ExchangeTransactor) Order(opts *bind.TransactOpts, addresses [2]common.Address, values [4]*big.Int) (*types.Transaction, error)

+ func (_Exchange *ExchangeTransactor) Trade(opts *bind.TransactOpts, addresses [3]common.Address, values [4]*big.Int, ...) (*types.Transaction, error)

+ type ExchangeTransactorRaw struct

+ Contract *ExchangeTransactor

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

+ func (_Exchange *ExchangeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ExchangeTransactorSession struct

+ Contract *ExchangeTransactor

+ TransactOpts bind.TransactOpts

+ func (_Exchange *ExchangeTransactorSession) Cancel(addresses [3]common.Address, values [4]*big.Int) (*types.Transaction, error)

+ func (_Exchange *ExchangeTransactorSession) Order(addresses [2]common.Address, values [4]*big.Int) (*types.Transaction, error)

+ func (_Exchange *ExchangeTransactorSession) Trade(addresses [3]common.Address, values [4]*big.Int, signature []byte, ...) (*types.Transaction, error)

+ type Vault struct

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

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

+ type VaultAddedSpender struct

+ Raw types.Log

+ Spender common.Address

+ type VaultAddedSpenderIterator struct

+ Event *VaultAddedSpender

+ func (it *VaultAddedSpenderIterator) Close() error

+ func (it *VaultAddedSpenderIterator) Error() error

+ func (it *VaultAddedSpenderIterator) Next() bool

+ type VaultApproved struct

+ Raw types.Log

+ Spender common.Address

+ User common.Address

+ type VaultApprovedIterator struct

+ Event *VaultApproved

+ func (it *VaultApprovedIterator) Close() error

+ func (it *VaultApprovedIterator) Error() error

+ func (it *VaultApprovedIterator) Next() bool

+ type VaultCaller struct

+ func NewVaultCaller(address common.Address, caller bind.ContractCaller) (*VaultCaller, error)

+ func (_Vault *VaultCaller) BalanceOf(opts *bind.CallOpts, token common.Address, user common.Address) (*big.Int, error)

+ func (_Vault *VaultCaller) IsApproved(opts *bind.CallOpts, user common.Address, spender common.Address) (bool, error)

+ func (_Vault *VaultCaller) IsSpender(opts *bind.CallOpts, spender common.Address) (bool, error)

+ func (_Vault *VaultCaller) LatestSpender(opts *bind.CallOpts) (common.Address, error)

+ type VaultCallerRaw struct

+ Contract *VaultCaller

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

+ type VaultCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *VaultCaller

+ func (_Vault *VaultCallerSession) BalanceOf(token common.Address, user common.Address) (*big.Int, error)

+ func (_Vault *VaultCallerSession) IsApproved(user common.Address, spender common.Address) (bool, error)

+ func (_Vault *VaultCallerSession) IsSpender(spender common.Address) (bool, error)

+ func (_Vault *VaultCallerSession) LatestSpender() (common.Address, error)

+ type VaultDeposited struct

+ Amount *big.Int

+ Raw types.Log

+ Token common.Address

+ User common.Address

+ type VaultDepositedIterator struct

+ Event *VaultDeposited

+ func (it *VaultDepositedIterator) Close() error

+ func (it *VaultDepositedIterator) Error() error

+ func (it *VaultDepositedIterator) Next() bool

+ type VaultFilterer struct

+ func NewVaultFilterer(address common.Address, filterer bind.ContractFilterer) (*VaultFilterer, error)

+ func (_Vault *VaultFilterer) FilterAddedSpender(opts *bind.FilterOpts, spender []common.Address) (*VaultAddedSpenderIterator, error)

+ func (_Vault *VaultFilterer) FilterApproved(opts *bind.FilterOpts, user []common.Address, spender []common.Address) (*VaultApprovedIterator, error)

+ func (_Vault *VaultFilterer) FilterDeposited(opts *bind.FilterOpts, user []common.Address) (*VaultDepositedIterator, error)

+ func (_Vault *VaultFilterer) FilterRemovedSpender(opts *bind.FilterOpts, spender []common.Address) (*VaultRemovedSpenderIterator, error)

+ func (_Vault *VaultFilterer) FilterUnapproved(opts *bind.FilterOpts, user []common.Address, spender []common.Address) (*VaultUnapprovedIterator, error)

+ func (_Vault *VaultFilterer) FilterWithdrawn(opts *bind.FilterOpts, user []common.Address) (*VaultWithdrawnIterator, error)

+ func (_Vault *VaultFilterer) WatchAddedSpender(opts *bind.WatchOpts, sink chan<- *VaultAddedSpender, spender []common.Address) (event.Subscription, error)

+ func (_Vault *VaultFilterer) WatchApproved(opts *bind.WatchOpts, sink chan<- *VaultApproved, user []common.Address, ...) (event.Subscription, error)

+ func (_Vault *VaultFilterer) WatchDeposited(opts *bind.WatchOpts, sink chan<- *VaultDeposited, user []common.Address) (event.Subscription, error)

+ func (_Vault *VaultFilterer) WatchRemovedSpender(opts *bind.WatchOpts, sink chan<- *VaultRemovedSpender, ...) (event.Subscription, error)

+ func (_Vault *VaultFilterer) WatchUnapproved(opts *bind.WatchOpts, sink chan<- *VaultUnapproved, user []common.Address, ...) (event.Subscription, error)

+ func (_Vault *VaultFilterer) WatchWithdrawn(opts *bind.WatchOpts, sink chan<- *VaultWithdrawn, user []common.Address) (event.Subscription, error)

+ type VaultInterface struct

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

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

+ type VaultInterfaceAddedSpender struct

+ Raw types.Log

+ Spender common.Address

+ type VaultInterfaceAddedSpenderIterator struct

+ Event *VaultInterfaceAddedSpender

+ func (it *VaultInterfaceAddedSpenderIterator) Close() error

+ func (it *VaultInterfaceAddedSpenderIterator) Error() error

+ func (it *VaultInterfaceAddedSpenderIterator) Next() bool

+ type VaultInterfaceApproved struct

+ Raw types.Log

+ Spender common.Address

+ User common.Address

+ type VaultInterfaceApprovedIterator struct

+ Event *VaultInterfaceApproved

+ func (it *VaultInterfaceApprovedIterator) Close() error

+ func (it *VaultInterfaceApprovedIterator) Error() error

+ func (it *VaultInterfaceApprovedIterator) Next() bool

+ type VaultInterfaceCaller struct

+ func NewVaultInterfaceCaller(address common.Address, caller bind.ContractCaller) (*VaultInterfaceCaller, error)

+ func (_VaultInterface *VaultInterfaceCaller) BalanceOf(opts *bind.CallOpts, token common.Address, user common.Address) (*big.Int, error)

+ func (_VaultInterface *VaultInterfaceCaller) IsApproved(opts *bind.CallOpts, user common.Address, spender common.Address) (bool, error)

+ func (_VaultInterface *VaultInterfaceCaller) IsSpender(opts *bind.CallOpts, spender common.Address) (bool, error)

+ func (_VaultInterface *VaultInterfaceCaller) LatestSpender(opts *bind.CallOpts) (common.Address, error)

+ type VaultInterfaceCallerRaw struct

+ Contract *VaultInterfaceCaller

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

+ type VaultInterfaceCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *VaultInterfaceCaller

+ func (_VaultInterface *VaultInterfaceCallerSession) BalanceOf(token common.Address, user common.Address) (*big.Int, error)

+ func (_VaultInterface *VaultInterfaceCallerSession) IsApproved(user common.Address, spender common.Address) (bool, error)

+ func (_VaultInterface *VaultInterfaceCallerSession) IsSpender(spender common.Address) (bool, error)

+ func (_VaultInterface *VaultInterfaceCallerSession) LatestSpender() (common.Address, error)

+ type VaultInterfaceDeposited struct

+ Amount *big.Int

+ Raw types.Log

+ Token common.Address

+ User common.Address

+ type VaultInterfaceDepositedIterator struct

+ Event *VaultInterfaceDeposited

+ func (it *VaultInterfaceDepositedIterator) Close() error

+ func (it *VaultInterfaceDepositedIterator) Error() error

+ func (it *VaultInterfaceDepositedIterator) Next() bool

+ type VaultInterfaceFilterer struct

+ func NewVaultInterfaceFilterer(address common.Address, filterer bind.ContractFilterer) (*VaultInterfaceFilterer, error)

+ func (_VaultInterface *VaultInterfaceFilterer) FilterAddedSpender(opts *bind.FilterOpts, spender []common.Address) (*VaultInterfaceAddedSpenderIterator, error)

+ func (_VaultInterface *VaultInterfaceFilterer) FilterApproved(opts *bind.FilterOpts, user []common.Address, spender []common.Address) (*VaultInterfaceApprovedIterator, error)

+ func (_VaultInterface *VaultInterfaceFilterer) FilterDeposited(opts *bind.FilterOpts, user []common.Address) (*VaultInterfaceDepositedIterator, error)

+ func (_VaultInterface *VaultInterfaceFilterer) FilterRemovedSpender(opts *bind.FilterOpts, spender []common.Address) (*VaultInterfaceRemovedSpenderIterator, error)

+ func (_VaultInterface *VaultInterfaceFilterer) FilterUnapproved(opts *bind.FilterOpts, user []common.Address, spender []common.Address) (*VaultInterfaceUnapprovedIterator, error)

+ func (_VaultInterface *VaultInterfaceFilterer) FilterWithdrawn(opts *bind.FilterOpts, user []common.Address) (*VaultInterfaceWithdrawnIterator, error)

+ func (_VaultInterface *VaultInterfaceFilterer) WatchAddedSpender(opts *bind.WatchOpts, sink chan<- *VaultInterfaceAddedSpender, ...) (event.Subscription, error)

+ func (_VaultInterface *VaultInterfaceFilterer) WatchApproved(opts *bind.WatchOpts, sink chan<- *VaultInterfaceApproved, ...) (event.Subscription, error)

+ func (_VaultInterface *VaultInterfaceFilterer) WatchDeposited(opts *bind.WatchOpts, sink chan<- *VaultInterfaceDeposited, ...) (event.Subscription, error)

+ func (_VaultInterface *VaultInterfaceFilterer) WatchRemovedSpender(opts *bind.WatchOpts, sink chan<- *VaultInterfaceRemovedSpender, ...) (event.Subscription, error)

+ func (_VaultInterface *VaultInterfaceFilterer) WatchUnapproved(opts *bind.WatchOpts, sink chan<- *VaultInterfaceUnapproved, ...) (event.Subscription, error)

+ func (_VaultInterface *VaultInterfaceFilterer) WatchWithdrawn(opts *bind.WatchOpts, sink chan<- *VaultInterfaceWithdrawn, ...) (event.Subscription, error)

+ type VaultInterfaceRaw struct

+ Contract *VaultInterface

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

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

+ func (_VaultInterface *VaultInterfaceRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type VaultInterfaceRemovedSpender struct

+ Raw types.Log

+ Spender common.Address

+ type VaultInterfaceRemovedSpenderIterator struct

+ Event *VaultInterfaceRemovedSpender

+ func (it *VaultInterfaceRemovedSpenderIterator) Close() error

+ func (it *VaultInterfaceRemovedSpenderIterator) Error() error

+ func (it *VaultInterfaceRemovedSpenderIterator) Next() bool

+ type VaultInterfaceSession struct

+ CallOpts bind.CallOpts

+ Contract *VaultInterface

+ TransactOpts bind.TransactOpts

+ func (_VaultInterface *VaultInterfaceSession) AddSpender(spender common.Address) (*types.Transaction, error)

+ func (_VaultInterface *VaultInterfaceSession) Approve(spender common.Address) (*types.Transaction, error)

+ func (_VaultInterface *VaultInterfaceSession) BalanceOf(token common.Address, user common.Address) (*big.Int, error)

+ func (_VaultInterface *VaultInterfaceSession) Deposit(token common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_VaultInterface *VaultInterfaceSession) IsApproved(user common.Address, spender common.Address) (bool, error)

+ func (_VaultInterface *VaultInterfaceSession) IsSpender(spender common.Address) (bool, error)

+ func (_VaultInterface *VaultInterfaceSession) LatestSpender() (common.Address, error)

+ func (_VaultInterface *VaultInterfaceSession) RemoveSpender(spender common.Address) (*types.Transaction, error)

+ func (_VaultInterface *VaultInterfaceSession) TokenFallback(from common.Address, value *big.Int, data []byte) (*types.Transaction, error)

+ func (_VaultInterface *VaultInterfaceSession) Transfer(token common.Address, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_VaultInterface *VaultInterfaceSession) Unapprove(spender common.Address) (*types.Transaction, error)

+ func (_VaultInterface *VaultInterfaceSession) Withdraw(token common.Address, amount *big.Int) (*types.Transaction, error)

+ type VaultInterfaceTransactor struct

+ func NewVaultInterfaceTransactor(address common.Address, transactor bind.ContractTransactor) (*VaultInterfaceTransactor, error)

+ func (_VaultInterface *VaultInterfaceTransactor) AddSpender(opts *bind.TransactOpts, spender common.Address) (*types.Transaction, error)

+ func (_VaultInterface *VaultInterfaceTransactor) Approve(opts *bind.TransactOpts, spender common.Address) (*types.Transaction, error)

+ func (_VaultInterface *VaultInterfaceTransactor) Deposit(opts *bind.TransactOpts, token common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_VaultInterface *VaultInterfaceTransactor) RemoveSpender(opts *bind.TransactOpts, spender common.Address) (*types.Transaction, error)

+ func (_VaultInterface *VaultInterfaceTransactor) TokenFallback(opts *bind.TransactOpts, from common.Address, value *big.Int, data []byte) (*types.Transaction, error)

+ func (_VaultInterface *VaultInterfaceTransactor) Transfer(opts *bind.TransactOpts, token common.Address, from common.Address, ...) (*types.Transaction, error)

+ func (_VaultInterface *VaultInterfaceTransactor) Unapprove(opts *bind.TransactOpts, spender common.Address) (*types.Transaction, error)

+ func (_VaultInterface *VaultInterfaceTransactor) Withdraw(opts *bind.TransactOpts, token common.Address, amount *big.Int) (*types.Transaction, error)

+ type VaultInterfaceTransactorRaw struct

+ Contract *VaultInterfaceTransactor

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

+ func (_VaultInterface *VaultInterfaceTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type VaultInterfaceTransactorSession struct

+ Contract *VaultInterfaceTransactor

+ TransactOpts bind.TransactOpts

+ func (_VaultInterface *VaultInterfaceTransactorSession) AddSpender(spender common.Address) (*types.Transaction, error)

+ func (_VaultInterface *VaultInterfaceTransactorSession) Approve(spender common.Address) (*types.Transaction, error)

+ func (_VaultInterface *VaultInterfaceTransactorSession) Deposit(token common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_VaultInterface *VaultInterfaceTransactorSession) RemoveSpender(spender common.Address) (*types.Transaction, error)

+ func (_VaultInterface *VaultInterfaceTransactorSession) TokenFallback(from common.Address, value *big.Int, data []byte) (*types.Transaction, error)

+ func (_VaultInterface *VaultInterfaceTransactorSession) Transfer(token common.Address, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_VaultInterface *VaultInterfaceTransactorSession) Unapprove(spender common.Address) (*types.Transaction, error)

+ func (_VaultInterface *VaultInterfaceTransactorSession) Withdraw(token common.Address, amount *big.Int) (*types.Transaction, error)

+ type VaultInterfaceUnapproved struct

+ Raw types.Log

+ Spender common.Address

+ User common.Address

+ type VaultInterfaceUnapprovedIterator struct

+ Event *VaultInterfaceUnapproved

+ func (it *VaultInterfaceUnapprovedIterator) Close() error

+ func (it *VaultInterfaceUnapprovedIterator) Error() error

+ func (it *VaultInterfaceUnapprovedIterator) Next() bool

+ type VaultInterfaceWithdrawn struct

+ Amount *big.Int

+ Raw types.Log

+ Token common.Address

+ User common.Address

+ type VaultInterfaceWithdrawnIterator struct

+ Event *VaultInterfaceWithdrawn

+ func (it *VaultInterfaceWithdrawnIterator) Close() error

+ func (it *VaultInterfaceWithdrawnIterator) Error() error

+ func (it *VaultInterfaceWithdrawnIterator) Next() bool

+ type VaultRaw struct

+ Contract *Vault

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

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

+ func (_Vault *VaultRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type VaultRemovedSpender struct

+ Raw types.Log

+ Spender common.Address

+ type VaultRemovedSpenderIterator struct

+ Event *VaultRemovedSpender

+ func (it *VaultRemovedSpenderIterator) Close() error

+ func (it *VaultRemovedSpenderIterator) Error() error

+ func (it *VaultRemovedSpenderIterator) Next() bool

+ type VaultSession struct

+ CallOpts bind.CallOpts

+ Contract *Vault

+ TransactOpts bind.TransactOpts

+ func (_Vault *VaultSession) AddSpender(spender common.Address) (*types.Transaction, error)

+ func (_Vault *VaultSession) Approve(spender common.Address) (*types.Transaction, error)

+ func (_Vault *VaultSession) BalanceOf(token common.Address, user common.Address) (*big.Int, error)

+ func (_Vault *VaultSession) Deposit(token common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_Vault *VaultSession) IsApproved(user common.Address, spender common.Address) (bool, error)

+ func (_Vault *VaultSession) IsSpender(spender common.Address) (bool, error)

+ func (_Vault *VaultSession) LatestSpender() (common.Address, error)

+ func (_Vault *VaultSession) RemoveSpender(spender common.Address) (*types.Transaction, error)

+ func (_Vault *VaultSession) TokenFallback(from common.Address, value *big.Int, data []byte) (*types.Transaction, error)

+ func (_Vault *VaultSession) Transfer(token common.Address, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_Vault *VaultSession) Unapprove(spender common.Address) (*types.Transaction, error)

+ func (_Vault *VaultSession) Withdraw(token common.Address, amount *big.Int) (*types.Transaction, error)

+ type VaultTransactor struct

+ func NewVaultTransactor(address common.Address, transactor bind.ContractTransactor) (*VaultTransactor, error)

+ func (_Vault *VaultTransactor) AddSpender(opts *bind.TransactOpts, spender common.Address) (*types.Transaction, error)

+ func (_Vault *VaultTransactor) Approve(opts *bind.TransactOpts, spender common.Address) (*types.Transaction, error)

+ func (_Vault *VaultTransactor) Deposit(opts *bind.TransactOpts, token common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_Vault *VaultTransactor) RemoveSpender(opts *bind.TransactOpts, spender common.Address) (*types.Transaction, error)

+ func (_Vault *VaultTransactor) TokenFallback(opts *bind.TransactOpts, from common.Address, value *big.Int, data []byte) (*types.Transaction, error)

+ func (_Vault *VaultTransactor) Transfer(opts *bind.TransactOpts, token common.Address, from common.Address, ...) (*types.Transaction, error)

+ func (_Vault *VaultTransactor) Unapprove(opts *bind.TransactOpts, spender common.Address) (*types.Transaction, error)

+ func (_Vault *VaultTransactor) Withdraw(opts *bind.TransactOpts, token common.Address, amount *big.Int) (*types.Transaction, error)

+ type VaultTransactorRaw struct

+ Contract *VaultTransactor

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

+ func (_Vault *VaultTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type VaultTransactorSession struct

+ Contract *VaultTransactor

+ TransactOpts bind.TransactOpts

+ func (_Vault *VaultTransactorSession) AddSpender(spender common.Address) (*types.Transaction, error)

+ func (_Vault *VaultTransactorSession) Approve(spender common.Address) (*types.Transaction, error)

+ func (_Vault *VaultTransactorSession) Deposit(token common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_Vault *VaultTransactorSession) RemoveSpender(spender common.Address) (*types.Transaction, error)

+ func (_Vault *VaultTransactorSession) TokenFallback(from common.Address, value *big.Int, data []byte) (*types.Transaction, error)

+ func (_Vault *VaultTransactorSession) Transfer(token common.Address, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_Vault *VaultTransactorSession) Unapprove(spender common.Address) (*types.Transaction, error)

+ func (_Vault *VaultTransactorSession) Withdraw(token common.Address, amount *big.Int) (*types.Transaction, error)

+ type VaultUnapproved struct

+ Raw types.Log

+ Spender common.Address

+ User common.Address

+ type VaultUnapprovedIterator struct

+ Event *VaultUnapproved

+ func (it *VaultUnapprovedIterator) Close() error

+ func (it *VaultUnapprovedIterator) Error() error

+ func (it *VaultUnapprovedIterator) Next() bool

+ type VaultWithdrawn struct

+ Amount *big.Int

+ Raw types.Log

+ Token common.Address

+ User common.Address

+ type VaultWithdrawnIterator struct

+ Event *VaultWithdrawn

+ func (it *VaultWithdrawnIterator) Close() error

+ func (it *VaultWithdrawnIterator) Error() error

+ func (it *VaultWithdrawnIterator) Next() bool