protocol

package
v0.0.0-...-5589fd4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 17, 2021 License: MIT Imports: 8 Imported by: 0

Documentation

Index

Constants

View Source 
const ExchangeABI = "" /* 7692-byte string literal not displayed */

ExchangeABI is the input ABI used to generate the binding from.

View Source 
const ExchangeBin = `` /* 15102-byte string literal not displayed */

ExchangeBin is the compiled bytecode used for deploying new contracts.

View Source 
const OwnableABI = "" /* 468-byte string literal not displayed */

OwnableABI is the input ABI used to generate the binding from.

View Source 
const OwnableBin = `` /* 868-byte string literal not displayed */

OwnableBin is the compiled bytecode used for deploying new contracts.

View Source 
const SafeMathABI = "[]"

SafeMathABI is the input ABI used to generate the binding from.

View Source 
const SafeMathBin = `` /* 166-byte string literal not displayed */

SafeMathBin is the compiled bytecode used for deploying new contracts.

View Source 
const TokenABI = "" /* 1832-byte string literal not displayed */

TokenABI is the input ABI used to generate the binding from.

View Source 
const TokenBin = `` /* 898-byte string literal not displayed */

TokenBin is the compiled bytecode used for deploying new contracts.

View Source 
const TokenTransferProxyABI = "" /* 2172-byte string literal not displayed */

TokenTransferProxyABI is the input ABI used to generate the binding from.

View Source 
const TokenTransferProxyBin = `` /* 3434-byte string literal not displayed */

TokenTransferProxyBin is the compiled bytecode used for deploying new contracts.

Variables

This section is empty.

Functions

This section is empty.

Types

type Exchange 

type Exchange struct {
	ExchangeCaller     // Read-only binding to the contract
	ExchangeTransactor // Write-only binding to the contract
	ExchangeFilterer   // Log filterer for contract events
}

Exchange is an auto generated Go binding around an Ethereum contract.

func DeployExchange 

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

DeployExchange deploys a new Ethereum contract, binding an instance of Exchange to it.

func NewExchange 

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

NewExchange creates a new instance of Exchange, bound to a specific deployed contract.

type ExchangeCaller 

type ExchangeCaller struct {
	// contains filtered or unexported fields
}

ExchangeCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewExchangeCaller 

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

NewExchangeCaller creates a new read-only instance of Exchange, bound to a specific deployed contract.

func (*ExchangeCaller) Cancelled 

func (_Exchange *ExchangeCaller) Cancelled(opts *bind.CallOpts, arg0 [32]byte) (*big.Int, error)

Cancelled is a free data retrieval call binding the contract method 0x2ac12622.

Solidity: function cancelled(bytes32 ) constant returns(uint256)

func (*ExchangeCaller) EXTERNALQUERYGASLIMIT 

func (_Exchange *ExchangeCaller) EXTERNALQUERYGASLIMIT(opts *bind.CallOpts) (uint16, error)

EXTERNALQUERYGASLIMIT is a free data retrieval call binding the contract method 0xf06bbf75.

Solidity: function EXTERNAL_QUERY_GAS_LIMIT() constant returns(uint16)

func (*ExchangeCaller) Filled 

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

Filled is a free data retrieval call binding the contract method 0x288cdc91.

Solidity: function filled(bytes32 ) constant returns(uint256)

func (*ExchangeCaller) GetOrderHash 

func (_Exchange *ExchangeCaller) GetOrderHash(opts *bind.CallOpts, orderAddresses [5]common.Address, orderValues [6]*big.Int) ([32]byte, error)

GetOrderHash is a free data retrieval call binding the contract method 0xcfc4d0ec.

Solidity: function getOrderHash(address[5] orderAddresses, uint256[6] orderValues) constant returns(bytes32)

func (*ExchangeCaller) GetPartialAmount 

func (_Exchange *ExchangeCaller) GetPartialAmount(opts *bind.CallOpts, numerator *big.Int, denominator *big.Int, target *big.Int) (*big.Int, error)

GetPartialAmount is a free data retrieval call binding the contract method 0x98024a8b.

Solidity: function getPartialAmount(uint256 numerator, uint256 denominator, uint256 target) constant returns(uint256)

func (*ExchangeCaller) GetUnavailableTakerTokenAmount 

func (_Exchange *ExchangeCaller) GetUnavailableTakerTokenAmount(opts *bind.CallOpts, orderHash [32]byte) (*big.Int, error)

GetUnavailableTakerTokenAmount is a free data retrieval call binding the contract method 0x7e9abb50.

Solidity: function getUnavailableTakerTokenAmount(bytes32 orderHash) constant returns(uint256)

func (*ExchangeCaller) IsRoundingError 

func (_Exchange *ExchangeCaller) IsRoundingError(opts *bind.CallOpts, numerator *big.Int, denominator *big.Int, target *big.Int) (bool, error)

IsRoundingError is a free data retrieval call binding the contract method 0x14df96ee.

Solidity: function isRoundingError(uint256 numerator, uint256 denominator, uint256 target) constant returns(bool)

func (*ExchangeCaller) IsValidSignature 

func (_Exchange *ExchangeCaller) IsValidSignature(opts *bind.CallOpts, signer common.Address, hash [32]byte, v uint8, r [32]byte, s [32]byte) (bool, error)

IsValidSignature is a free data retrieval call binding the contract method 0x8163681e.

Solidity: function isValidSignature(address signer, bytes32 hash, uint8 v, bytes32 r, bytes32 s) constant returns(bool)

func (*ExchangeCaller) TOKENTRANSFERPROXYCONTRACT 

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

TOKENTRANSFERPROXYCONTRACT is a free data retrieval call binding the contract method 0xadd1cbc5.

Solidity: function TOKEN_TRANSFER_PROXY_CONTRACT() constant returns(address)

func (*ExchangeCaller) VERSION 

func (_Exchange *ExchangeCaller) VERSION(opts *bind.CallOpts) (string, error)

VERSION is a free data retrieval call binding the contract method 0xffa1ad74.

Solidity: function VERSION() constant returns(string)

func (*ExchangeCaller) ZRXTOKENCONTRACT 

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

ZRXTOKENCONTRACT is a free data retrieval call binding the contract method 0x3b30ba59.

Solidity: function ZRX_TOKEN_CONTRACT() constant returns(address)

type ExchangeCallerRaw 

type ExchangeCallerRaw struct {
	Contract *ExchangeCaller // Generic read-only contract binding to access the raw methods on
}

ExchangeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*ExchangeCallerRaw) Call 

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

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type ExchangeCallerSession 

type ExchangeCallerSession struct {
	Contract *ExchangeCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts   // Call options to use throughout this session
}

ExchangeCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*ExchangeCallerSession) Cancelled 

func (_Exchange *ExchangeCallerSession) Cancelled(arg0 [32]byte) (*big.Int, error)

Cancelled is a free data retrieval call binding the contract method 0x2ac12622.

Solidity: function cancelled(bytes32 ) constant returns(uint256)

func (*ExchangeCallerSession) EXTERNALQUERYGASLIMIT 

func (_Exchange *ExchangeCallerSession) EXTERNALQUERYGASLIMIT() (uint16, error)

EXTERNALQUERYGASLIMIT is a free data retrieval call binding the contract method 0xf06bbf75.

Solidity: function EXTERNAL_QUERY_GAS_LIMIT() constant returns(uint16)

func (*ExchangeCallerSession) Filled 

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

Filled is a free data retrieval call binding the contract method 0x288cdc91.

Solidity: function filled(bytes32 ) constant returns(uint256)

func (*ExchangeCallerSession) GetOrderHash 

func (_Exchange *ExchangeCallerSession) GetOrderHash(orderAddresses [5]common.Address, orderValues [6]*big.Int) ([32]byte, error)

GetOrderHash is a free data retrieval call binding the contract method 0xcfc4d0ec.

Solidity: function getOrderHash(address[5] orderAddresses, uint256[6] orderValues) constant returns(bytes32)

func (*ExchangeCallerSession) GetPartialAmount 

func (_Exchange *ExchangeCallerSession) GetPartialAmount(numerator *big.Int, denominator *big.Int, target *big.Int) (*big.Int, error)

