mocks

package
v2.3.1 Latest Latest
Warning

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

 Go to latest Published: Jan 7, 2020 License: GPL-2.0, GPL-3.0 Imports: 8 Imported by: 0

Documentation

Index

Constants

View Source 
const Base64ExporterABI = "" /* 275-byte string literal not displayed */

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

View Source 
const BurnerTokenABI = "" /* 5494-byte string literal not displayed */

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

View Source 
const BytesUtilsExporterABI = "" /* 1039-byte string literal not displayed */

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

View Source 
const IsValidSignatureExporterABI = "" /* 516-byte string literal not displayed */

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

View Source 
const NonCompliantTokenABI = "" /* 3065-byte string literal not displayed */

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

View Source 
const OraclizeAddrResolverABI = "" /* 384-byte string literal not displayed */

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

View Source 
const OraclizeConnectorABI = "" /* 2600-byte string literal not displayed */

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

View Source 
const ParseIntScientificExporterABI = "" /* 920-byte string literal not displayed */

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

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

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

View Source 
const TokenWhitelistableExporterABI = "" /* 3979-byte string literal not displayed */

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

Variables

View Source 
var Base64ExporterBin = "" /* 4246-byte string literal not displayed */

Base64ExporterBin is the compiled bytecode used for deploying new contracts.

View Source 
var BurnerTokenBin = "" /* 6706-byte string literal not displayed */

BurnerTokenBin is the compiled bytecode used for deploying new contracts.

View Source 
var BytesUtilsExporterBin = "" /* 2346-byte string literal not displayed */

BytesUtilsExporterBin is the compiled bytecode used for deploying new contracts.

View Source 
var IsValidSignatureExporterBin = "" /* 1288-byte string literal not displayed */

IsValidSignatureExporterBin is the compiled bytecode used for deploying new contracts.

View Source 
var NonCompliantTokenBin = "" /* 3192-byte string literal not displayed */

NonCompliantTokenBin is the compiled bytecode used for deploying new contracts.

View Source 
var OraclizeAddrResolverBin = "" /* 496-byte string literal not displayed */

OraclizeAddrResolverBin is the compiled bytecode used for deploying new contracts.

View Source 
var OraclizeConnectorBin = "" /* 3286-byte string literal not displayed */

OraclizeConnectorBin is the compiled bytecode used for deploying new contracts.

View Source 
var ParseIntScientificExporterBin = "" /* 6434-byte string literal not displayed */

ParseIntScientificExporterBin is the compiled bytecode used for deploying new contracts.

View Source 
var TokenBin = "" /* 3124-byte string literal not displayed */

TokenBin is the compiled bytecode used for deploying new contracts.

View Source 
var TokenWhitelistableExporterBin = "" /* 6358-byte string literal not displayed */

TokenWhitelistableExporterBin is the compiled bytecode used for deploying new contracts.

Functions

This section is empty.

Types

type Base64Exporter 

type Base64Exporter struct {
	Base64ExporterCaller     // Read-only binding to the contract
	Base64ExporterTransactor // Write-only binding to the contract
	Base64ExporterFilterer   // Log filterer for contract events
}

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

func DeployBase64Exporter 

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

DeployBase64Exporter deploys a new Ethereum contract, binding an instance of Base64Exporter to it.

func NewBase64Exporter 

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

NewBase64Exporter creates a new instance of Base64Exporter, bound to a specific deployed contract.

type Base64ExporterCaller 

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

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

func NewBase64ExporterCaller 

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

NewBase64ExporterCaller creates a new read-only instance of Base64Exporter, bound to a specific deployed contract.

func (*Base64ExporterCaller) Base64decode 

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

Base64decode is a free data retrieval call binding the contract method 0x3a718bfb.

Solidity: function base64decode(bytes _encoded) constant returns(bytes)

type Base64ExporterCallerRaw 

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

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

func (*Base64ExporterCallerRaw) Call 

func (_Base64Exporter *Base64ExporterCallerRaw) 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 Base64ExporterCallerSession 

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

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

func (*Base64ExporterCallerSession) Base64decode 

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

Base64decode is a free data retrieval call binding the contract method 0x3a718bfb.

Solidity: function base64decode(bytes _encoded) constant returns(bytes)

type Base64ExporterFilterer 

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

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

func NewBase64ExporterFilterer 

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

NewBase64ExporterFilterer creates a new log filterer instance of Base64Exporter, bound to a specific deployed contract.

type Base64ExporterRaw 

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

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

func (*Base64ExporterRaw) Call 

func (_Base64Exporter *Base64ExporterRaw) 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 (*Base64ExporterRaw) Transact 

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

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

func (*Base64ExporterRaw) Transfer 

func (_Base64Exporter *Base64ExporterRaw) 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 Base64ExporterSession 

type Base64ExporterSession struct {
	Contract     *Base64Exporter   // 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
}

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

func (*Base64ExporterSession) Base64decode 

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

Base64decode is a free data retrieval call binding the contract method 0x3a718bfb.

Solidity: function base64decode(bytes _encoded) constant returns(bytes)

type Base64ExporterTransactor 

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

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

func NewBase64ExporterTransactor 

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

NewBase64ExporterTransactor creates a new write-only instance of Base64Exporter, bound to a specific deployed contract.

type Base64ExporterTransactorRaw 

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

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

func (*Base64ExporterTransactorRaw) Transact 

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

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

func (*Base64ExporterTransactorRaw) Transfer 

func (_Base64Exporter *Base64ExporterTransactorRaw) 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 Base64ExporterTransactorSession 

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

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

type BurnerToken 

type BurnerToken struct {
	BurnerTokenCaller     // Read-only binding to the contract
	BurnerTokenTransactor // Write-only binding to the contract
	BurnerTokenFilterer   // Log filterer for contract events
}

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

func DeployBurnerToken 

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

DeployBurnerToken deploys a new Ethereum contract, binding an instance of BurnerToken to it.

func NewBurnerToken 

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

NewBurnerToken creates a new instance of BurnerToken, bound to a specific deployed contract.

type BurnerTokenApproval 

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

BurnerTokenApproval represents a Approval event raised by the BurnerToken contract.

type BurnerTokenApprovalIterator 

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

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

func (*BurnerTokenApprovalIterator) Close 

func (it *BurnerTokenApprovalIterator) Close() error

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

func (*BurnerTokenApprovalIterator) Error 

func (it *BurnerTokenApprovalIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*BurnerTokenApprovalIterator) Next 

func (it *BurnerTokenApprovalIterator) 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 BurnerTokenCaller 

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

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

func NewBurnerTokenCaller 

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

NewBurnerTokenCaller creates a new read-only instance of BurnerToken, bound to a specific deployed contract.

func (*BurnerTokenCaller) Allowance 

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

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

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

func (*BurnerTokenCaller) BalanceOf 

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

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

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

func (*BurnerTokenCaller) CurrentSupply 

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

CurrentSupply is a free data retrieval call binding the contract method 0x771282f6.

Solidity: function currentSupply() constant returns(uint256)

func (*BurnerTokenCaller) Decimals 

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

Decimals is a free data retrieval call binding the contract method 0x313ce567.

Solidity: function decimals() constant returns(uint8)

func (*BurnerTokenCaller) Name 

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

Name is a free data retrieval call binding the contract method 0x06fdde03.

Solidity: function name() constant returns(string)

func (*BurnerTokenCaller) Owner 

func (_BurnerToken *BurnerTokenCaller) 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)

func (*BurnerTokenCaller) Symbol 

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

Symbol is a free data retrieval call binding the contract method 0x95d89b41.

Solidity: function symbol() constant returns(string)

func (*BurnerTokenCaller) Tokenholder 

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