GetPartialAmount is a free data retrieval call binding the contract method 0x98024a8b.

Solidity: function getPartialAmount(uint256 numerator, uint256 denominator, uint256 target) constant returns(uint256)

func (*ExchangeCallerSession) GetUnavailableTakerTokenAmount 

func (_Exchange *ExchangeCallerSession) GetUnavailableTakerTokenAmount(orderHash [32]byte) (*big.Int, error)

GetUnavailableTakerTokenAmount is a free data retrieval call binding the contract method 0x7e9abb50.

Solidity: function getUnavailableTakerTokenAmount(bytes32 orderHash) constant returns(uint256)

func (*ExchangeCallerSession) IsRoundingError 

func (_Exchange *ExchangeCallerSession) IsRoundingError(numerator *big.Int, denominator *big.Int, target *big.Int) (bool, error)

IsRoundingError is a free data retrieval call binding the contract method 0x14df96ee.

Solidity: function isRoundingError(uint256 numerator, uint256 denominator, uint256 target) constant returns(bool)

func (*ExchangeCallerSession) IsValidSignature 

func (_Exchange *ExchangeCallerSession) IsValidSignature(signer common.Address, hash [32]byte, v uint8, r [32]byte, s [32]byte) (bool, error)

IsValidSignature is a free data retrieval call binding the contract method 0x8163681e.

Solidity: function isValidSignature(address signer, bytes32 hash, uint8 v, bytes32 r, bytes32 s) constant returns(bool)

func (*ExchangeCallerSession) TOKENTRANSFERPROXYCONTRACT 

func (_Exchange *ExchangeCallerSession) TOKENTRANSFERPROXYCONTRACT() (common.Address, error)

TOKENTRANSFERPROXYCONTRACT is a free data retrieval call binding the contract method 0xadd1cbc5.

Solidity: function TOKEN_TRANSFER_PROXY_CONTRACT() constant returns(address)

func (*ExchangeCallerSession) VERSION 

func (_Exchange *ExchangeCallerSession) VERSION() (string, error)

VERSION is a free data retrieval call binding the contract method 0xffa1ad74.

Solidity: function VERSION() constant returns(string)

func (*ExchangeCallerSession) ZRXTOKENCONTRACT 

func (_Exchange *ExchangeCallerSession) ZRXTOKENCONTRACT() (common.Address, error)

ZRXTOKENCONTRACT is a free data retrieval call binding the contract method 0x3b30ba59.

Solidity: function ZRX_TOKEN_CONTRACT() constant returns(address)

type ExchangeFilterer 

type ExchangeFilterer struct {
	// contains filtered or unexported fields
}

ExchangeFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewExchangeFilterer 

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

NewExchangeFilterer creates a new log filterer instance of Exchange, bound to a specific deployed contract.

func (*ExchangeFilterer) FilterLogCancel 

func (_Exchange *ExchangeFilterer) FilterLogCancel(opts *bind.FilterOpts, maker []common.Address, feeRecipient []common.Address, tokens [][32]byte) (*ExchangeLogCancelIterator, error)

FilterLogCancel is a free log retrieval operation binding the contract event 0x67d66f160bc93d925d05dae1794c90d2d6d6688b29b84ff069398a9b04587131.

Solidity: event LogCancel(address indexed maker, address indexed feeRecipient, address makerToken, address takerToken, uint256 cancelledMakerTokenAmount, uint256 cancelledTakerTokenAmount, bytes32 indexed tokens, bytes32 orderHash)

func (*ExchangeFilterer) FilterLogError 

func (_Exchange *ExchangeFilterer) FilterLogError(opts *bind.FilterOpts, errorId []uint8, orderHash [][32]byte) (*ExchangeLogErrorIterator, error)

FilterLogError is a free log retrieval operation binding the contract event 0x36d86c59e00bd73dc19ba3adfe068e4b64ac7e92be35546adeddf1b956a87e90.

Solidity: event LogError(uint8 indexed errorId, bytes32 indexed orderHash)

func (*ExchangeFilterer) FilterLogFill 

func (_Exchange *ExchangeFilterer) FilterLogFill(opts *bind.FilterOpts, maker []common.Address, feeRecipient []common.Address, tokens [][32]byte) (*ExchangeLogFillIterator, error)

FilterLogFill is a free log retrieval operation binding the contract event 0x0d0b9391970d9a25552f37d436d2aae2925e2bfe1b2a923754bada030c498cb3.

Solidity: event LogFill(address indexed maker, address taker, address indexed feeRecipient, address makerToken, address takerToken, uint256 filledMakerTokenAmount, uint256 filledTakerTokenAmount, uint256 paidMakerFee, uint256 paidTakerFee, bytes32 indexed tokens, bytes32 orderHash)

func (*ExchangeFilterer) WatchLogCancel 

func (_Exchange *ExchangeFilterer) WatchLogCancel(opts *bind.WatchOpts, sink chan<- *ExchangeLogCancel, maker []common.Address, feeRecipient []common.Address, tokens [][32]byte) (event.Subscription, error)

WatchLogCancel is a free log subscription operation binding the contract event 0x67d66f160bc93d925d05dae1794c90d2d6d6688b29b84ff069398a9b04587131.

Solidity: event LogCancel(address indexed maker, address indexed feeRecipient, address makerToken, address takerToken, uint256 cancelledMakerTokenAmount, uint256 cancelledTakerTokenAmount, bytes32 indexed tokens, bytes32 orderHash)

func (*ExchangeFilterer) WatchLogError 

func (_Exchange *ExchangeFilterer) WatchLogError(opts *bind.WatchOpts, sink chan<- *ExchangeLogError, errorId []uint8, orderHash [][32]byte) (event.Subscription, error)

WatchLogError is a free log subscription operation binding the contract event 0x36d86c59e00bd73dc19ba3adfe068e4b64ac7e92be35546adeddf1b956a87e90.

Solidity: event LogError(uint8 indexed errorId, bytes32 indexed orderHash)

func (*ExchangeFilterer) WatchLogFill 

func (_Exchange *ExchangeFilterer) WatchLogFill(opts *bind.WatchOpts, sink chan<- *ExchangeLogFill, maker []common.Address, feeRecipient []common.Address, tokens [][32]byte) (event.Subscription, error)

WatchLogFill is a free log subscription operation binding the contract event 0x0d0b9391970d9a25552f37d436d2aae2925e2bfe1b2a923754bada030c498cb3.

Solidity: event LogFill(address indexed maker, address taker, address indexed feeRecipient, address makerToken, address takerToken, uint256 filledMakerTokenAmount, uint256 filledTakerTokenAmount, uint256 paidMakerFee, uint256 paidTakerFee, bytes32 indexed tokens, bytes32 orderHash)

type ExchangeLogCancel 

type ExchangeLogCancel struct {
	Maker                     common.Address
	FeeRecipient              common.Address
	MakerToken                common.Address
	TakerToken                common.Address
	CancelledMakerTokenAmount *big.Int
	CancelledTakerTokenAmount *big.Int
	Tokens                    [32]byte
	OrderHash                 [32]byte
	Raw                       types.Log // Blockchain specific contextual infos
}

ExchangeLogCancel represents a LogCancel event raised by the Exchange contract.

type ExchangeLogCancelIterator 

type ExchangeLogCancelIterator struct {
	Event *ExchangeLogCancel // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

ExchangeLogCancelIterator is returned from FilterLogCancel and is used to iterate over the raw logs and unpacked data for LogCancel events raised by the Exchange contract.

func (*ExchangeLogCancelIterator) Close 

func (it *ExchangeLogCancelIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*ExchangeLogCancelIterator) Error 

func (it *ExchangeLogCancelIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ExchangeLogCancelIterator) Next 

func (it *ExchangeLogCancelIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type ExchangeLogError 

type ExchangeLogError struct {
	ErrorId   uint8
	OrderHash [32]byte
	Raw       types.Log // Blockchain specific contextual infos
}

ExchangeLogError represents a LogError event raised by the Exchange contract.

type ExchangeLogErrorIterator 

type ExchangeLogErrorIterator struct {
	Event *ExchangeLogError // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

ExchangeLogErrorIterator is returned from FilterLogError and is used to iterate over the raw logs and unpacked data for LogError events raised by the Exchange contract.

func (*ExchangeLogErrorIterator) Close 

func (it *ExchangeLogErrorIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*ExchangeLogErrorIterator) Error 

func (it *ExchangeLogErrorIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ExchangeLogErrorIterator) Next 

func (it *ExchangeLogErrorIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type ExchangeLogFill 

type ExchangeLogFill struct {
	Maker                  common.Address
	Taker                  common.Address
	FeeRecipient           common.Address
	MakerToken             common.Address
	TakerToken             common.Address
	FilledMakerTokenAmount *big.Int
	FilledTakerTokenAmount *big.Int
	PaidMakerFee           *big.Int
	PaidTakerFee           *big.Int
	Tokens                 [32]byte
	OrderHash              [32]byte
	Raw                    types.Log // Blockchain specific contextual infos
}

ExchangeLogFill represents a LogFill event raised by the Exchange contract.

type ExchangeLogFillIterator 

type ExchangeLogFillIterator struct {
	Event *ExchangeLogFill // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

ExchangeLogFillIterator is returned from FilterLogFill and is used to iterate over the raw logs and unpacked data for LogFill events raised by the Exchange contract.

func (*ExchangeLogFillIterator) Close 

func (it *ExchangeLogFillIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*ExchangeLogFillIterator) Error 

func (it *ExchangeLogFillIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ExchangeLogFillIterator) Next 

func (it *ExchangeLogFillIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type ExchangeRaw 

type ExchangeRaw struct {
	Contract *Exchange // Generic contract binding to access the raw methods on
}

ExchangeRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*ExchangeRaw) Call 

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

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*ExchangeRaw) Transact 

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

Transact invokes the (paid) contract method with params as input values.

func (*ExchangeRaw) Transfer 

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

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ExchangeSession 

type ExchangeSession struct {
	Contract     *Exchange         // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

ExchangeSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*ExchangeSession) BatchCancelOrders 

func (_Exchange *ExchangeSession) BatchCancelOrders(orderAddresses [][5]common.Address, orderValues [][6]*big.Int, cancelTakerTokenAmounts []*big.Int) (*types.Transaction, error)

BatchCancelOrders is a paid mutator transaction binding the contract method 0xbaa0181d.

Solidity: function batchCancelOrders(address[5][] orderAddresses, uint256[6][] orderValues, uint256[] cancelTakerTokenAmounts) returns()

func (*ExchangeSession) BatchFillOrKillOrders 

func (_Exchange *ExchangeSession) BatchFillOrKillOrders(orderAddresses [][5]common.Address, orderValues [][6]*big.Int, fillTakerTokenAmounts []*big.Int, v []uint8, r [][32]byte, s [][32]byte) (*types.Transaction, error)

BatchFillOrKillOrders is a paid mutator transaction binding the contract method 0x4f150787.

Solidity: function batchFillOrKillOrders(address[5][] orderAddresses, uint256[6][] orderValues, uint256[] fillTakerTokenAmounts, uint8[] v, bytes32[] r, bytes32[] s) returns()

func (*ExchangeSession) BatchFillOrders 

func (_Exchange *ExchangeSession) BatchFillOrders(orderAddresses [][5]common.Address, orderValues [][6]*big.Int, fillTakerTokenAmounts []*big.Int, shouldThrowOnInsufficientBalanceOrAllowance bool, v []uint8, r [][32]byte, s [][32]byte) (*types.Transaction, error)

BatchFillOrders is a paid mutator transaction binding the contract method 0xb7b2c7d6.

Solidity: function batchFillOrders(address[5][] orderAddresses, uint256[6][] orderValues, uint256[] fillTakerTokenAmounts, bool shouldThrowOnInsufficientBalanceOrAllowance, uint8[] v, bytes32[] r, bytes32[] s) returns()

func (*ExchangeSession) CancelOrder 

func (_Exchange *ExchangeSession) CancelOrder(orderAddresses [5]common.Address, orderValues [6]*big.Int, cancelTakerTokenAmount *big.Int) (*types.Transaction, error)

CancelOrder is a paid mutator transaction binding the contract method 0x394c21e7.

Solidity: function cancelOrder(address[5] orderAddresses, uint256[6] orderValues, uint256 cancelTakerTokenAmount) returns(uint256)

func (*ExchangeSession) Cancelled 

func (_Exchange *ExchangeSession) Cancelled(arg0 [32]byte) (*big.Int, error)

Cancelled is a free data retrieval call binding the contract method 0x2ac12622.

Solidity: function cancelled(bytes32 ) constant returns(uint256)

func (*ExchangeSession) EXTERNALQUERYGASLIMIT 

func (_Exchange *ExchangeSession) EXTERNALQUERYGASLIMIT() (uint16, error)

EXTERNALQUERYGASLIMIT is a free data retrieval call binding the contract method 0xf06bbf75.

Solidity: function EXTERNAL_QUERY_GAS_LIMIT() constant returns(uint16)

func (*ExchangeSession) FillOrKillOrder 

func (_Exchange *ExchangeSession) FillOrKillOrder(orderAddresses [5]common.Address, orderValues [6]*big.Int, fillTakerTokenAmount *big.Int, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error)

FillOrKillOrder is a paid mutator transaction binding the contract method 0x741bcc93.

Solidity: function fillOrKillOrder(address[5] orderAddresses, uint256[6] orderValues, uint256 fillTakerTokenAmount, uint8 v, bytes32 r, bytes32 s) returns()

func (*ExchangeSession) FillOrder 

func (_Exchange *ExchangeSession) FillOrder(orderAddresses [5]common.Address, orderValues [6]*big.Int, fillTakerTokenAmount *big.Int, shouldThrowOnInsufficientBalanceOrAllowance bool, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error)

FillOrder is a paid mutator transaction binding the contract method 0xbc61394a.

Solidity: function fillOrder(address[5] orderAddresses, uint256[6] orderValues, uint256 fillTakerTokenAmount, bool shouldThrowOnInsufficientBalanceOrAllowance, uint8 v, bytes32 r, bytes32 s) returns(uint256 filledTakerTokenAmount)

func (*ExchangeSession) FillOrdersUpTo 

func (_Exchange *ExchangeSession) FillOrdersUpTo(orderAddresses [][5]common.Address, orderValues [][6]*big.Int, fillTakerTokenAmount *big.Int, shouldThrowOnInsufficientBalanceOrAllowance bool, v []uint8, r [][32]byte, s [][32]byte) (*types.Transaction, error)

FillOrdersUpTo is a paid mutator transaction binding the contract method 0x363349be.

Solidity: function fillOrdersUpTo(address[5][] orderAddresses, uint256[6][] orderValues, uint256 fillTakerTokenAmount, bool shouldThrowOnInsufficientBalanceOrAllowance, uint8[] v, bytes32[] r, bytes32[] s) returns(uint256)

func (*ExchangeSession) Filled 

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

Filled is a free data retrieval call binding the contract method 0x288cdc91.

Solidity: function filled(bytes32 ) constant returns(uint256)

func (*ExchangeSession) GetOrderHash 

func (_Exchange *ExchangeSession) GetOrderHash(orderAddresses [5]common.Address, orderValues [6]*big.Int) ([32]byte, error)

GetOrderHash is a free data retrieval call binding the contract method 0xcfc4d0ec.

Solidity: function getOrderHash(address[5] orderAddresses, uint256[6] orderValues) constant returns(bytes32)

func (*ExchangeSession) GetPartialAmount 

func (_Exchange *ExchangeSession) GetPartialAmount(numerator *big.Int, denominator *big.Int, target *big.Int) (*big.Int, error)

GetPartialAmount is a free data retrieval call binding the contract method 0x98024a8b.

Solidity: function getPartialAmount(uint256 numerator, uint256 denominator, uint256 target) constant returns(uint256)

func (*ExchangeSession) GetUnavailableTakerTokenAmount 

func (_Exchange *ExchangeSession) GetUnavailableTakerTokenAmount(orderHash [32]byte) (*big.Int, error)

GetUnavailableTakerTokenAmount is a free data retrieval call binding the contract method 0x7e9abb50.

Solidity: function getUnavailableTakerTokenAmount(bytes32 orderHash) constant returns(uint256)

func (*ExchangeSession) IsRoundingError 

func (_Exchange *ExchangeSession) IsRoundingError(numerator *big.Int, denominator *big.Int, target *big.Int) (bool, error)

IsRoundingError is a free data retrieval call binding the contract method 0x14df96ee.

Solidity: function isRoundingError(uint256 numerator, uint256 denominator, uint256 target) constant returns(bool)

func (*ExchangeSession) IsValidSignature 

func (_Exchange *ExchangeSession) IsValidSignature(signer common.Address, hash [32]byte, v uint8, r [32]byte, s [32]byte) (bool, error)

IsValidSignature is a free data retrieval call binding the contract method 0x8163681e.

Solidity: function isValidSignature(address signer, bytes32 hash, uint8 v, bytes32 r, bytes32 s) constant returns(bool)

func (*ExchangeSession) TOKENTRANSFERPROXYCONTRACT 

func (_Exchange *ExchangeSession) TOKENTRANSFERPROXYCONTRACT() (common.Address, error)

TOKENTRANSFERPROXYCONTRACT is a free data retrieval call binding the contract method 0xadd1cbc5.

Solidity: function TOKEN_TRANSFER_PROXY_CONTRACT() constant returns(address)

func (*ExchangeSession) VERSION 

func (_Exchange *ExchangeSession) VERSION() (string, error)

VERSION is a free data retrieval call binding the contract method 0xffa1ad74.

Solidity: function VERSION() constant returns(string)

func (*ExchangeSession) ZRXTOKENCONTRACT 

func (_Exchange *ExchangeSession) ZRXTOKENCONTRACT() (common.Address, error)

ZRXTOKENCONTRACT is a free data retrieval call binding the contract method 0x3b30ba59.

Solidity: function ZRX_TOKEN_CONTRACT() constant returns(address)

type ExchangeTransactor 

type ExchangeTransactor struct {
	// contains filtered or unexported fields
}

ExchangeTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewExchangeTransactor 

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

NewExchangeTransactor creates a new write-only instance of Exchange, bound to a specific deployed contract.

func (*ExchangeTransactor) BatchCancelOrders 

func (_Exchange *ExchangeTransactor) BatchCancelOrders(opts *bind.TransactOpts, orderAddresses [][5]common.Address, orderValues [][6]*big.Int, cancelTakerTokenAmounts []*big.Int) (*types.Transaction, error)

BatchCancelOrders is a paid mutator transaction binding the contract method 0xbaa0181d.

Solidity: function batchCancelOrders(address[5][] orderAddresses, uint256[6][] orderValues, uint256[] cancelTakerTokenAmounts) returns()

func (*ExchangeTransactor) BatchFillOrKillOrders 

func (_Exchange *ExchangeTransactor) BatchFillOrKillOrders(opts *bind.TransactOpts, orderAddresses [][5]common.Address, orderValues [][6]*big.Int, fillTakerTokenAmounts []*big.Int, v []uint8, r [][32]byte, s [][32]byte) (*types.Transaction, error)

BatchFillOrKillOrders is a paid mutator transaction binding the contract method 0x4f150787.

Solidity: function batchFillOrKillOrders(address[5][] orderAddresses, uint256[6][] orderValues, uint256[] fillTakerTokenAmounts, uint8[] v, bytes32[] r, bytes32[] s) returns()

func (*ExchangeTransactor) BatchFillOrders 

func (_Exchange *ExchangeTransactor) BatchFillOrders(opts *bind.TransactOpts, orderAddresses [][5]common.Address, orderValues [][6]*big.Int, fillTakerTokenAmounts []*big.Int, shouldThrowOnInsufficientBalanceOrAllowance bool, v []uint8, r [][32]byte, s [][32]byte) (*types.Transaction, error)

BatchFillOrders is a paid mutator transaction binding the contract method 0xb7b2c7d6.

Solidity: function batchFillOrders(address[5][] orderAddresses, uint256[6][] orderValues, uint256[] fillTakerTokenAmounts, bool shouldThrowOnInsufficientBalanceOrAllowance, uint8[] v, bytes32[] r, bytes32[] s) returns()

func (*ExchangeTransactor) CancelOrder 

func (_Exchange *ExchangeTransactor) CancelOrder(opts *bind.TransactOpts, orderAddresses [5]common.Address, orderValues [6]*big.Int, cancelTakerTokenAmount *big.Int) (*types.Transaction, error)

CancelOrder is a paid mutator transaction binding the contract method 0x394c21e7.

Solidity: function cancelOrder(address[5] orderAddresses, uint256[6] orderValues, uint256 cancelTakerTokenAmount) returns(uint256)

func (*ExchangeTransactor) FillOrKillOrder 

func (_Exchange *ExchangeTransactor) FillOrKillOrder(opts *bind.TransactOpts, orderAddresses [5]common.Address, orderValues [6]*big.Int, fillTakerTokenAmount *big.Int, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error)

FillOrKillOrder is a paid mutator transaction binding the contract method 0x741bcc93.

Solidity: function fillOrKillOrder(address[5] orderAddresses, uint256[6] orderValues, uint256 fillTakerTokenAmount, uint8 v, bytes32 r, bytes32 s) returns()

func (*ExchangeTransactor) FillOrder 

func (_Exchange *ExchangeTransactor) FillOrder(opts *bind.TransactOpts, orderAddresses [5]common.Address, orderValues [6]*big.Int, fillTakerTokenAmount *big.Int, shouldThrowOnInsufficientBalanceOrAllowance bool, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error)

FillOrder is a paid mutator transaction binding the contract method 0xbc61394a.

Solidity: function fillOrder(address[5] orderAddresses, uint256[6] orderValues, uint256 fillTakerTokenAmount, bool shouldThrowOnInsufficientBalanceOrAllowance, uint8 v, bytes32 r, bytes32 s) returns(uint256 filledTakerTokenAmount)

func (*ExchangeTransactor) FillOrdersUpTo 

func (_Exchange *ExchangeTransactor) FillOrdersUpTo(opts *bind.TransactOpts, orderAddresses [][5]common.Address, orderValues [][6]*big.Int, fillTakerTokenAmount *big.Int, shouldThrowOnInsufficientBalanceOrAllowance bool, v []uint8, r [][32]byte, s [][32]byte) (*types.Transaction, error)

FillOrdersUpTo is a paid mutator transaction binding the contract method 0x363349be.

Solidity: function fillOrdersUpTo(address[5][] orderAddresses, uint256[6][] orderValues, uint256 fillTakerTokenAmount, bool shouldThrowOnInsufficientBalanceOrAllowance, uint8[] v, bytes32[] r, bytes32[] s) returns(uint256)

type ExchangeTransactorRaw 

type ExchangeTransactorRaw struct {
	Contract *ExchangeTransactor // Generic write-only contract binding to access the raw methods on
}

ExchangeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*ExchangeTransactorRaw) Transact 

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

Transact invokes the (paid) contract method with params as input values.

func (*ExchangeTransactorRaw) Transfer 

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

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ExchangeTransactorSession 

type ExchangeTransactorSession struct {
	Contract     *ExchangeTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
}

ExchangeTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*ExchangeTransactorSession) BatchCancelOrders 

func (_Exchange *ExchangeTransactorSession) BatchCancelOrders(orderAddresses [][5]common.Address, orderValues [][6]*big.Int, cancelTakerTokenAmounts []*big.Int) (*types.Transaction, error)

BatchCancelOrders is a paid mutator transaction binding the contract method 0xbaa0181d.

Solidity: function batchCancelOrders(address[5][] orderAddresses, uint256[6][] orderValues, uint256[] cancelTakerTokenAmounts) returns()

func (*ExchangeTransactorSession) BatchFillOrKillOrders 

func (_Exchange *ExchangeTransactorSession) BatchFillOrKillOrders(orderAddresses [][5]common.Address, orderValues [][6]*big.Int, fillTakerTokenAmounts []*big.Int, v []uint8, r [][32]byte, s [][32]byte) (*types.Transaction, error)

BatchFillOrKillOrders is a paid mutator transaction binding the contract method 0x4f150787.

Solidity: function batchFillOrKillOrders(address[5][] orderAddresses, uint256[6][] orderValues, uint256[] fillTakerTokenAmounts, uint8[] v, bytes32[] r, bytes32[] s) returns()

func (*ExchangeTransactorSession) BatchFillOrders 

func (_Exchange *ExchangeTransactorSession) BatchFillOrders(orderAddresses [][5]common.Address, orderValues [][6]*big.Int, fillTakerTokenAmounts []*big.Int, shouldThrowOnInsufficientBalanceOrAllowance bool, v []uint8, r [][32]byte, s [][32]byte) (*types.Transaction, error)

BatchFillOrders is a paid mutator transaction binding the contract method 0xb7b2c7d6.

Solidity: function batchFillOrders(address[5][] orderAddresses, uint256[6][] orderValues, uint256[] fillTakerTokenAmounts, bool shouldThrowOnInsufficientBalanceOrAllowance, uint8[] v, bytes32[] r, bytes32[] s) returns()

func (*ExchangeTransactorSession) CancelOrder 

func (_Exchange *ExchangeTransactorSession) CancelOrder(orderAddresses [5]common.Address, orderValues [6]*big.Int, cancelTakerTokenAmount *big.Int) (*types.Transaction, error)

CancelOrder is a paid mutator transaction binding the contract method 0x394c21e7.

Solidity: function cancelOrder(address[5] orderAddresses, uint256[6] orderValues, uint256 cancelTakerTokenAmount) returns(uint256)

func (*ExchangeTransactorSession) FillOrKillOrder 

func (_Exchange *ExchangeTransactorSession) FillOrKillOrder(orderAddresses [5]common.Address, orderValues [6]*big.Int, fillTakerTokenAmount *big.Int, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error)

FillOrKillOrder is a paid mutator transaction binding the contract method 0x741bcc93.

Solidity: function fillOrKillOrder(address[5] orderAddresses, uint256[6] orderValues, uint256 fillTakerTokenAmount, uint8 v, bytes32 r, bytes32 s) returns()

func (*ExchangeTransactorSession) FillOrder 

func (_Exchange *ExchangeTransactorSession) FillOrder(orderAddresses [5]common.Address, orderValues [6]*big.Int, fillTakerTokenAmount *big.Int, shouldThrowOnInsufficientBalanceOrAllowance bool, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error)

FillOrder is a paid mutator transaction binding the contract method 0xbc61394a.

Solidity: function fillOrder(address[5] orderAddresses, uint256[6] orderValues, uint256 fillTakerTokenAmount, bool shouldThrowOnInsufficientBalanceOrAllowance, uint8 v, bytes32 r, bytes32 s) returns(uint256 filledTakerTokenAmount)

func (*ExchangeTransactorSession) FillOrdersUpTo 

func (_Exchange *ExchangeTransactorSession) FillOrdersUpTo(orderAddresses [][5]common.Address, orderValues [][6]*big.Int, fillTakerTokenAmount *big.Int, shouldThrowOnInsufficientBalanceOrAllowance bool, v []uint8, r [][32]byte, s [][32]byte) (*types.Transaction, error)

FillOrdersUpTo is a paid mutator transaction binding the contract method 0x363349be.

Solidity: function fillOrdersUpTo(address[5][] orderAddresses, uint256[6][] orderValues, uint256 fillTakerTokenAmount, bool shouldThrowOnInsufficientBalanceOrAllowance, uint8[] v, bytes32[] r, bytes32[] s) returns(uint256)

type Ownable 

type Ownable struct {
	OwnableCaller     // Read-only binding to the contract
	OwnableTransactor // Write-only binding to the contract
	OwnableFilterer   // Log filterer for contract events
}

Ownable is an auto generated Go binding around an Ethereum contract.

func DeployOwnable 

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

DeployOwnable deploys a new Ethereum contract, binding an instance of Ownable to it.

func NewOwnable 

func NewOwnable(address common.Address, backend bind.ContractBackend) (*Ownable, error)

NewOwnable creates a new instance of Ownable, bound to a specific deployed contract.

type OwnableCaller 

type OwnableCaller struct {
	// contains filtered or unexported fields
}

OwnableCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewOwnableCaller 

func NewOwnableCaller(address common.Address, caller bind.ContractCaller) (*OwnableCaller, error)

NewOwnableCaller creates a new read-only instance of Ownable, bound to a specific deployed contract.

func (*OwnableCaller) Owner 

func (_Ownable *OwnableCaller) Owner(opts *bind.CallOpts) (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

type OwnableCallerRaw 

type OwnableCallerRaw struct {
	Contract *OwnableCaller // Generic read-only contract binding to access the raw methods on
}

OwnableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*OwnableCallerRaw) Call 

func (_Ownable *OwnableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type OwnableCallerSession 

type OwnableCallerSession struct {
	Contract *OwnableCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts  // Call options to use throughout this session
}

OwnableCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*OwnableCallerSession) Owner 

func (_Ownable *OwnableCallerSession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

type OwnableFilterer 

type OwnableFilterer struct {
	// contains filtered or unexported fields
}

OwnableFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewOwnableFilterer 

func NewOwnableFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableFilterer, error)

NewOwnableFilterer creates a new log filterer instance of Ownable, bound to a specific deployed contract.

type OwnableRaw 

type OwnableRaw struct {
	Contract *Ownable // Generic contract binding to access the raw methods on
}

OwnableRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*OwnableRaw) Call 

func (_Ownable *OwnableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*OwnableRaw) Transact 

func (_Ownable *OwnableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*OwnableRaw) Transfer 

func (_Ownable *OwnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type OwnableSession 

type OwnableSession struct {
	Contract     *Ownable          // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

OwnableSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*OwnableSession) Owner 

func (_Ownable *OwnableSession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*OwnableSession) TransferOwnership 

func (_Ownable *OwnableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(address newOwner) returns()

type OwnableTransactor 

type OwnableTransactor struct {
	// contains filtered or unexported fields
}

OwnableTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewOwnableTransactor 

func NewOwnableTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableTransactor, error)

NewOwnableTransactor creates a new write-only instance of Ownable, bound to a specific deployed contract.

func (*OwnableTransactor) TransferOwnership 

func (_Ownable *OwnableTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(address newOwner) returns()

type OwnableTransactorRaw 

type OwnableTransactorRaw struct {
	Contract *OwnableTransactor // Generic write-only contract binding to access the raw methods on
}

OwnableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*OwnableTransactorRaw) Transact 

func (_Ownable *OwnableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*OwnableTransactorRaw) Transfer 

func (_Ownable *OwnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type OwnableTransactorSession 

type OwnableTransactorSession struct {
	Contract     *OwnableTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
}

OwnableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*OwnableTransactorSession) TransferOwnership 

func (_Ownable *OwnableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(address newOwner) returns()

type SafeMath 

type SafeMath struct {
	SafeMathCaller     // Read-only binding to the contract
	SafeMathTransactor // Write-only binding to the contract
	SafeMathFilterer   // Log filterer for contract events
}

SafeMath is an auto generated Go binding around an Ethereum contract.

func DeploySafeMath 

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

DeploySafeMath deploys a new Ethereum contract, binding an instance of SafeMath to it.

func NewSafeMath 

func NewSafeMath(address common.Address, backend bind.ContractBackend) (*SafeMath, error)

NewSafeMath creates a new instance of SafeMath, bound to a specific deployed contract.

type SafeMathCaller 

type SafeMathCaller struct {
	// contains filtered or unexported fields
}

SafeMathCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewSafeMathCaller 

func NewSafeMathCaller(address common.Address, caller bind.ContractCaller) (*SafeMathCaller, error)

NewSafeMathCaller creates a new read-only instance of SafeMath, bound to a specific deployed contract.

type SafeMathCallerRaw 

type SafeMathCallerRaw struct {
	Contract *SafeMathCaller // Generic read-only contract binding to access the raw methods on
}

SafeMathCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*SafeMathCallerRaw) Call 

func (_SafeMath *SafeMathCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type SafeMathCallerSession 

type SafeMathCallerSession struct {
	Contract *SafeMathCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts   // Call options to use throughout this session
}

SafeMathCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type SafeMathFilterer 

type SafeMathFilterer struct {
	// contains filtered or unexported fields
}

SafeMathFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewSafeMathFilterer 

func NewSafeMathFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeMathFilterer, error)

NewSafeMathFilterer creates a new log filterer instance of SafeMath, bound to a specific deployed contract.

type SafeMathRaw 

type SafeMathRaw struct {
	Contract *SafeMath // Generic contract binding to access the raw methods on
}

SafeMathRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*SafeMathRaw) Call 

func (_SafeMath *SafeMathRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*SafeMathRaw) Transact 

func (_SafeMath *SafeMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*SafeMathRaw) Transfer 

func (_SafeMath *SafeMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type SafeMathSession 

type SafeMathSession struct {
	Contract     *SafeMath         // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

SafeMathSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type SafeMathTransactor 

type SafeMathTransactor struct {
	// contains filtered or unexported fields
}

SafeMathTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewSafeMathTransactor 

func NewSafeMathTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeMathTransactor, error)

NewSafeMathTransactor creates a new write-only instance of SafeMath, bound to a specific deployed contract.

type SafeMathTransactorRaw 

type SafeMathTransactorRaw struct {
	Contract *SafeMathTransactor // Generic write-only contract binding to access the raw methods on
}

SafeMathTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*SafeMathTransactorRaw) Transact 

func (_SafeMath *SafeMathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*SafeMathTransactorRaw) Transfer 

func (_SafeMath *SafeMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type SafeMathTransactorSession 

type SafeMathTransactorSession struct {
	Contract     *SafeMathTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
}

SafeMathTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type Token 

type Token struct {
	TokenCaller     // Read-only binding to the contract
	TokenTransactor // Write-only binding to the contract
	TokenFilterer   // Log filterer for contract events
}

Token is an auto generated Go binding around an Ethereum contract.

func DeployToken 

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

DeployToken deploys a new Ethereum contract, binding an instance of Token to it.

func NewToken 

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

NewToken creates a new instance of Token, bound to a specific deployed contract.

type TokenApproval 

type TokenApproval struct {
	Owner   common.Address
	Spender common.Address
	Value   *big.Int
	Raw     types.Log // Blockchain specific contextual infos
}

TokenApproval represents a Approval event raised by the Token contract.

type TokenApprovalIterator 

type TokenApprovalIterator struct {
	Event *TokenApproval // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

TokenApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the Token contract.

func (*TokenApprovalIterator) Close 

func (it *TokenApprovalIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*TokenApprovalIterator) Error 

func (it *TokenApprovalIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TokenApprovalIterator) Next 

func (it *TokenApprovalIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type TokenCaller 

type TokenCaller struct {
	// contains filtered or unexported fields
}

TokenCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewTokenCaller 

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

NewTokenCaller creates a new read-only instance of Token, bound to a specific deployed contract.

func (*TokenCaller) Allowance 

func (_Token *TokenCaller) Allowance(opts *bind.CallOpts, _owner common.Address, _spender common.Address) (*big.Int, error)

Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.

Solidity: function allowance(address _owner, address _spender) constant returns(uint256)

func (*TokenCaller) BalanceOf 

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

BalanceOf is a free data retrieval call binding the contract method 0x70a08231.

Solidity: function balanceOf(address _owner) constant returns(uint256)

type TokenCallerRaw 

type TokenCallerRaw struct {
	Contract *TokenCaller // Generic read-only contract binding to access the raw methods on
}

TokenCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*TokenCallerRaw) Call 

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

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type TokenCallerSession 

type TokenCallerSession struct {
	Contract *TokenCaller  // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts // Call options to use throughout this session
}

TokenCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*TokenCallerSession) Allowance 

func (_Token *TokenCallerSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error)

Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.

Solidity: function allowance(address _owner, address _spender) constant returns(uint256)

func (*TokenCallerSession) BalanceOf 

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

BalanceOf is a free data retrieval call binding the contract method 0x70a08231.

Solidity: function balanceOf(address _owner) constant returns(uint256)

type TokenFilterer 

type TokenFilterer struct {
	// contains filtered or unexported fields
}

TokenFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewTokenFilterer 

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

NewTokenFilterer creates a new log filterer instance of Token, bound to a specific deployed contract.

func (*TokenFilterer) FilterApproval 

func (_Token *TokenFilterer) FilterApproval(opts *bind.FilterOpts, _owner []common.Address, _spender []common.Address) (*TokenApprovalIterator, error)

FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.

Solidity: event Approval(address indexed _owner, address indexed _spender, uint256 _value)

func (*TokenFilterer) FilterTransfer 

func (_Token *TokenFilterer) FilterTransfer(opts *bind.FilterOpts, _from []common.Address, _to []common.Address) (*TokenTransferIterator, error)

FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.

Solidity: event Transfer(address indexed _from, address indexed _to, uint256 _value)

func (*TokenFilterer) WatchApproval 

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

WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.

Solidity: event Approval(address indexed _owner, address indexed _spender, uint256 _value)

func (*TokenFilterer) WatchTransfer 

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

WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.

Solidity: event Transfer(address indexed _from, address indexed _to, uint256 _value)

type TokenRaw 

type TokenRaw struct {
	Contract *Token // Generic contract binding to access the raw methods on
}

TokenRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*TokenRaw) Call 

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

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*TokenRaw) Transact 

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