Tokenholder is a free data retrieval call binding the contract method 0x84eba00c.

Solidity: function tokenholder() constant returns(address)

func (*BurnerTokenCaller) TotalSupply 

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

TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.

Solidity: function totalSupply() constant returns(uint256)

type BurnerTokenCallerRaw 

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

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

func (*BurnerTokenCallerRaw) Call 

func (_BurnerToken *BurnerTokenCallerRaw) 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 BurnerTokenCallerSession 

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

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

func (*BurnerTokenCallerSession) Allowance 

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

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

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

func (*BurnerTokenCallerSession) BalanceOf 

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

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

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

func (*BurnerTokenCallerSession) CurrentSupply 

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

CurrentSupply is a free data retrieval call binding the contract method 0x771282f6.

Solidity: function currentSupply() constant returns(uint256)

func (*BurnerTokenCallerSession) Decimals 

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

Decimals is a free data retrieval call binding the contract method 0x313ce567.

Solidity: function decimals() constant returns(uint8)

func (*BurnerTokenCallerSession) Name 

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

Name is a free data retrieval call binding the contract method 0x06fdde03.

Solidity: function name() constant returns(string)

func (*BurnerTokenCallerSession) Owner 

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

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

Solidity: function owner() constant returns(address)

func (*BurnerTokenCallerSession) Symbol 

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

Symbol is a free data retrieval call binding the contract method 0x95d89b41.

Solidity: function symbol() constant returns(string)

func (*BurnerTokenCallerSession) Tokenholder 

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

Tokenholder is a free data retrieval call binding the contract method 0x84eba00c.

Solidity: function tokenholder() constant returns(address)

func (*BurnerTokenCallerSession) TotalSupply 

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

TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.

Solidity: function totalSupply() constant returns(uint256)

type BurnerTokenFilterer 

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

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

func NewBurnerTokenFilterer 

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

NewBurnerTokenFilterer creates a new log filterer instance of BurnerToken, bound to a specific deployed contract.

func (*BurnerTokenFilterer) FilterApproval 

func (_BurnerToken *BurnerTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*BurnerTokenApprovalIterator, 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 (*BurnerTokenFilterer) FilterTransfer 

func (_BurnerToken *BurnerTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*BurnerTokenTransferIterator, 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 (*BurnerTokenFilterer) ParseApproval added in v2.3.0 

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

ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.

Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)

func (*BurnerTokenFilterer) ParseTransfer added in v2.3.0 

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

ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.

Solidity: event Transfer(address indexed from, address indexed to, uint256 value)

func (*BurnerTokenFilterer) WatchApproval 

func (_BurnerToken *BurnerTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *BurnerTokenApproval, 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 (*BurnerTokenFilterer) WatchTransfer 

func (_BurnerToken *BurnerTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *BurnerTokenTransfer, 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 BurnerTokenRaw 

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

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

func (*BurnerTokenRaw) Call 

func (_BurnerToken *BurnerTokenRaw) 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 (*BurnerTokenRaw) Transact 

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

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

func (*BurnerTokenRaw) Transfer 

func (_BurnerToken *BurnerTokenRaw) 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 BurnerTokenSession 

type BurnerTokenSession struct {
	Contract     *BurnerToken      // 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
}

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

func (*BurnerTokenSession) Allowance 

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

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

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

func (*BurnerTokenSession) Approve 

func (_BurnerToken *BurnerTokenSession) 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 success)

func (*BurnerTokenSession) BalanceOf 

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

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

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

func (*BurnerTokenSession) Burn 

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

Burn is a paid mutator transaction binding the contract method 0x42966c68.

Solidity: function burn(uint256 _amount) returns(bool result)

func (*BurnerTokenSession) CurrentSupply 

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

CurrentSupply is a free data retrieval call binding the contract method 0x771282f6.

Solidity: function currentSupply() constant returns(uint256)

func (*BurnerTokenSession) Decimals 

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

Decimals is a free data retrieval call binding the contract method 0x313ce567.

Solidity: function decimals() constant returns(uint8)

func (*BurnerTokenSession) DecreaseApproval 

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

DecreaseApproval is a paid mutator transaction binding the contract method 0x66188463.

Solidity: function decreaseApproval(address _spender, uint256 _subtractedValue) returns(bool success)

func (*BurnerTokenSession) IncreaseApproval 

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

IncreaseApproval is a paid mutator transaction binding the contract method 0xd73dd623.

Solidity: function increaseApproval(address _spender, uint256 _addedValue) returns(bool success)

func (*BurnerTokenSession) Mint 

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

Mint is a paid mutator transaction binding the contract method 0x40c10f19.

Solidity: function mint(address addr, uint256 amount) returns()

func (*BurnerTokenSession) Name 

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

Name is a free data retrieval call binding the contract method 0x06fdde03.

Solidity: function name() constant returns(string)

func (*BurnerTokenSession) Owner 

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

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

Solidity: function owner() constant returns(address)

func (*BurnerTokenSession) SetTokenHolder 

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

SetTokenHolder is a paid mutator transaction binding the contract method 0xf29d2f28.

Solidity: function setTokenHolder(address _th) returns()

func (*BurnerTokenSession) Symbol 

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

Symbol is a free data retrieval call binding the contract method 0x95d89b41.

Solidity: function symbol() constant returns(string)

func (*BurnerTokenSession) Tokenholder 

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

Tokenholder is a free data retrieval call binding the contract method 0x84eba00c.

Solidity: function tokenholder() constant returns(address)

func (*BurnerTokenSession) TotalSupply 

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

TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.

Solidity: function totalSupply() constant returns(uint256)

func (*BurnerTokenSession) Transfer 

func (_BurnerToken *BurnerTokenSession) 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 success)

func (*BurnerTokenSession) TransferFrom 

func (_BurnerToken *BurnerTokenSession) 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 success)

type BurnerTokenTransactor 

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

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

func NewBurnerTokenTransactor 

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

NewBurnerTokenTransactor creates a new write-only instance of BurnerToken, bound to a specific deployed contract.

func (*BurnerTokenTransactor) Approve 

func (_BurnerToken *BurnerTokenTransactor) 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 success)

func (*BurnerTokenTransactor) Burn 

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

Burn is a paid mutator transaction binding the contract method 0x42966c68.

Solidity: function burn(uint256 _amount) returns(bool result)

func (*BurnerTokenTransactor) DecreaseApproval 

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

DecreaseApproval is a paid mutator transaction binding the contract method 0x66188463.

Solidity: function decreaseApproval(address _spender, uint256 _subtractedValue) returns(bool success)

func (*BurnerTokenTransactor) IncreaseApproval 

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

IncreaseApproval is a paid mutator transaction binding the contract method 0xd73dd623.

Solidity: function increaseApproval(address _spender, uint256 _addedValue) returns(bool success)

func (*BurnerTokenTransactor) Mint 

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

Mint is a paid mutator transaction binding the contract method 0x40c10f19.

Solidity: function mint(address addr, uint256 amount) returns()

func (*BurnerTokenTransactor) SetTokenHolder 

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

SetTokenHolder is a paid mutator transaction binding the contract method 0xf29d2f28.

Solidity: function setTokenHolder(address _th) returns()

func (*BurnerTokenTransactor) Transfer 

func (_BurnerToken *BurnerTokenTransactor) 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 success)

func (*BurnerTokenTransactor) TransferFrom 

func (_BurnerToken *BurnerTokenTransactor) 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 success)

type BurnerTokenTransactorRaw 

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

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

func (*BurnerTokenTransactorRaw) Transact 

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

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

func (*BurnerTokenTransactorRaw) Transfer 

func (_BurnerToken *BurnerTokenTransactorRaw) 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 BurnerTokenTransactorSession 

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

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