Transact invokes the (paid) contract method with params as input values.

func (*TokenRaw) Transfer 

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

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type TokenSession 

type TokenSession struct {
	Contract     *Token            // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

TokenSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*TokenSession) Allowance 

func (_Token *TokenSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error)

Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.

Solidity: function allowance(address _owner, address _spender) constant returns(uint256)

func (*TokenSession) Approve 

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

Approve is a paid mutator transaction binding the contract method 0x095ea7b3.

Solidity: function approve(address _spender, uint256 _value) returns(bool)

func (*TokenSession) BalanceOf 

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

BalanceOf is a free data retrieval call binding the contract method 0x70a08231.

Solidity: function balanceOf(address _owner) constant returns(uint256)

func (*TokenSession) Transfer 

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

Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.

Solidity: function transfer(address _to, uint256 _value) returns(bool)

func (*TokenSession) TransferFrom 

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

TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.

Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool)

type TokenTransactor 

type TokenTransactor struct {
	// contains filtered or unexported fields
}

TokenTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewTokenTransactor 

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

NewTokenTransactor creates a new write-only instance of Token, bound to a specific deployed contract.

func (*TokenTransactor) Approve 

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

Approve is a paid mutator transaction binding the contract method 0x095ea7b3.

Solidity: function approve(address _spender, uint256 _value) returns(bool)

func (*TokenTransactor) Transfer 

func (_Token *TokenTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (*types.Transaction, error)

Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.

Solidity: function transfer(address _to, uint256 _value) returns(bool)

func (*TokenTransactor) TransferFrom 

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

TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.

Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool)

type TokenTransactorRaw 

type TokenTransactorRaw struct {
	Contract *TokenTransactor // Generic write-only contract binding to access the raw methods on
}

TokenTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*TokenTransactorRaw) Transact 

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

Transact invokes the (paid) contract method with params as input values.

func (*TokenTransactorRaw) Transfer 

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

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type TokenTransactorSession 

type TokenTransactorSession struct {
	Contract     *TokenTransactor  // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

TokenTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*TokenTransactorSession) Approve 

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

Approve is a paid mutator transaction binding the contract method 0x095ea7b3.

Solidity: function approve(address _spender, uint256 _value) returns(bool)

func (*TokenTransactorSession) Transfer 

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

Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.

Solidity: function transfer(address _to, uint256 _value) returns(bool)

func (*TokenTransactorSession) TransferFrom 

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

TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.

Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool)

type TokenTransfer 

type TokenTransfer struct {
	From  common.Address
	To    common.Address
	Value *big.Int
	Raw   types.Log // Blockchain specific contextual infos
}

TokenTransfer represents a Transfer event raised by the Token contract.