func (*BurnerTokenTransactorSession) Approve 

func (_BurnerToken *BurnerTokenTransactorSession) 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 success)

func (*BurnerTokenTransactorSession) Burn 

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

Burn is a paid mutator transaction binding the contract method 0x42966c68.

Solidity: function burn(uint256 _amount) returns(bool result)

func (*BurnerTokenTransactorSession) DecreaseApproval 

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

DecreaseApproval is a paid mutator transaction binding the contract method 0x66188463.

Solidity: function decreaseApproval(address _spender, uint256 _subtractedValue) returns(bool success)

func (*BurnerTokenTransactorSession) IncreaseApproval 

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

IncreaseApproval is a paid mutator transaction binding the contract method 0xd73dd623.

Solidity: function increaseApproval(address _spender, uint256 _addedValue) returns(bool success)

func (*BurnerTokenTransactorSession) Mint 

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

Mint is a paid mutator transaction binding the contract method 0x40c10f19.

Solidity: function mint(address addr, uint256 amount) returns()

func (*BurnerTokenTransactorSession) SetTokenHolder 

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

SetTokenHolder is a paid mutator transaction binding the contract method 0xf29d2f28.

Solidity: function setTokenHolder(address _th) returns()

func (*BurnerTokenTransactorSession) Transfer 

func (_BurnerToken *BurnerTokenTransactorSession) 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 success)

func (*BurnerTokenTransactorSession) TransferFrom 

func (_BurnerToken *BurnerTokenTransactorSession) 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 success)

type BurnerTokenTransfer 

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

BurnerTokenTransfer represents a Transfer event raised by the BurnerToken contract.

type BurnerTokenTransferIterator 

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

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

func (*BurnerTokenTransferIterator) Close 

func (it *BurnerTokenTransferIterator) Close() error

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

func (*BurnerTokenTransferIterator) Error 

func (it *BurnerTokenTransferIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*BurnerTokenTransferIterator) Next 

func (it *BurnerTokenTransferIterator) 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 BytesUtilsExporter 

type BytesUtilsExporter struct {
	BytesUtilsExporterCaller     // Read-only binding to the contract
	BytesUtilsExporterTransactor // Write-only binding to the contract
	BytesUtilsExporterFilterer   // Log filterer for contract events
}

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

func DeployBytesUtilsExporter 

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

DeployBytesUtilsExporter deploys a new Ethereum contract, binding an instance of BytesUtilsExporter to it.

func NewBytesUtilsExporter 

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

NewBytesUtilsExporter creates a new instance of BytesUtilsExporter, bound to a specific deployed contract.

type BytesUtilsExporterCaller 

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

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

func NewBytesUtilsExporterCaller 

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

NewBytesUtilsExporterCaller creates a new read-only instance of BytesUtilsExporter, bound to a specific deployed contract.

func (*BytesUtilsExporterCaller) BytesToAddress 

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

BytesToAddress is a free data retrieval call binding the contract method 0x0638c0f4.

Solidity: function bytesToAddress(bytes _bts, uint256 _from) constant returns(address)

func (*BytesUtilsExporterCaller) BytesToBytes4 

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

BytesToBytes4 is a free data retrieval call binding the contract method 0xcbd85c76.

Solidity: function bytesToBytes4(bytes _bts, uint256 _from) constant returns(bytes4)

func (*BytesUtilsExporterCaller) BytesToUint256 

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

BytesToUint256 is a free data retrieval call binding the contract method 0x55f94ce0.

Solidity: function bytesToUint256(bytes _bts, uint256 _from) constant returns(uint256)

type BytesUtilsExporterCallerRaw 

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

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

func (*BytesUtilsExporterCallerRaw) Call 

func (_BytesUtilsExporter *BytesUtilsExporterCallerRaw) 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 BytesUtilsExporterCallerSession 

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

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

func (*BytesUtilsExporterCallerSession) BytesToAddress 

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

BytesToAddress is a free data retrieval call binding the contract method 0x0638c0f4.

Solidity: function bytesToAddress(bytes _bts, uint256 _from) constant returns(address)

func (*BytesUtilsExporterCallerSession) BytesToBytes4 

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

BytesToBytes4 is a free data retrieval call binding the contract method 0xcbd85c76.

Solidity: function bytesToBytes4(bytes _bts, uint256 _from) constant returns(bytes4)

func (*BytesUtilsExporterCallerSession) BytesToUint256 

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

BytesToUint256 is a free data retrieval call binding the contract method 0x55f94ce0.

Solidity: function bytesToUint256(bytes _bts, uint256 _from) constant returns(uint256)

type BytesUtilsExporterFilterer 

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

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

func NewBytesUtilsExporterFilterer 

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

NewBytesUtilsExporterFilterer creates a new log filterer instance of BytesUtilsExporter, bound to a specific deployed contract.

type BytesUtilsExporterRaw 

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

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

func (*BytesUtilsExporterRaw) Call 

func (_BytesUtilsExporter *BytesUtilsExporterRaw) 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 (*BytesUtilsExporterRaw) Transact 

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

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

func (*BytesUtilsExporterRaw) Transfer 

func (_BytesUtilsExporter *BytesUtilsExporterRaw) 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 BytesUtilsExporterSession 

type BytesUtilsExporterSession struct {
	Contract     *BytesUtilsExporter // 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
}

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

func (*BytesUtilsExporterSession) BytesToAddress 

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

BytesToAddress is a free data retrieval call binding the contract method 0x0638c0f4.

Solidity: function bytesToAddress(bytes _bts, uint256 _from) constant returns(address)

func (*BytesUtilsExporterSession) BytesToBytes4 

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

BytesToBytes4 is a free data retrieval call binding the contract method 0xcbd85c76.

Solidity: function bytesToBytes4(bytes _bts, uint256 _from) constant returns(bytes4)

func (*BytesUtilsExporterSession) BytesToUint256 

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

BytesToUint256 is a free data retrieval call binding the contract method 0x55f94ce0.

Solidity: function bytesToUint256(bytes _bts, uint256 _from) constant returns(uint256)

type BytesUtilsExporterTransactor 

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

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

func NewBytesUtilsExporterTransactor 

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

NewBytesUtilsExporterTransactor creates a new write-only instance of BytesUtilsExporter, bound to a specific deployed contract.

type BytesUtilsExporterTransactorRaw 

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

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

func (*BytesUtilsExporterTransactorRaw) Transact 

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

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

func (*BytesUtilsExporterTransactorRaw) Transfer 

func (_BytesUtilsExporter *BytesUtilsExporterTransactorRaw) 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 BytesUtilsExporterTransactorSession 

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

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

type IsValidSignatureExporter added in v2.3.1 

type IsValidSignatureExporter struct {
	IsValidSignatureExporterCaller     // Read-only binding to the contract
	IsValidSignatureExporterTransactor // Write-only binding to the contract
	IsValidSignatureExporterFilterer   // Log filterer for contract events
}

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

func DeployIsValidSignatureExporter added in v2.3.1 

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

DeployIsValidSignatureExporter deploys a new Ethereum contract, binding an instance of IsValidSignatureExporter to it.

func NewIsValidSignatureExporter added in v2.3.1 

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

NewIsValidSignatureExporter creates a new instance of IsValidSignatureExporter, bound to a specific deployed contract.

type IsValidSignatureExporterCaller added in v2.3.1 

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

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

func NewIsValidSignatureExporterCaller added in v2.3.1 

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

NewIsValidSignatureExporterCaller creates a new read-only instance of IsValidSignatureExporter, bound to a specific deployed contract.

func (*IsValidSignatureExporterCaller) IsValidSignature added in v2.3.1 

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

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

Solidity: function isValidSignature(bytes _data, bytes _signature) constant returns(bytes4)

type IsValidSignatureExporterCallerRaw added in v2.3.1 

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

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

func (*IsValidSignatureExporterCallerRaw) Call added in v2.3.1 

func (_IsValidSignatureExporter *IsValidSignatureExporterCallerRaw) 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 IsValidSignatureExporterCallerSession added in v2.3.1 

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

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

func (*IsValidSignatureExporterCallerSession) IsValidSignature added in v2.3.1 

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

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

Solidity: function isValidSignature(bytes _data, bytes _signature) constant returns(bytes4)

type IsValidSignatureExporterFilterer added in v2.3.1 

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

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

func NewIsValidSignatureExporterFilterer added in v2.3.1 

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

NewIsValidSignatureExporterFilterer creates a new log filterer instance of IsValidSignatureExporter, bound to a specific deployed contract.

type IsValidSignatureExporterRaw added in v2.3.1 

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

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

func (*IsValidSignatureExporterRaw) Call added in v2.3.1 

func (_IsValidSignatureExporter *IsValidSignatureExporterRaw) 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 (*IsValidSignatureExporterRaw) Transact added in v2.3.1 

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

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

func (*IsValidSignatureExporterRaw) Transfer added in v2.3.1 

func (_IsValidSignatureExporter *IsValidSignatureExporterRaw) 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 IsValidSignatureExporterSession added in v2.3.1 

type IsValidSignatureExporterSession struct {
	Contract     *IsValidSignatureExporter // 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
}

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

func (*IsValidSignatureExporterSession) IsValidSignature added in v2.3.1 

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

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

Solidity: function isValidSignature(bytes _data, bytes _signature) constant returns(bytes4)

type IsValidSignatureExporterTransactor added in v2.3.1 

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

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

func NewIsValidSignatureExporterTransactor added in v2.3.1 

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

NewIsValidSignatureExporterTransactor creates a new write-only instance of IsValidSignatureExporter, bound to a specific deployed contract.

type IsValidSignatureExporterTransactorRaw added in v2.3.1 

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

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

func (*IsValidSignatureExporterTransactorRaw) Transact added in v2.3.1 

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

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

func (*IsValidSignatureExporterTransactorRaw) Transfer added in v2.3.1 

func (_IsValidSignatureExporter *IsValidSignatureExporterTransactorRaw) 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 IsValidSignatureExporterTransactorSession added in v2.3.1 

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

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

type NonCompliantToken 

type NonCompliantToken struct {
	NonCompliantTokenCaller     // Read-only binding to the contract
	NonCompliantTokenTransactor // Write-only binding to the contract
	NonCompliantTokenFilterer   // Log filterer for contract events
}

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

func DeployNonCompliantToken 

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

DeployNonCompliantToken deploys a new Ethereum contract, binding an instance of NonCompliantToken to it.

func NewNonCompliantToken 

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

NewNonCompliantToken creates a new instance of NonCompliantToken, bound to a specific deployed contract.

type NonCompliantTokenApproval 

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

NonCompliantTokenApproval represents a Approval event raised by the NonCompliantToken contract.

type NonCompliantTokenApprovalIterator 

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

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

func (*NonCompliantTokenApprovalIterator) Close 

func (it *NonCompliantTokenApprovalIterator) Close() error

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

func (*NonCompliantTokenApprovalIterator) Error 

func (it *NonCompliantTokenApprovalIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*NonCompliantTokenApprovalIterator) Next 

func (it *NonCompliantTokenApprovalIterator) 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 NonCompliantTokenCaller 

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

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

func NewNonCompliantTokenCaller 

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

NewNonCompliantTokenCaller creates a new read-only instance of NonCompliantToken, bound to a specific deployed contract.

func (*NonCompliantTokenCaller) Allowance 

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

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

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

func (*NonCompliantTokenCaller) BalanceOf 

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

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

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

func (*NonCompliantTokenCaller) TotalSupply 

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

TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.

Solidity: function totalSupply() constant returns(uint256)

type NonCompliantTokenCallerRaw 

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

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

func (*NonCompliantTokenCallerRaw) Call 

func (_NonCompliantToken *NonCompliantTokenCallerRaw) 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 NonCompliantTokenCallerSession 

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

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

func (*NonCompliantTokenCallerSession) Allowance 

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

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

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

func (*NonCompliantTokenCallerSession) BalanceOf 

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

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

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

func (*NonCompliantTokenCallerSession) TotalSupply 

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

TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.

Solidity: function totalSupply() constant returns(uint256)

type NonCompliantTokenFilterer 

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

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

func NewNonCompliantTokenFilterer 

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

NewNonCompliantTokenFilterer creates a new log filterer instance of NonCompliantToken, bound to a specific deployed contract.

func (*NonCompliantTokenFilterer) FilterApproval 

func (_NonCompliantToken *NonCompliantTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*NonCompliantTokenApprovalIterator, 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 (*NonCompliantTokenFilterer) FilterTransfer 

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

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

Solidity: event Transfer(address indexed from, address indexed to, uint256 amount)

func (*NonCompliantTokenFilterer) ParseApproval added in v2.3.0 

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

ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.

Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)

func (*NonCompliantTokenFilterer) ParseTransfer added in v2.3.0 

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

ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.

Solidity: event Transfer(address indexed from, address indexed to, uint256 amount)

func (*NonCompliantTokenFilterer) WatchApproval 