type TokenTransferIterator 

type TokenTransferIterator struct {
	Event *TokenTransfer // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

TokenTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the Token contract.

func (*TokenTransferIterator) Close 

func (it *TokenTransferIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*TokenTransferIterator) Error 

func (it *TokenTransferIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TokenTransferIterator) Next 

func (it *TokenTransferIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type TokenTransferProxy 

type TokenTransferProxy struct {
	TokenTransferProxyCaller     // Read-only binding to the contract
	TokenTransferProxyTransactor // Write-only binding to the contract
	TokenTransferProxyFilterer   // Log filterer for contract events
}

TokenTransferProxy is an auto generated Go binding around an Ethereum contract.

func DeployTokenTransferProxy 

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

DeployTokenTransferProxy deploys a new Ethereum contract, binding an instance of TokenTransferProxy to it.

func NewTokenTransferProxy 

func NewTokenTransferProxy(address common.Address, backend bind.ContractBackend) (*TokenTransferProxy, error)

NewTokenTransferProxy creates a new instance of TokenTransferProxy, bound to a specific deployed contract.

type TokenTransferProxyCaller 

type TokenTransferProxyCaller struct {
	// contains filtered or unexported fields
}

TokenTransferProxyCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewTokenTransferProxyCaller 

func NewTokenTransferProxyCaller(address common.Address, caller bind.ContractCaller) (*TokenTransferProxyCaller, error)

NewTokenTransferProxyCaller creates a new read-only instance of TokenTransferProxy, bound to a specific deployed contract.

func (*TokenTransferProxyCaller) Authorities 

func (_TokenTransferProxy *TokenTransferProxyCaller) Authorities(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error)

Authorities is a free data retrieval call binding the contract method 0x494503d4.

Solidity: function authorities(uint256 ) constant returns(address)

func (*TokenTransferProxyCaller) Authorized 

func (_TokenTransferProxy *TokenTransferProxyCaller) Authorized(opts *bind.CallOpts, arg0 common.Address) (bool, error)

Authorized is a free data retrieval call binding the contract method 0xb9181611.

Solidity: function authorized(address ) constant returns(bool)

func (*TokenTransferProxyCaller) GetAuthorizedAddresses 

func (_TokenTransferProxy *TokenTransferProxyCaller) GetAuthorizedAddresses(opts *bind.CallOpts) ([]common.Address, error)

GetAuthorizedAddresses is a free data retrieval call binding the contract method 0xd39de6e9.

Solidity: function getAuthorizedAddresses() constant returns(address[])

func (*TokenTransferProxyCaller) Owner 

func (_TokenTransferProxy *TokenTransferProxyCaller) Owner(opts *bind.CallOpts) (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

type TokenTransferProxyCallerRaw 

type TokenTransferProxyCallerRaw struct {
	Contract *TokenTransferProxyCaller // Generic read-only contract binding to access the raw methods on
}

TokenTransferProxyCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*TokenTransferProxyCallerRaw) Call 

func (_TokenTransferProxy *TokenTransferProxyCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type TokenTransferProxyCallerSession 

type TokenTransferProxyCallerSession struct {
	Contract *TokenTransferProxyCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts             // Call options to use throughout this session
}

TokenTransferProxyCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*TokenTransferProxyCallerSession) Authorities 

func (_TokenTransferProxy *TokenTransferProxyCallerSession) Authorities(arg0 *big.Int) (common.Address, error)

Authorities is a free data retrieval call binding the contract method 0x494503d4.

Solidity: function authorities(uint256 ) constant returns(address)

func (*TokenTransferProxyCallerSession) Authorized 

func (_TokenTransferProxy *TokenTransferProxyCallerSession) Authorized(arg0 common.Address) (bool, error)

Authorized is a free data retrieval call binding the contract method 0xb9181611.

Solidity: function authorized(address ) constant returns(bool)

func (*TokenTransferProxyCallerSession) GetAuthorizedAddresses 

func (_TokenTransferProxy *TokenTransferProxyCallerSession) GetAuthorizedAddresses() ([]common.Address, error)

GetAuthorizedAddresses is a free data retrieval call binding the contract method 0xd39de6e9.

Solidity: function getAuthorizedAddresses() constant returns(address[])

func (*TokenTransferProxyCallerSession) Owner 

func (_TokenTransferProxy *TokenTransferProxyCallerSession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

type TokenTransferProxyFilterer 

type TokenTransferProxyFilterer struct {
	// contains filtered or unexported fields
}

TokenTransferProxyFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewTokenTransferProxyFilterer 

func NewTokenTransferProxyFilterer(address common.Address, filterer bind.ContractFilterer) (*TokenTransferProxyFilterer, error)

NewTokenTransferProxyFilterer creates a new log filterer instance of TokenTransferProxy, bound to a specific deployed contract.

func (*TokenTransferProxyFilterer) FilterLogAuthorizedAddressAdded 

func (_TokenTransferProxy *TokenTransferProxyFilterer) FilterLogAuthorizedAddressAdded(opts *bind.FilterOpts, target []common.Address, caller []common.Address) (*TokenTransferProxyLogAuthorizedAddressAddedIterator, error)

FilterLogAuthorizedAddressAdded is a free log retrieval operation binding the contract event 0x94bb87f4c15c4587ff559a7584006fa01ddf9299359be6b512b94527aa961aca.

Solidity: event LogAuthorizedAddressAdded(address indexed target, address indexed caller)

func (*TokenTransferProxyFilterer) FilterLogAuthorizedAddressRemoved 

func (_TokenTransferProxy *TokenTransferProxyFilterer) FilterLogAuthorizedAddressRemoved(opts *bind.FilterOpts, target []common.Address, caller []common.Address) (*TokenTransferProxyLogAuthorizedAddressRemovedIterator, error)

FilterLogAuthorizedAddressRemoved is a free log retrieval operation binding the contract event 0xf5b347a1e40749dd050f5f07fbdbeb7e3efa9756903044dd29401fd1d4bb4a1c.

Solidity: event LogAuthorizedAddressRemoved(address indexed target, address indexed caller)

func (*TokenTransferProxyFilterer) WatchLogAuthorizedAddressAdded 

func (_TokenTransferProxy *TokenTransferProxyFilterer) WatchLogAuthorizedAddressAdded(opts *bind.WatchOpts, sink chan<- *TokenTransferProxyLogAuthorizedAddressAdded, target []common.Address, caller []common.Address) (event.Subscription, error)

WatchLogAuthorizedAddressAdded is a free log subscription operation binding the contract event 0x94bb87f4c15c4587ff559a7584006fa01ddf9299359be6b512b94527aa961aca.

Solidity: event LogAuthorizedAddressAdded(address indexed target, address indexed caller)

func (*TokenTransferProxyFilterer) WatchLogAuthorizedAddressRemoved 

func (_TokenTransferProxy *TokenTransferProxyFilterer) WatchLogAuthorizedAddressRemoved(opts *bind.WatchOpts, sink chan<- *TokenTransferProxyLogAuthorizedAddressRemoved, target []common.Address, caller []common.Address) (event.Subscription, error)

WatchLogAuthorizedAddressRemoved is a free log subscription operation binding the contract event 0xf5b347a1e40749dd050f5f07fbdbeb7e3efa9756903044dd29401fd1d4bb4a1c.

Solidity: event LogAuthorizedAddressRemoved(address indexed target, address indexed caller)

type TokenTransferProxyLogAuthorizedAddressAdded 

type TokenTransferProxyLogAuthorizedAddressAdded struct {
	Target common.Address
	Caller common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

TokenTransferProxyLogAuthorizedAddressAdded represents a LogAuthorizedAddressAdded event raised by the TokenTransferProxy contract.

type TokenTransferProxyLogAuthorizedAddressAddedIterator 

type TokenTransferProxyLogAuthorizedAddressAddedIterator struct {
	Event *TokenTransferProxyLogAuthorizedAddressAdded // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

TokenTransferProxyLogAuthorizedAddressAddedIterator is returned from FilterLogAuthorizedAddressAdded and is used to iterate over the raw logs and unpacked data for LogAuthorizedAddressAdded events raised by the TokenTransferProxy contract.

func (*TokenTransferProxyLogAuthorizedAddressAddedIterator) Close 

func (it *TokenTransferProxyLogAuthorizedAddressAddedIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*TokenTransferProxyLogAuthorizedAddressAddedIterator) Error 

func (it *TokenTransferProxyLogAuthorizedAddressAddedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TokenTransferProxyLogAuthorizedAddressAddedIterator) Next 

func (it *TokenTransferProxyLogAuthorizedAddressAddedIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type TokenTransferProxyLogAuthorizedAddressRemoved 

type TokenTransferProxyLogAuthorizedAddressRemoved struct {
	Target common.Address
	Caller common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

TokenTransferProxyLogAuthorizedAddressRemoved represents a LogAuthorizedAddressRemoved event raised by the TokenTransferProxy contract.

type TokenTransferProxyLogAuthorizedAddressRemovedIterator 

type TokenTransferProxyLogAuthorizedAddressRemovedIterator struct {
	Event *TokenTransferProxyLogAuthorizedAddressRemoved // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

TokenTransferProxyLogAuthorizedAddressRemovedIterator is returned from FilterLogAuthorizedAddressRemoved and is used to iterate over the raw logs and unpacked data for LogAuthorizedAddressRemoved events raised by the TokenTransferProxy contract.

func (*TokenTransferProxyLogAuthorizedAddressRemovedIterator) Close 

func (it *TokenTransferProxyLogAuthorizedAddressRemovedIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*TokenTransferProxyLogAuthorizedAddressRemovedIterator) Error 

func (it *TokenTransferProxyLogAuthorizedAddressRemovedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TokenTransferProxyLogAuthorizedAddressRemovedIterator) Next 

func (it *TokenTransferProxyLogAuthorizedAddressRemovedIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type TokenTransferProxyRaw 

type TokenTransferProxyRaw struct {
	Contract *TokenTransferProxy // Generic contract binding to access the raw methods on
}

TokenTransferProxyRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*TokenTransferProxyRaw) Call 

func (_TokenTransferProxy *TokenTransferProxyRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*TokenTransferProxyRaw) Transact 

func (_TokenTransferProxy *TokenTransferProxyRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*TokenTransferProxyRaw) Transfer 

func (_TokenTransferProxy *TokenTransferProxyRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type TokenTransferProxySession 

type TokenTransferProxySession struct {
	Contract     *TokenTransferProxy // Generic contract binding to set the session for
	CallOpts     bind.CallOpts       // Call options to use throughout this session
	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
}

TokenTransferProxySession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*TokenTransferProxySession) AddAuthorizedAddress 

func (_TokenTransferProxy *TokenTransferProxySession) AddAuthorizedAddress(target common.Address) (*types.Transaction, error)

AddAuthorizedAddress is a paid mutator transaction binding the contract method 0x42f1181e.

Solidity: function addAuthorizedAddress(address target) returns()

func (*TokenTransferProxySession) Authorities 

func (_TokenTransferProxy *TokenTransferProxySession) Authorities(arg0 *big.Int) (common.Address, error)

Authorities is a free data retrieval call binding the contract method 0x494503d4.

Solidity: function authorities(uint256 ) constant returns(address)

func (*TokenTransferProxySession) Authorized 

func (_TokenTransferProxy *TokenTransferProxySession) Authorized(arg0 common.Address) (bool, error)

Authorized is a free data retrieval call binding the contract method 0xb9181611.

Solidity: function authorized(address ) constant returns(bool)

func (*TokenTransferProxySession) GetAuthorizedAddresses 

func (_TokenTransferProxy *TokenTransferProxySession) GetAuthorizedAddresses() ([]common.Address, error)

GetAuthorizedAddresses is a free data retrieval call binding the contract method 0xd39de6e9.

Solidity: function getAuthorizedAddresses() constant returns(address[])

func (*TokenTransferProxySession) Owner 

func (_TokenTransferProxy *TokenTransferProxySession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*TokenTransferProxySession) RemoveAuthorizedAddress 

func (_TokenTransferProxy *TokenTransferProxySession) RemoveAuthorizedAddress(target common.Address) (*types.Transaction, error)

RemoveAuthorizedAddress is a paid mutator transaction binding the contract method 0x70712939.

Solidity: function removeAuthorizedAddress(address target) returns()

func (*TokenTransferProxySession) TransferFrom 

func (_TokenTransferProxy *TokenTransferProxySession) TransferFrom(token common.Address, from common.Address, to common.Address, value *big.Int) (*types.Transaction, error)

TransferFrom is a paid mutator transaction binding the contract method 0x15dacbea.

Solidity: function transferFrom(address token, address from, address to, uint256 value) returns(bool)

func (*TokenTransferProxySession) TransferOwnership 

func (_TokenTransferProxy *TokenTransferProxySession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(address newOwner) returns()

type TokenTransferProxyTransactor 

type TokenTransferProxyTransactor struct {
	// contains filtered or unexported fields
}

TokenTransferProxyTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewTokenTransferProxyTransactor 

func NewTokenTransferProxyTransactor(address common.Address, transactor bind.ContractTransactor) (*TokenTransferProxyTransactor, error)

NewTokenTransferProxyTransactor creates a new write-only instance of TokenTransferProxy, bound to a specific deployed contract.

func (*TokenTransferProxyTransactor) AddAuthorizedAddress 

func (_TokenTransferProxy *TokenTransferProxyTransactor) AddAuthorizedAddress(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error)

AddAuthorizedAddress is a paid mutator transaction binding the contract method 0x42f1181e.

Solidity: function addAuthorizedAddress(address target) returns()

func (*TokenTransferProxyTransactor) RemoveAuthorizedAddress 

func (_TokenTransferProxy *TokenTransferProxyTransactor) RemoveAuthorizedAddress(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error)

RemoveAuthorizedAddress is a paid mutator transaction binding the contract method 0x70712939.

Solidity: function removeAuthorizedAddress(address target) returns()

func (*TokenTransferProxyTransactor) TransferFrom 

func (_TokenTransferProxy *TokenTransferProxyTransactor) TransferFrom(opts *bind.TransactOpts, token common.Address, from common.Address, to common.Address, value *big.Int) (*types.Transaction, error)

TransferFrom is a paid mutator transaction binding the contract method 0x15dacbea.

Solidity: function transferFrom(address token, address from, address to, uint256 value) returns(bool)

func (*TokenTransferProxyTransactor) TransferOwnership 

func (_TokenTransferProxy *TokenTransferProxyTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(address newOwner) returns()

type TokenTransferProxyTransactorRaw 

type TokenTransferProxyTransactorRaw struct {
	Contract *TokenTransferProxyTransactor // Generic write-only contract binding to access the raw methods on
}

TokenTransferProxyTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*TokenTransferProxyTransactorRaw) Transact 

func (_TokenTransferProxy *TokenTransferProxyTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*TokenTransferProxyTransactorRaw) Transfer 

func (_TokenTransferProxy *TokenTransferProxyTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type TokenTransferProxyTransactorSession 

type TokenTransferProxyTransactorSession struct {
	Contract     *TokenTransferProxyTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts             // Transaction auth options to use throughout this session
}

TokenTransferProxyTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*TokenTransferProxyTransactorSession) AddAuthorizedAddress 

func (_TokenTransferProxy *TokenTransferProxyTransactorSession) AddAuthorizedAddress(target common.Address) (*types.Transaction, error)

AddAuthorizedAddress is a paid mutator transaction binding the contract method 0x42f1181e.

Solidity: function addAuthorizedAddress(address target) returns()

func (*TokenTransferProxyTransactorSession) RemoveAuthorizedAddress 

func (_TokenTransferProxy *TokenTransferProxyTransactorSession) RemoveAuthorizedAddress(target common.Address) (*types.Transaction, error)

RemoveAuthorizedAddress is a paid mutator transaction binding the contract method 0x70712939.

Solidity: function removeAuthorizedAddress(address target) returns()

func (*TokenTransferProxyTransactorSession) TransferFrom 

func (_TokenTransferProxy *TokenTransferProxyTransactorSession) TransferFrom(token common.Address, from common.Address, to common.Address, value *big.Int) (*types.Transaction, error)

TransferFrom is a paid mutator transaction binding the contract method 0x15dacbea.

Solidity: function transferFrom(address token, address from, address to, uint256 value) returns(bool)

func (*TokenTransferProxyTransactorSession) TransferOwnership 

func (_TokenTransferProxy *TokenTransferProxyTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(address newOwner) returns()

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.