func (_NonCompliantToken *NonCompliantTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *NonCompliantTokenApproval, 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 (*NonCompliantTokenFilterer) WatchTransfer 

func (_NonCompliantToken *NonCompliantTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *NonCompliantTokenTransfer, 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 amount)

type NonCompliantTokenRaw 

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

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

func (*NonCompliantTokenRaw) Call 

func (_NonCompliantToken *NonCompliantTokenRaw) 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 (*NonCompliantTokenRaw) Transact 

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

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

func (*NonCompliantTokenRaw) Transfer 

func (_NonCompliantToken *NonCompliantTokenRaw) 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 NonCompliantTokenSession 

type NonCompliantTokenSession struct {
	Contract     *NonCompliantToken // 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
}

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

func (*NonCompliantTokenSession) Allowance 

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

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

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

func (*NonCompliantTokenSession) Approve 

func (_NonCompliantToken *NonCompliantTokenSession) 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()

func (*NonCompliantTokenSession) BalanceOf 

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

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

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

func (*NonCompliantTokenSession) Credit 

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

Credit is a paid mutator transaction binding the contract method 0xef6506db.

Solidity: function credit(address to, uint256 amount) returns(bool)

func (*NonCompliantTokenSession) Debit 

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

Debit is a paid mutator transaction binding the contract method 0x636be27a.

Solidity: function debit(address from, uint256 amount) returns()

func (*NonCompliantTokenSession) TotalSupply 

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

TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.

Solidity: function totalSupply() constant returns(uint256)

func (*NonCompliantTokenSession) Transfer 

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

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

Solidity: function transfer(address to, uint256 amount) returns()

func (*NonCompliantTokenSession) TransferFrom 

func (_NonCompliantToken *NonCompliantTokenSession) 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()

type NonCompliantTokenTransactor 

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

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

func NewNonCompliantTokenTransactor 

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

NewNonCompliantTokenTransactor creates a new write-only instance of NonCompliantToken, bound to a specific deployed contract.

func (*NonCompliantTokenTransactor) Approve 

func (_NonCompliantToken *NonCompliantTokenTransactor) 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()

func (*NonCompliantTokenTransactor) Credit 

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

Credit is a paid mutator transaction binding the contract method 0xef6506db.

Solidity: function credit(address to, uint256 amount) returns(bool)

func (*NonCompliantTokenTransactor) Debit 

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

Debit is a paid mutator transaction binding the contract method 0x636be27a.

Solidity: function debit(address from, uint256 amount) returns()

func (*NonCompliantTokenTransactor) Transfer 

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

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

Solidity: function transfer(address to, uint256 amount) returns()

func (*NonCompliantTokenTransactor) TransferFrom 

func (_NonCompliantToken *NonCompliantTokenTransactor) 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()

type NonCompliantTokenTransactorRaw 

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

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

func (*NonCompliantTokenTransactorRaw) Transact 

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

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

func (*NonCompliantTokenTransactorRaw) Transfer 

func (_NonCompliantToken *NonCompliantTokenTransactorRaw) 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 NonCompliantTokenTransactorSession 

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

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

func (*NonCompliantTokenTransactorSession) Approve 

func (_NonCompliantToken *NonCompliantTokenTransactorSession) 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()

func (*NonCompliantTokenTransactorSession) Credit 

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

Credit is a paid mutator transaction binding the contract method 0xef6506db.

Solidity: function credit(address to, uint256 amount) returns(bool)

func (*NonCompliantTokenTransactorSession) Debit 

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

Debit is a paid mutator transaction binding the contract method 0x636be27a.

Solidity: function debit(address from, uint256 amount) returns()

func (*NonCompliantTokenTransactorSession) Transfer 

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

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

Solidity: function transfer(address to, uint256 amount) returns()

func (*NonCompliantTokenTransactorSession) TransferFrom 

func (_NonCompliantToken *NonCompliantTokenTransactorSession) 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()

type NonCompliantTokenTransfer 

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

NonCompliantTokenTransfer represents a Transfer event raised by the NonCompliantToken contract.

type NonCompliantTokenTransferIterator 

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

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

func (*NonCompliantTokenTransferIterator) Close 

func (it *NonCompliantTokenTransferIterator) Close() error

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

func (*NonCompliantTokenTransferIterator) Error 

func (it *NonCompliantTokenTransferIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*NonCompliantTokenTransferIterator) Next 

func (it *NonCompliantTokenTransferIterator) 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 OraclizeAddrResolver 

type OraclizeAddrResolver struct {
	OraclizeAddrResolverCaller     // Read-only binding to the contract
	OraclizeAddrResolverTransactor // Write-only binding to the contract
	OraclizeAddrResolverFilterer   // Log filterer for contract events
}

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

func DeployOraclizeAddrResolver 

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

DeployOraclizeAddrResolver deploys a new Ethereum contract, binding an instance of OraclizeAddrResolver to it.

func NewOraclizeAddrResolver 

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

NewOraclizeAddrResolver creates a new instance of OraclizeAddrResolver, bound to a specific deployed contract.

type OraclizeAddrResolverCaller 

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

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

func NewOraclizeAddrResolverCaller 

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

NewOraclizeAddrResolverCaller creates a new read-only instance of OraclizeAddrResolver, bound to a specific deployed contract.

func (*OraclizeAddrResolverCaller) GetAddress 

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

GetAddress is a free data retrieval call binding the contract method 0x38cc4831.

Solidity: function getAddress() constant returns(address)

type OraclizeAddrResolverCallerRaw 

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

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

func (*OraclizeAddrResolverCallerRaw) Call 

func (_OraclizeAddrResolver *OraclizeAddrResolverCallerRaw) 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 OraclizeAddrResolverCallerSession 

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

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

func (*OraclizeAddrResolverCallerSession) GetAddress 

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

GetAddress is a free data retrieval call binding the contract method 0x38cc4831.

Solidity: function getAddress() constant returns(address)

type OraclizeAddrResolverFilterer 

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

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

func NewOraclizeAddrResolverFilterer 

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

NewOraclizeAddrResolverFilterer creates a new log filterer instance of OraclizeAddrResolver, bound to a specific deployed contract.

type OraclizeAddrResolverRaw 

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

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

func (*OraclizeAddrResolverRaw) Call 

func (_OraclizeAddrResolver *OraclizeAddrResolverRaw) 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 (*OraclizeAddrResolverRaw) Transact 

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

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

func (*OraclizeAddrResolverRaw) Transfer 

func (_OraclizeAddrResolver *OraclizeAddrResolverRaw) 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 OraclizeAddrResolverSession 

type OraclizeAddrResolverSession struct {
	Contract     *OraclizeAddrResolver // 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
}

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

func (*OraclizeAddrResolverSession) GetAddress 

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

GetAddress is a free data retrieval call binding the contract method 0x38cc4831.

Solidity: function getAddress() constant returns(address)

type OraclizeAddrResolverTransactor 

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

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

func NewOraclizeAddrResolverTransactor 

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

NewOraclizeAddrResolverTransactor creates a new write-only instance of OraclizeAddrResolver, bound to a specific deployed contract.

type OraclizeAddrResolverTransactorRaw 

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

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

func (*OraclizeAddrResolverTransactorRaw) Transact 

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

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

func (*OraclizeAddrResolverTransactorRaw) Transfer 

func (_OraclizeAddrResolver *OraclizeAddrResolverTransactorRaw) 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 OraclizeAddrResolverTransactorSession 

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

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

type OraclizeConnector 

type OraclizeConnector struct {
	OraclizeConnectorCaller     // Read-only binding to the contract
	OraclizeConnectorTransactor // Write-only binding to the contract
	OraclizeConnectorFilterer   // Log filterer for contract events
}

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

func DeployOraclizeConnector 

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

DeployOraclizeConnector deploys a new Ethereum contract, binding an instance of OraclizeConnector to it.

func NewOraclizeConnector 

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

NewOraclizeConnector creates a new instance of OraclizeConnector, bound to a specific deployed contract.

type OraclizeConnectorCaller 

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

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

func NewOraclizeConnectorCaller 

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

NewOraclizeConnectorCaller creates a new read-only instance of OraclizeConnector, bound to a specific deployed contract.

func (*OraclizeConnectorCaller) CbAddress 

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

CbAddress is a free data retrieval call binding the contract method 0xc281d19e.

Solidity: function cbAddress() constant returns(address)

func (*OraclizeConnectorCaller) GetPrice 

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

GetPrice is a free data retrieval call binding the contract method 0x2ef3accc.

Solidity: function getPrice(string _datasource, uint256 gaslimit) constant returns(uint256)

func (*OraclizeConnectorCaller) GetPrice0 added in v2.3.0 

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

GetPrice0 is a free data retrieval call binding the contract method 0x524f3889.

Solidity: function getPrice(string _datasource) constant returns(uint256)

func (*OraclizeConnectorCaller) ProofType 

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

ProofType is a free data retrieval call binding the contract method 0x05af5d35.

Solidity: function proofType() constant returns(bytes1)

type OraclizeConnectorCallerRaw 

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

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

func (*OraclizeConnectorCallerRaw) Call 

func (_OraclizeConnector *OraclizeConnectorCallerRaw) 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 OraclizeConnectorCallerSession 

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

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

func (*OraclizeConnectorCallerSession) CbAddress 

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

CbAddress is a free data retrieval call binding the contract method 0xc281d19e.

Solidity: function cbAddress() constant returns(address)

func (*OraclizeConnectorCallerSession) GetPrice 

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

GetPrice is a free data retrieval call binding the contract method 0x2ef3accc.

Solidity: function getPrice(string _datasource, uint256 gaslimit) constant returns(uint256)

func (*OraclizeConnectorCallerSession) GetPrice0 added in v2.3.0 

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

GetPrice0 is a free data retrieval call binding the contract method 0x524f3889.

Solidity: function getPrice(string _datasource) constant returns(uint256)

func (*OraclizeConnectorCallerSession) ProofType 

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

ProofType is a free data retrieval call binding the contract method 0x05af5d35.

Solidity: function proofType() constant returns(bytes1)

type OraclizeConnectorFilterer 

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

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

func NewOraclizeConnectorFilterer 

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

NewOraclizeConnectorFilterer creates a new log filterer instance of OraclizeConnector, bound to a specific deployed contract.

type OraclizeConnectorRaw 

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

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

func (*OraclizeConnectorRaw) Call 

func (_OraclizeConnector *OraclizeConnectorRaw) 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 (*OraclizeConnectorRaw) Transact 

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

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

func (*OraclizeConnectorRaw) Transfer 

func (_OraclizeConnector *OraclizeConnectorRaw) 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 OraclizeConnectorSession 

type OraclizeConnectorSession struct {
	Contract     *OraclizeConnector // 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
}

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

func (*OraclizeConnectorSession) CbAddress 

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

CbAddress is a free data retrieval call binding the contract method 0xc281d19e.

Solidity: function cbAddress() constant returns(address)

func (*OraclizeConnectorSession) GetPrice 

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

GetPrice is a free data retrieval call binding the contract method 0x2ef3accc.

Solidity: function getPrice(string _datasource, uint256 gaslimit) constant returns(uint256)

func (*OraclizeConnectorSession) GetPrice0 added in v2.3.0 

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

GetPrice0 is a free data retrieval call binding the contract method 0x524f3889.

Solidity: function getPrice(string _datasource) constant returns(uint256)

func (*OraclizeConnectorSession) ProofType 

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

ProofType is a free data retrieval call binding the contract method 0x05af5d35.

Solidity: function proofType() constant returns(bytes1)

func (*OraclizeConnectorSession) Query 

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

Query is a paid mutator transaction binding the contract method 0xadf59f99.

Solidity: function query(uint256 _timestamp, string _datasource, string _arg) returns(bytes32)

func (*OraclizeConnectorSession) QueryWithGasLimit 

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

QueryWithGasLimit is a paid mutator transaction binding the contract method 0xc51be90f.

Solidity: function query_withGasLimit(uint256 _timestamp, string _datasource, string _arg, uint256 _gaslimit) returns(bytes32)

func (*OraclizeConnectorSession) SetCustomGasPrice 

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

SetCustomGasPrice is a paid mutator transaction binding the contract method 0xca6ad1e4.

Solidity: function setCustomGasPrice(uint256 _gasPrice) returns()

func (*OraclizeConnectorSession) SetProofType 

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

SetProofType is a paid mutator transaction binding the contract method 0x688dcfd7.

Solidity: function setProofType(bytes1 _proofType) returns()

type OraclizeConnectorTransactor 

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

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

func NewOraclizeConnectorTransactor 

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

NewOraclizeConnectorTransactor creates a new write-only instance of OraclizeConnector, bound to a specific deployed contract.

func (*OraclizeConnectorTransactor) Query 

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

Query is a paid mutator transaction binding the contract method 0xadf59f99.

Solidity: function query(uint256 _timestamp, string _datasource, string _arg) returns(bytes32)

func (*OraclizeConnectorTransactor) QueryWithGasLimit 

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

QueryWithGasLimit is a paid mutator transaction binding the contract method 0xc51be90f.

Solidity: function query_withGasLimit(uint256 _timestamp, string _datasource, string _arg, uint256 _gaslimit) returns(bytes32)

func (*OraclizeConnectorTransactor) SetCustomGasPrice 

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

SetCustomGasPrice is a paid mutator transaction binding the contract method 0xca6ad1e4.

Solidity: function setCustomGasPrice(uint256 _gasPrice) returns()

func (*OraclizeConnectorTransactor) SetProofType 

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

SetProofType is a paid mutator transaction binding the contract method 0x688dcfd7.

Solidity: function setProofType(bytes1 _proofType) returns()

type OraclizeConnectorTransactorRaw 

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

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

func (*OraclizeConnectorTransactorRaw) Transact 

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

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

func (*OraclizeConnectorTransactorRaw) Transfer 

func (_OraclizeConnector *OraclizeConnectorTransactorRaw) 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 OraclizeConnectorTransactorSession 

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

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

func (*OraclizeConnectorTransactorSession) Query 

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

Query is a paid mutator transaction binding the contract method 0xadf59f99.

Solidity: function query(uint256 _timestamp, string _datasource, string _arg) returns(bytes32)

func (*OraclizeConnectorTransactorSession) QueryWithGasLimit 

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

QueryWithGasLimit is a paid mutator transaction binding the contract method 0xc51be90f.

Solidity: function query_withGasLimit(uint256 _timestamp, string _datasource, string _arg, uint256 _gaslimit) returns(bytes32)

func (*OraclizeConnectorTransactorSession) SetCustomGasPrice 

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

SetCustomGasPrice is a paid mutator transaction binding the contract method 0xca6ad1e4.

Solidity: function setCustomGasPrice(uint256 _gasPrice) returns()

func (*OraclizeConnectorTransactorSession) SetProofType 

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

SetProofType is a paid mutator transaction binding the contract method 0x688dcfd7.

Solidity: function setProofType(bytes1 _proofType) returns()

type ParseIntScientificExporter 

type ParseIntScientificExporter struct {
	ParseIntScientificExporterCaller     // Read-only binding to the contract
	ParseIntScientificExporterTransactor // Write-only binding to the contract
	ParseIntScientificExporterFilterer   // Log filterer for contract events
}

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

func DeployParseIntScientificExporter 

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

DeployParseIntScientificExporter deploys a new Ethereum contract, binding an instance of ParseIntScientificExporter to it.

func NewParseIntScientificExporter 

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

NewParseIntScientificExporter creates a new instance of ParseIntScientificExporter, bound to a specific deployed contract.

type ParseIntScientificExporterCaller 

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

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

func NewParseIntScientificExporterCaller 

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

NewParseIntScientificExporterCaller creates a new read-only instance of ParseIntScientificExporter, bound to a specific deployed contract.

func (*ParseIntScientificExporterCaller) ParseIntScientific 

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

ParseIntScientific is a free data retrieval call binding the contract method 0xba070695.

Solidity: function parseIntScientific(string _a) constant returns(uint256)

func (*ParseIntScientificExporterCaller) ParseIntScientificDecimals 

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

ParseIntScientificDecimals is a free data retrieval call binding the contract method 0x87c8da5e.

Solidity: function parseIntScientificDecimals(string _a, uint256 _b) constant returns(uint256)

func (*ParseIntScientificExporterCaller) ParseIntScientificWei 

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

ParseIntScientificWei is a free data retrieval call binding the contract method 0x61f7e0ac.

Solidity: function parseIntScientificWei(string _a) constant returns(uint256)

type ParseIntScientificExporterCallerRaw 

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

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

func (*ParseIntScientificExporterCallerRaw) Call 

func (_ParseIntScientificExporter *ParseIntScientificExporterCallerRaw) 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 ParseIntScientificExporterCallerSession 

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

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

func (*ParseIntScientificExporterCallerSession) ParseIntScientific 

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

ParseIntScientific is a free data retrieval call binding the contract method 0xba070695.

Solidity: function parseIntScientific(string _a) constant returns(uint256)

func (*ParseIntScientificExporterCallerSession) ParseIntScientificDecimals 

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

ParseIntScientificDecimals is a free data retrieval call binding the contract method 0x87c8da5e.

Solidity: function parseIntScientificDecimals(string _a, uint256 _b) constant returns(uint256)

func (*ParseIntScientificExporterCallerSession) ParseIntScientificWei 

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

ParseIntScientificWei is a free data retrieval call binding the contract method 0x61f7e0ac.

Solidity: function parseIntScientificWei(string _a) constant returns(uint256)

type ParseIntScientificExporterFilterer 

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

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

func NewParseIntScientificExporterFilterer 

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

NewParseIntScientificExporterFilterer creates a new log filterer instance of ParseIntScientificExporter, bound to a specific deployed contract.

type ParseIntScientificExporterRaw 

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

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

func (*ParseIntScientificExporterRaw) Call 

func (_ParseIntScientificExporter *ParseIntScientificExporterRaw) 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 (*ParseIntScientificExporterRaw) Transact 

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

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

func (*ParseIntScientificExporterRaw) Transfer 

func (_ParseIntScientificExporter *ParseIntScientificExporterRaw) 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 ParseIntScientificExporterSession 

type ParseIntScientificExporterSession struct {
	Contract     *ParseIntScientificExporter // 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
}

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

func (*ParseIntScientificExporterSession) ParseIntScientific 

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

ParseIntScientific is a free data retrieval call binding the contract method 0xba070695.

Solidity: function parseIntScientific(string _a) constant returns(uint256)

func (*ParseIntScientificExporterSession) ParseIntScientificDecimals 

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

ParseIntScientificDecimals is a free data retrieval call binding the contract method 0x87c8da5e.

Solidity: function parseIntScientificDecimals(string _a, uint256 _b) constant returns(uint256)

func (*ParseIntScientificExporterSession) ParseIntScientificWei 

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

ParseIntScientificWei is a free data retrieval call binding the contract method 0x61f7e0ac.

Solidity: function parseIntScientificWei(string _a) constant returns(uint256)

type ParseIntScientificExporterTransactor 

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

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

func NewParseIntScientificExporterTransactor 

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

NewParseIntScientificExporterTransactor creates a new write-only instance of ParseIntScientificExporter, bound to a specific deployed contract.

type ParseIntScientificExporterTransactorRaw 

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

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

func (*ParseIntScientificExporterTransactorRaw) Transact 

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

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

func (*ParseIntScientificExporterTransactorRaw) Transfer 

func (_ParseIntScientificExporter *ParseIntScientificExporterTransactorRaw) 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 ParseIntScientificExporterTransactorSession 

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

ParseIntScientificExporterTransactorSession 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, arg0 common.Address, arg1 common.Address) (*big.Int, error)

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

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

func (*TokenCaller) BalanceOf 

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

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

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

func (*TokenCaller) TotalSupply 

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

TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.

Solidity: function totalSupply() 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(arg0 common.Address, arg1 common.Address) (*big.Int, error)

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

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

func (*TokenCallerSession) BalanceOf 

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

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

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

func (*TokenCallerSession) TotalSupply 

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

TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.

Solidity: function totalSupply() 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 amount)

func (*TokenFilterer) ParseApproval added in v2.3.0 

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

ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.

Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)

func (*TokenFilterer) ParseTransfer added in v2.3.0 

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

ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.

Solidity: event Transfer(address indexed from, address indexed to, uint256 amount)

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 amount)

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(arg0 common.Address, arg1 common.Address) (*big.Int, error)

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

Solidity: function allowance(address , address ) 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(arg0 common.Address) (*big.Int, error)

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

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

func (*TokenSession) Credit 

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

Credit is a paid mutator transaction binding the contract method 0xef6506db.

Solidity: function credit(address to, uint256 amount) returns(bool)

func (*TokenSession) Debit 

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

Debit is a paid mutator transaction binding the contract method 0x636be27a.

Solidity: function debit(address from, uint256 amount) returns()

func (*TokenSession) TotalSupply 

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

TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.

Solidity: function totalSupply() constant returns(uint256)

func (*TokenSession) Transfer 

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

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

Solidity: function transfer(address to, uint256 amount) 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) Credit 

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

Credit is a paid mutator transaction binding the contract method 0xef6506db.

Solidity: function credit(address to, uint256 amount) returns(bool)

func (*TokenTransactor) Debit 

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

Debit is a paid mutator transaction binding the contract method 0x636be27a.

Solidity: function debit(address from, uint256 amount) returns()

func (*TokenTransactor) Transfer 

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

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

Solidity: function transfer(address to, uint256 amount) 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) Credit 

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

Credit is a paid mutator transaction binding the contract method 0xef6506db.

Solidity: function credit(address to, uint256 amount) returns(bool)

func (*TokenTransactorSession) Debit 

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

Debit is a paid mutator transaction binding the contract method 0x636be27a.

Solidity: function debit(address from, uint256 amount) returns()

func (*TokenTransactorSession) Transfer 

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

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

Solidity: function transfer(address to, uint256 amount) 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
	Amount *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 TokenWhitelistableExporter 

type TokenWhitelistableExporter struct {
	TokenWhitelistableExporterCaller     // Read-only binding to the contract
	TokenWhitelistableExporterTransactor // Write-only binding to the contract
	TokenWhitelistableExporterFilterer   // Log filterer for contract events
}

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

func DeployTokenWhitelistableExporter 

func DeployTokenWhitelistableExporter(auth *bind.TransactOpts, backend bind.ContractBackend, _ens_ common.Address, _tokenWhitelistName_ [32]byte) (common.Address, *types.Transaction, *TokenWhitelistableExporter, error)

DeployTokenWhitelistableExporter deploys a new Ethereum contract, binding an instance of TokenWhitelistableExporter to it.

func NewTokenWhitelistableExporter 

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

NewTokenWhitelistableExporter creates a new instance of TokenWhitelistableExporter, bound to a specific deployed contract.

type TokenWhitelistableExporterCaller 

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

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

func NewTokenWhitelistableExporterCaller 

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

NewTokenWhitelistableExporterCaller creates a new read-only instance of TokenWhitelistableExporter, bound to a specific deployed contract.

func (*TokenWhitelistableExporterCaller) EnsRegistry 

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

EnsRegistry is a free data retrieval call binding the contract method 0x7d73b231.

Solidity: function ensRegistry() constant returns(address)

func (*TokenWhitelistableExporterCaller) GetERC20RecipientAndAmount 

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

GetERC20RecipientAndAmount is a free data retrieval call binding the contract method 0xafc72e93.

Solidity: function getERC20RecipientAndAmount(address _destination, bytes _data) constant returns(address, uint256)

func (*TokenWhitelistableExporterCaller) GetStablecoinInfo 

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

GetStablecoinInfo is a free data retrieval call binding the contract method 0x3efec5e9.

Solidity: function getStablecoinInfo() constant returns(string, uint256, uint256, bool, bool, bool, uint256)

func (*TokenWhitelistableExporterCaller) GetTokenInfo 

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

GetTokenInfo is a free data retrieval call binding the contract method 0x1f69565f.

Solidity: function getTokenInfo(address _a) constant returns(string, uint256, uint256, bool, bool, bool, uint256)

func (*TokenWhitelistableExporterCaller) IsTokenAvailable 

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

IsTokenAvailable is a free data retrieval call binding the contract method 0x2ff0fcaa.

Solidity: function isTokenAvailable(address _a) constant returns(bool)

func (*TokenWhitelistableExporterCaller) IsTokenLoadable 

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

IsTokenLoadable is a free data retrieval call binding the contract method 0x17e73794.

Solidity: function isTokenLoadable(address _a) constant returns(bool)

func (*TokenWhitelistableExporterCaller) IsTokenRedeemable 

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

IsTokenRedeemable is a free data retrieval call binding the contract method 0xdcc922bc.

Solidity: function isTokenRedeemable(address _a) constant returns(bool)

func (*TokenWhitelistableExporterCaller) RedeemableTokens 

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

RedeemableTokens is a free data retrieval call binding the contract method 0x44b049bc.

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

func (*TokenWhitelistableExporterCaller) TokenAddressArray 

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

TokenAddressArray is a free data retrieval call binding the contract method 0x443dd2a4.

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

func (*TokenWhitelistableExporterCaller) TokenWhitelistNode 

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

TokenWhitelistNode is a free data retrieval call binding the contract method 0x877337b0.

Solidity: function tokenWhitelistNode() constant returns(bytes32)

type TokenWhitelistableExporterCallerRaw 

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

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

func (*TokenWhitelistableExporterCallerRaw) Call 

func (_TokenWhitelistableExporter *TokenWhitelistableExporterCallerRaw) 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 TokenWhitelistableExporterCallerSession 

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

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

func (*TokenWhitelistableExporterCallerSession) EnsRegistry 

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

EnsRegistry is a free data retrieval call binding the contract method 0x7d73b231.

Solidity: function ensRegistry() constant returns(address)

func (*TokenWhitelistableExporterCallerSession) GetERC20RecipientAndAmount 

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

GetERC20RecipientAndAmount is a free data retrieval call binding the contract method 0xafc72e93.

Solidity: function getERC20RecipientAndAmount(address _destination, bytes _data) constant returns(address, uint256)

func (*TokenWhitelistableExporterCallerSession) GetStablecoinInfo 

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

GetStablecoinInfo is a free data retrieval call binding the contract method 0x3efec5e9.

Solidity: function getStablecoinInfo() constant returns(string, uint256, uint256, bool, bool, bool, uint256)

func (*TokenWhitelistableExporterCallerSession) GetTokenInfo 

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

GetTokenInfo is a free data retrieval call binding the contract method 0x1f69565f.

Solidity: function getTokenInfo(address _a) constant returns(string, uint256, uint256, bool, bool, bool, uint256)

func (*TokenWhitelistableExporterCallerSession) IsTokenAvailable 

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

IsTokenAvailable is a free data retrieval call binding the contract method 0x2ff0fcaa.

Solidity: function isTokenAvailable(address _a) constant returns(bool)

func (*TokenWhitelistableExporterCallerSession) IsTokenLoadable 

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

IsTokenLoadable is a free data retrieval call binding the contract method 0x17e73794.

Solidity: function isTokenLoadable(address _a) constant returns(bool)

func (*TokenWhitelistableExporterCallerSession) IsTokenRedeemable 

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

IsTokenRedeemable is a free data retrieval call binding the contract method 0xdcc922bc.

Solidity: function isTokenRedeemable(address _a) constant returns(bool)

func (*TokenWhitelistableExporterCallerSession) RedeemableTokens 

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

RedeemableTokens is a free data retrieval call binding the contract method 0x44b049bc.

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

func (*TokenWhitelistableExporterCallerSession) TokenAddressArray 

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

TokenAddressArray is a free data retrieval call binding the contract method 0x443dd2a4.

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

func (*TokenWhitelistableExporterCallerSession) TokenWhitelistNode 

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

TokenWhitelistNode is a free data retrieval call binding the contract method 0x877337b0.

Solidity: function tokenWhitelistNode() constant returns(bytes32)

type TokenWhitelistableExporterFilterer 

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

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

func NewTokenWhitelistableExporterFilterer 

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

NewTokenWhitelistableExporterFilterer creates a new log filterer instance of TokenWhitelistableExporter, bound to a specific deployed contract.

type TokenWhitelistableExporterRaw 

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

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

func (*TokenWhitelistableExporterRaw) Call 

func (_TokenWhitelistableExporter *TokenWhitelistableExporterRaw) 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 (*TokenWhitelistableExporterRaw) Transact 

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

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

func (*TokenWhitelistableExporterRaw) Transfer 

func (_TokenWhitelistableExporter *TokenWhitelistableExporterRaw) 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 TokenWhitelistableExporterSession 

type TokenWhitelistableExporterSession struct {
	Contract     *TokenWhitelistableExporter // 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
}

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

func (*TokenWhitelistableExporterSession) EnsRegistry 

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

EnsRegistry is a free data retrieval call binding the contract method 0x7d73b231.

Solidity: function ensRegistry() constant returns(address)

func (*TokenWhitelistableExporterSession) GetERC20RecipientAndAmount 

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

GetERC20RecipientAndAmount is a free data retrieval call binding the contract method 0xafc72e93.

Solidity: function getERC20RecipientAndAmount(address _destination, bytes _data) constant returns(address, uint256)

func (*TokenWhitelistableExporterSession) GetStablecoinInfo 

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

GetStablecoinInfo is a free data retrieval call binding the contract method 0x3efec5e9.

Solidity: function getStablecoinInfo() constant returns(string, uint256, uint256, bool, bool, bool, uint256)

func (*TokenWhitelistableExporterSession) GetTokenInfo 

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

GetTokenInfo is a free data retrieval call binding the contract method 0x1f69565f.

Solidity: function getTokenInfo(address _a) constant returns(string, uint256, uint256, bool, bool, bool, uint256)

func (*TokenWhitelistableExporterSession) IsTokenAvailable 

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

IsTokenAvailable is a free data retrieval call binding the contract method 0x2ff0fcaa.

Solidity: function isTokenAvailable(address _a) constant returns(bool)

func (*TokenWhitelistableExporterSession) IsTokenLoadable 

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

IsTokenLoadable is a free data retrieval call binding the contract method 0x17e73794.

Solidity: function isTokenLoadable(address _a) constant returns(bool)

func (*TokenWhitelistableExporterSession) IsTokenRedeemable 

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

IsTokenRedeemable is a free data retrieval call binding the contract method 0xdcc922bc.

Solidity: function isTokenRedeemable(address _a) constant returns(bool)

func (*TokenWhitelistableExporterSession) RedeemableTokens 

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

RedeemableTokens is a free data retrieval call binding the contract method 0x44b049bc.

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

func (*TokenWhitelistableExporterSession) TokenAddressArray 

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

TokenAddressArray is a free data retrieval call binding the contract method 0x443dd2a4.

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

func (*TokenWhitelistableExporterSession) TokenWhitelistNode 

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

TokenWhitelistNode is a free data retrieval call binding the contract method 0x877337b0.

Solidity: function tokenWhitelistNode() constant returns(bytes32)

func (*TokenWhitelistableExporterSession) UpdateTokenRate 

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

UpdateTokenRate is a paid mutator transaction binding the contract method 0xd545782e.

Solidity: function updateTokenRate(address _token, uint256 _rate, uint256 _updateDate) returns()

type TokenWhitelistableExporterTransactor 

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

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

func NewTokenWhitelistableExporterTransactor 

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

NewTokenWhitelistableExporterTransactor creates a new write-only instance of TokenWhitelistableExporter, bound to a specific deployed contract.

func (*TokenWhitelistableExporterTransactor) UpdateTokenRate 

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

UpdateTokenRate is a paid mutator transaction binding the contract method 0xd545782e.

Solidity: function updateTokenRate(address _token, uint256 _rate, uint256 _updateDate) returns()

type TokenWhitelistableExporterTransactorRaw 

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

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

func (*TokenWhitelistableExporterTransactorRaw) Transact 

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

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

func (*TokenWhitelistableExporterTransactorRaw) Transfer 

func (_TokenWhitelistableExporter *TokenWhitelistableExporterTransactorRaw) 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 TokenWhitelistableExporterTransactorSession 

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

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

func (*TokenWhitelistableExporterTransactorSession) UpdateTokenRate 

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

UpdateTokenRate is a paid mutator transaction binding the contract method 0xd545782e.

Solidity: function updateTokenRate(address _token, uint256 _rate, uint256 _updateDate) 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.