token

package
v0.0.0-rc7.4 Latest Latest
Warning

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

 Go to latest Published: May 1, 2020 License: GPL-3.0 Imports: 8 Imported by: 0

Documentation

Index

Constants

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

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

View Source 
const RequestableIABI = "" /* 1176-byte string literal not displayed */

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

View Source 
const RequestableSimpleTokenABI = "" /* 5509-byte string literal not displayed */

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

View Source 
const SafeMathABI = "[]"

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

Variables

View Source 
var OwnableFuncSigs = map[string]string{
	"8f32d59b": "isOwner()",
	"8da5cb5b": "owner()",
	"715018a6": "renounceOwnership()",
	"f2fde38b": "transferOwnership(address)",
}

OwnableFuncSigs maps the 4-byte function signature to its string representation.

View Source 
var RequestableIFuncSigs = map[string]string{
	"141ecf46": "applyRequestInChildChain(bool,uint256,address,bytes32,bytes)",
	"a9f79308": "applyRequestInRootChain(bool,uint256,address,bytes32,bytes)",
}

RequestableIFuncSigs maps the 4-byte function signature to its string representation.

View Source 
var RequestableSimpleTokenBin = "" /* 6370-byte string literal not displayed */

RequestableSimpleTokenBin is the compiled bytecode used for deploying new contracts.

View Source 
var RequestableSimpleTokenFuncSigs = map[string]string{
	"f904d9eb": "KEY_OWNER()",
	"cb069663": "KEY_TOTAL_SUPPLY()",
	"a8490815": "PERFIX_BALANCES()",
	"141ecf46": "applyRequestInChildChain(bool,uint256,address,bytes32,bytes)",
	"a9f79308": "applyRequestInRootChain(bool,uint256,address,bytes32,bytes)",
	"27e235e3": "balances(address)",
	"b9e59d09": "decodeTrieValue(bytes)",
	"b18fcfdf": "getBalanceTrieKey(address)",
	"8f32d59b": "isOwner()",
	"40c10f19": "mint(address,uint256)",
	"8da5cb5b": "owner()",
	"715018a6": "renounceOwnership()",
	"18160ddd": "totalSupply()",
	"a9059cbb": "transfer(address,uint256)",
	"f2fde38b": "transferOwnership(address)",
}

RequestableSimpleTokenFuncSigs maps the 4-byte function signature to its string representation.

View Source 
var SafeMathBin = "" /* 242-byte string literal not displayed */

SafeMathBin is the compiled bytecode used for deploying new contracts.

Functions

This section is empty.

Types

type Ownable 

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

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

func NewOwnable 

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

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

type OwnableCaller 

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

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

func NewOwnableCaller 

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

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

func (*OwnableCaller) IsOwner 

func (_Ownable *OwnableCaller) IsOwner(opts *bind.CallOpts) (bool, error)

IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.

Solidity: function isOwner() constant returns(bool)

func (*OwnableCaller) Owner 

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

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

Solidity: function owner() constant returns(address)

type OwnableCallerRaw 

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

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

func (*OwnableCallerRaw) Call 

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

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

type OwnableCallerSession 

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

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

func (*OwnableCallerSession) IsOwner 

func (_Ownable *OwnableCallerSession) IsOwner() (bool, error)

IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.

Solidity: function isOwner() constant returns(bool)

func (*OwnableCallerSession) Owner 

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

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

Solidity: function owner() constant returns(address)

type OwnableFilterer 

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

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

func NewOwnableFilterer 

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

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

func (*OwnableFilterer) FilterOwnershipTransferred 

func (_Ownable *OwnableFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*OwnableOwnershipTransferredIterator, error)

FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)

func (*OwnableFilterer) ParseOwnershipTransferred 

func (_Ownable *OwnableFilterer) ParseOwnershipTransferred(log types.Log) (*OwnableOwnershipTransferred, error)

ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)

func (*OwnableFilterer) WatchOwnershipTransferred 

func (_Ownable *OwnableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OwnableOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)

type OwnableOwnershipTransferred 

type OwnableOwnershipTransferred struct {
	PreviousOwner common.Address
	NewOwner      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

OwnableOwnershipTransferred represents a OwnershipTransferred event raised by the Ownable contract.

type OwnableOwnershipTransferredIterator 

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

OwnableOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Ownable contract.

func (*OwnableOwnershipTransferredIterator) Close 

func (it *OwnableOwnershipTransferredIterator) Close() error

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

func (*OwnableOwnershipTransferredIterator) Error 

func (it *OwnableOwnershipTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*OwnableOwnershipTransferredIterator) Next 

func (it *OwnableOwnershipTransferredIterator) 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 OwnableRaw 

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

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

func (*OwnableRaw) Call 

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

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

func (*OwnableRaw) Transact 

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

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

func (*OwnableRaw) Transfer 

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

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

type OwnableSession 

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

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

func (*OwnableSession) IsOwner 

func (_Ownable *OwnableSession) IsOwner() (bool, error)

IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.

Solidity: function isOwner() constant returns(bool)

func (*OwnableSession) Owner 

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

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

Solidity: function owner() constant returns(address)

func (*OwnableSession) RenounceOwnership 

func (_Ownable *OwnableSession) RenounceOwnership() (*types.Transaction, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*OwnableSession) TransferOwnership 

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

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

Solidity: function transferOwnership(address newOwner) returns()

type OwnableTransactor 

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

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

func NewOwnableTransactor 

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

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

func (*OwnableTransactor) RenounceOwnership 

func (_Ownable *OwnableTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*OwnableTransactor) TransferOwnership 

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

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

Solidity: function transferOwnership(address newOwner) returns()

type OwnableTransactorRaw 

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

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

func (*OwnableTransactorRaw) Transact 

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

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

func (*OwnableTransactorRaw) Transfer 

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

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

type OwnableTransactorSession 

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

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

func (*OwnableTransactorSession) RenounceOwnership 

func (_Ownable *OwnableTransactorSession) RenounceOwnership() (*types.Transaction, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*OwnableTransactorSession) TransferOwnership 

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

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

Solidity: function transferOwnership(address newOwner) returns()

type RequestableI 

type RequestableI struct {
	RequestableICaller     // Read-only binding to the contract
	RequestableITransactor // Write-only binding to the contract
	RequestableIFilterer   // Log filterer for contract events
}

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

func NewRequestableI 

func NewRequestableI(address common.Address, backend bind.ContractBackend) (*RequestableI, error)

NewRequestableI creates a new instance of RequestableI, bound to a specific deployed contract.

type RequestableICaller 

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

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

func NewRequestableICaller 

func NewRequestableICaller(address common.Address, caller bind.ContractCaller) (*RequestableICaller, error)

NewRequestableICaller creates a new read-only instance of RequestableI, bound to a specific deployed contract.

type RequestableICallerRaw 

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

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

func (*RequestableICallerRaw) Call 

func (_RequestableI *RequestableICallerRaw) 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 RequestableICallerSession 

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

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

type RequestableIFilterer 

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

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

func NewRequestableIFilterer 

func NewRequestableIFilterer(address common.Address, filterer bind.ContractFilterer) (*RequestableIFilterer, error)

NewRequestableIFilterer creates a new log filterer instance of RequestableI, bound to a specific deployed contract.

type RequestableIRaw 

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

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

func (*RequestableIRaw) Call 

func (_RequestableI *RequestableIRaw) 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 (*RequestableIRaw) Transact 

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

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

func (*RequestableIRaw) Transfer 

func (_RequestableI *RequestableIRaw) 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 RequestableISession 

type RequestableISession struct {
	Contract     *RequestableI     // 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
}

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

func (*RequestableISession) ApplyRequestInChildChain 

func (_RequestableI *RequestableISession) ApplyRequestInChildChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error)

ApplyRequestInChildChain is a paid mutator transaction binding the contract method 0x141ecf46.

Solidity: function applyRequestInChildChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success)

func (*RequestableISession) ApplyRequestInRootChain 

func (_RequestableI *RequestableISession) ApplyRequestInRootChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error)

ApplyRequestInRootChain is a paid mutator transaction binding the contract method 0xa9f79308.

Solidity: function applyRequestInRootChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success)

type RequestableITransactor 

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

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

func NewRequestableITransactor 

func NewRequestableITransactor(address common.Address, transactor bind.ContractTransactor) (*RequestableITransactor, error)

NewRequestableITransactor creates a new write-only instance of RequestableI, bound to a specific deployed contract.

func (*RequestableITransactor) ApplyRequestInChildChain 

func (_RequestableI *RequestableITransactor) ApplyRequestInChildChain(opts *bind.TransactOpts, isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error)

ApplyRequestInChildChain is a paid mutator transaction binding the contract method 0x141ecf46.

Solidity: function applyRequestInChildChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success)

func (*RequestableITransactor) ApplyRequestInRootChain 

func (_RequestableI *RequestableITransactor) ApplyRequestInRootChain(opts *bind.TransactOpts, isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error)

ApplyRequestInRootChain is a paid mutator transaction binding the contract method 0xa9f79308.

Solidity: function applyRequestInRootChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success)

type RequestableITransactorRaw 

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

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

func (*RequestableITransactorRaw) Transact 

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

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

func (*RequestableITransactorRaw) Transfer 

func (_RequestableI *RequestableITransactorRaw) 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 RequestableITransactorSession 

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

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

func (*RequestableITransactorSession) ApplyRequestInChildChain 

func (_RequestableI *RequestableITransactorSession) ApplyRequestInChildChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error)

ApplyRequestInChildChain is a paid mutator transaction binding the contract method 0x141ecf46.

Solidity: function applyRequestInChildChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success)

func (*RequestableITransactorSession) ApplyRequestInRootChain 

func (_RequestableI *RequestableITransactorSession) ApplyRequestInRootChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error)

ApplyRequestInRootChain is a paid mutator transaction binding the contract method 0xa9f79308.

Solidity: function applyRequestInRootChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success)

type RequestableSimpleToken 

type RequestableSimpleToken struct {
	RequestableSimpleTokenCaller     // Read-only binding to the contract
	RequestableSimpleTokenTransactor // Write-only binding to the contract
	RequestableSimpleTokenFilterer   // Log filterer for contract events
}

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

func DeployRequestableSimpleToken 

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

DeployRequestableSimpleToken deploys a new Ethereum contract, binding an instance of RequestableSimpleToken to it.

func NewRequestableSimpleToken 

func NewRequestableSimpleToken(address common.Address, backend bind.ContractBackend) (*RequestableSimpleToken, error)

NewRequestableSimpleToken creates a new instance of RequestableSimpleToken, bound to a specific deployed contract.

type RequestableSimpleTokenCaller 

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

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

func NewRequestableSimpleTokenCaller 

func NewRequestableSimpleTokenCaller(address common.Address, caller bind.ContractCaller) (*RequestableSimpleTokenCaller, error)

NewRequestableSimpleTokenCaller creates a new read-only instance of RequestableSimpleToken, bound to a specific deployed contract.

func (*RequestableSimpleTokenCaller) Balances 

func (_RequestableSimpleToken *RequestableSimpleTokenCaller) Balances(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

Balances is a free data retrieval call binding the contract method 0x27e235e3.

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

func (*RequestableSimpleTokenCaller) DecodeTrieValue 

func (_RequestableSimpleToken *RequestableSimpleTokenCaller) DecodeTrieValue(opts *bind.CallOpts, trieValue []byte) (*big.Int, error)

DecodeTrieValue is a free data retrieval call binding the contract method 0xb9e59d09.

Solidity: function decodeTrieValue(bytes trieValue) constant returns(uint256 v)

func (*RequestableSimpleTokenCaller) GetBalanceTrieKey 

func (_RequestableSimpleToken *RequestableSimpleTokenCaller) GetBalanceTrieKey(opts *bind.CallOpts, who common.Address) ([32]byte, error)

GetBalanceTrieKey is a free data retrieval call binding the contract method 0xb18fcfdf.

Solidity: function getBalanceTrieKey(address who) constant returns(bytes32)

func (*RequestableSimpleTokenCaller) IsOwner 

func (_RequestableSimpleToken *RequestableSimpleTokenCaller) IsOwner(opts *bind.CallOpts) (bool, error)

IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.

Solidity: function isOwner() constant returns(bool)

func (*RequestableSimpleTokenCaller) KEYOWNER 

func (_RequestableSimpleToken *RequestableSimpleTokenCaller) KEYOWNER(opts *bind.CallOpts) ([32]byte, error)

KEYOWNER is a free data retrieval call binding the contract method 0xf904d9eb.

Solidity: function KEY_OWNER() constant returns(bytes32)

func (*RequestableSimpleTokenCaller) KEYTOTALSUPPLY 

func (_RequestableSimpleToken *RequestableSimpleTokenCaller) KEYTOTALSUPPLY(opts *bind.CallOpts) ([32]byte, error)

KEYTOTALSUPPLY is a free data retrieval call binding the contract method 0xcb069663.

Solidity: function KEY_TOTAL_SUPPLY() constant returns(bytes32)

func (*RequestableSimpleTokenCaller) Owner 

func (_RequestableSimpleToken *RequestableSimpleTokenCaller) 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 (*RequestableSimpleTokenCaller) PERFIXBALANCES 

func (_RequestableSimpleToken *RequestableSimpleTokenCaller) PERFIXBALANCES(opts *bind.CallOpts) ([32]byte, error)

PERFIXBALANCES is a free data retrieval call binding the contract method 0xa8490815.

Solidity: function PERFIX_BALANCES() constant returns(bytes32)

func (*RequestableSimpleTokenCaller) TotalSupply 

func (_RequestableSimpleToken *RequestableSimpleTokenCaller) 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 RequestableSimpleTokenCallerRaw 

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

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

func (*RequestableSimpleTokenCallerRaw) Call 

func (_RequestableSimpleToken *RequestableSimpleTokenCallerRaw) 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 RequestableSimpleTokenCallerSession 

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

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

func (*RequestableSimpleTokenCallerSession) Balances 

func (_RequestableSimpleToken *RequestableSimpleTokenCallerSession) Balances(arg0 common.Address) (*big.Int, error)

Balances is a free data retrieval call binding the contract method 0x27e235e3.

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

func (*RequestableSimpleTokenCallerSession) DecodeTrieValue 

func (_RequestableSimpleToken *RequestableSimpleTokenCallerSession) DecodeTrieValue(trieValue []byte) (*big.Int, error)

DecodeTrieValue is a free data retrieval call binding the contract method 0xb9e59d09.

Solidity: function decodeTrieValue(bytes trieValue) constant returns(uint256 v)

func (*RequestableSimpleTokenCallerSession) GetBalanceTrieKey 

func (_RequestableSimpleToken *RequestableSimpleTokenCallerSession) GetBalanceTrieKey(who common.Address) ([32]byte, error)

GetBalanceTrieKey is a free data retrieval call binding the contract method 0xb18fcfdf.

Solidity: function getBalanceTrieKey(address who) constant returns(bytes32)

func (*RequestableSimpleTokenCallerSession) IsOwner 

func (_RequestableSimpleToken *RequestableSimpleTokenCallerSession) IsOwner() (bool, error)

IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.

Solidity: function isOwner() constant returns(bool)

func (*RequestableSimpleTokenCallerSession) KEYOWNER 

func (_RequestableSimpleToken *RequestableSimpleTokenCallerSession) KEYOWNER() ([32]byte, error)

KEYOWNER is a free data retrieval call binding the contract method 0xf904d9eb.

Solidity: function KEY_OWNER() constant returns(bytes32)

func (*RequestableSimpleTokenCallerSession) KEYTOTALSUPPLY 

func (_RequestableSimpleToken *RequestableSimpleTokenCallerSession) KEYTOTALSUPPLY() ([32]byte, error)

KEYTOTALSUPPLY is a free data retrieval call binding the contract method 0xcb069663.

Solidity: function KEY_TOTAL_SUPPLY() constant returns(bytes32)

func (*RequestableSimpleTokenCallerSession) Owner 

func (_RequestableSimpleToken *RequestableSimpleTokenCallerSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*RequestableSimpleTokenCallerSession) PERFIXBALANCES 

func (_RequestableSimpleToken *RequestableSimpleTokenCallerSession) PERFIXBALANCES() ([32]byte, error)

PERFIXBALANCES is a free data retrieval call binding the contract method 0xa8490815.

Solidity: function PERFIX_BALANCES() constant returns(bytes32)

func (*RequestableSimpleTokenCallerSession) TotalSupply 

func (_RequestableSimpleToken *RequestableSimpleTokenCallerSession) TotalSupply() (*big.Int, error)

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

Solidity: function totalSupply() constant returns(uint256)

type RequestableSimpleTokenFilterer 

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

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

func NewRequestableSimpleTokenFilterer 

func NewRequestableSimpleTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*RequestableSimpleTokenFilterer, error)

NewRequestableSimpleTokenFilterer creates a new log filterer instance of RequestableSimpleToken, bound to a specific deployed contract.

func (*RequestableSimpleTokenFilterer) FilterMint 

func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) FilterMint(opts *bind.FilterOpts) (*RequestableSimpleTokenMintIterator, error)

FilterMint is a free log retrieval operation binding the contract event 0x0f6798a560793a54c3bcfe86a93cde1e73087d944c0ea20544137d4121396885.

Solidity: event Mint(address _to, uint256 _value)

func (*RequestableSimpleTokenFilterer) FilterOwnershipTransferred 

func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*RequestableSimpleTokenOwnershipTransferredIterator, error)

FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)

func (*RequestableSimpleTokenFilterer) FilterRequested 

func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) FilterRequested(opts *bind.FilterOpts) (*RequestableSimpleTokenRequestedIterator, error)

FilterRequested is a free log retrieval operation binding the contract event 0xc9cca1cafbefa6d9c2ec79c95fc6e689905c6e96616a1e7406f13cf725f3cd15.

Solidity: event Requested(bool _isExit, address _requestor, bytes32 _trieKey, bytes _trieValue)

func (*RequestableSimpleTokenFilterer) FilterTransfer 

func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) FilterTransfer(opts *bind.FilterOpts) (*RequestableSimpleTokenTransferIterator, error)

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

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

func (*RequestableSimpleTokenFilterer) ParseMint 

func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) ParseMint(log types.Log) (*RequestableSimpleTokenMint, error)

ParseMint is a log parse operation binding the contract event 0x0f6798a560793a54c3bcfe86a93cde1e73087d944c0ea20544137d4121396885.

Solidity: event Mint(address _to, uint256 _value)

func (*RequestableSimpleTokenFilterer) ParseOwnershipTransferred 

func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) ParseOwnershipTransferred(log types.Log) (*RequestableSimpleTokenOwnershipTransferred, error)

ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)

func (*RequestableSimpleTokenFilterer) ParseRequested 

func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) ParseRequested(log types.Log) (*RequestableSimpleTokenRequested, error)

ParseRequested is a log parse operation binding the contract event 0xc9cca1cafbefa6d9c2ec79c95fc6e689905c6e96616a1e7406f13cf725f3cd15.

Solidity: event Requested(bool _isExit, address _requestor, bytes32 _trieKey, bytes _trieValue)

func (*RequestableSimpleTokenFilterer) ParseTransfer 

func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) ParseTransfer(log types.Log) (*RequestableSimpleTokenTransfer, error)

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

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

func (*RequestableSimpleTokenFilterer) WatchMint 

func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) WatchMint(opts *bind.WatchOpts, sink chan<- *RequestableSimpleTokenMint) (event.Subscription, error)

WatchMint is a free log subscription operation binding the contract event 0x0f6798a560793a54c3bcfe86a93cde1e73087d944c0ea20544137d4121396885.

Solidity: event Mint(address _to, uint256 _value)

func (*RequestableSimpleTokenFilterer) WatchOwnershipTransferred 

func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *RequestableSimpleTokenOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)

func (*RequestableSimpleTokenFilterer) WatchRequested 

func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) WatchRequested(opts *bind.WatchOpts, sink chan<- *RequestableSimpleTokenRequested) (event.Subscription, error)

WatchRequested is a free log subscription operation binding the contract event 0xc9cca1cafbefa6d9c2ec79c95fc6e689905c6e96616a1e7406f13cf725f3cd15.

Solidity: event Requested(bool _isExit, address _requestor, bytes32 _trieKey, bytes _trieValue)

func (*RequestableSimpleTokenFilterer) WatchTransfer 

func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *RequestableSimpleTokenTransfer) (event.Subscription, error)

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

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

type RequestableSimpleTokenMint 

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

RequestableSimpleTokenMint represents a Mint event raised by the RequestableSimpleToken contract.

type RequestableSimpleTokenMintIterator 

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

RequestableSimpleTokenMintIterator is returned from FilterMint and is used to iterate over the raw logs and unpacked data for Mint events raised by the RequestableSimpleToken contract.

func (*RequestableSimpleTokenMintIterator) Close 

func (it *RequestableSimpleTokenMintIterator) Close() error

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

func (*RequestableSimpleTokenMintIterator) Error 

func (it *RequestableSimpleTokenMintIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RequestableSimpleTokenMintIterator) Next 

func (it *RequestableSimpleTokenMintIterator) 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 RequestableSimpleTokenOwnershipTransferred 

type RequestableSimpleTokenOwnershipTransferred struct {
	PreviousOwner common.Address
	NewOwner      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

RequestableSimpleTokenOwnershipTransferred represents a OwnershipTransferred event raised by the RequestableSimpleToken contract.

type RequestableSimpleTokenOwnershipTransferredIterator 

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

RequestableSimpleTokenOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the RequestableSimpleToken contract.

func (*RequestableSimpleTokenOwnershipTransferredIterator) Close 

func (it *RequestableSimpleTokenOwnershipTransferredIterator) Close() error

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

func (*RequestableSimpleTokenOwnershipTransferredIterator) Error 

func (it *RequestableSimpleTokenOwnershipTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RequestableSimpleTokenOwnershipTransferredIterator) Next 

func (it *RequestableSimpleTokenOwnershipTransferredIterator) 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 RequestableSimpleTokenRaw 

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

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

func (*RequestableSimpleTokenRaw) Call 

func (_RequestableSimpleToken *RequestableSimpleTokenRaw) 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 (*RequestableSimpleTokenRaw) Transact 

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

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

func (*RequestableSimpleTokenRaw) Transfer 

func (_RequestableSimpleToken *RequestableSimpleTokenRaw) 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 RequestableSimpleTokenRequested 

type RequestableSimpleTokenRequested struct {
	IsExit    bool
	Requestor common.Address
	TrieKey   [32]byte
	TrieValue []byte
	Raw       types.Log // Blockchain specific contextual infos
}

RequestableSimpleTokenRequested represents a Requested event raised by the RequestableSimpleToken contract.

type RequestableSimpleTokenRequestedIterator 

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

RequestableSimpleTokenRequestedIterator is returned from FilterRequested and is used to iterate over the raw logs and unpacked data for Requested events raised by the RequestableSimpleToken contract.

func (*RequestableSimpleTokenRequestedIterator) Close 

func (it *RequestableSimpleTokenRequestedIterator) Close() error

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

func (*RequestableSimpleTokenRequestedIterator) Error 

func (it *RequestableSimpleTokenRequestedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RequestableSimpleTokenRequestedIterator) Next 

func (it *RequestableSimpleTokenRequestedIterator) 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 RequestableSimpleTokenSession 

type RequestableSimpleTokenSession struct {
	Contract     *RequestableSimpleToken // 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
}

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

func (*RequestableSimpleTokenSession) ApplyRequestInChildChain 

func (_RequestableSimpleToken *RequestableSimpleTokenSession) ApplyRequestInChildChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error)

ApplyRequestInChildChain is a paid mutator transaction binding the contract method 0x141ecf46.

Solidity: function applyRequestInChildChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success)

func (*RequestableSimpleTokenSession) ApplyRequestInRootChain 

func (_RequestableSimpleToken *RequestableSimpleTokenSession) ApplyRequestInRootChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error)

ApplyRequestInRootChain is a paid mutator transaction binding the contract method 0xa9f79308.

Solidity: function applyRequestInRootChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success)

func (*RequestableSimpleTokenSession) Balances 

func (_RequestableSimpleToken *RequestableSimpleTokenSession) Balances(arg0 common.Address) (*big.Int, error)

Balances is a free data retrieval call binding the contract method 0x27e235e3.

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

func (*RequestableSimpleTokenSession) DecodeTrieValue 

func (_RequestableSimpleToken *RequestableSimpleTokenSession) DecodeTrieValue(trieValue []byte) (*big.Int, error)

DecodeTrieValue is a free data retrieval call binding the contract method 0xb9e59d09.

Solidity: function decodeTrieValue(bytes trieValue) constant returns(uint256 v)

func (*RequestableSimpleTokenSession) GetBalanceTrieKey 

func (_RequestableSimpleToken *RequestableSimpleTokenSession) GetBalanceTrieKey(who common.Address) ([32]byte, error)

GetBalanceTrieKey is a free data retrieval call binding the contract method 0xb18fcfdf.

Solidity: function getBalanceTrieKey(address who) constant returns(bytes32)

func (*RequestableSimpleTokenSession) IsOwner 

func (_RequestableSimpleToken *RequestableSimpleTokenSession) IsOwner() (bool, error)

IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.

Solidity: function isOwner() constant returns(bool)

func (*RequestableSimpleTokenSession) KEYOWNER 

func (_RequestableSimpleToken *RequestableSimpleTokenSession) KEYOWNER() ([32]byte, error)

KEYOWNER is a free data retrieval call binding the contract method 0xf904d9eb.

Solidity: function KEY_OWNER() constant returns(bytes32)

func (*RequestableSimpleTokenSession) KEYTOTALSUPPLY 

func (_RequestableSimpleToken *RequestableSimpleTokenSession) KEYTOTALSUPPLY() ([32]byte, error)

KEYTOTALSUPPLY is a free data retrieval call binding the contract method 0xcb069663.

Solidity: function KEY_TOTAL_SUPPLY() constant returns(bytes32)

func (*RequestableSimpleTokenSession) Mint 

func (_RequestableSimpleToken *RequestableSimpleTokenSession) Mint(_to common.Address, _value *big.Int) (*types.Transaction, error)

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

Solidity: function mint(address _to, uint256 _value) returns()

func (*RequestableSimpleTokenSession) Owner 

func (_RequestableSimpleToken *RequestableSimpleTokenSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*RequestableSimpleTokenSession) PERFIXBALANCES 

func (_RequestableSimpleToken *RequestableSimpleTokenSession) PERFIXBALANCES() ([32]byte, error)

PERFIXBALANCES is a free data retrieval call binding the contract method 0xa8490815.

Solidity: function PERFIX_BALANCES() constant returns(bytes32)

func (*RequestableSimpleTokenSession) RenounceOwnership 

func (_RequestableSimpleToken *RequestableSimpleTokenSession) RenounceOwnership() (*types.Transaction, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*RequestableSimpleTokenSession) TotalSupply 

func (_RequestableSimpleToken *RequestableSimpleTokenSession) TotalSupply() (*big.Int, error)

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

Solidity: function totalSupply() constant returns(uint256)

func (*RequestableSimpleTokenSession) Transfer 

func (_RequestableSimpleToken *RequestableSimpleTokenSession) 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()

func (*RequestableSimpleTokenSession) TransferOwnership 

func (_RequestableSimpleToken *RequestableSimpleTokenSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

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

Solidity: function transferOwnership(address newOwner) returns()

type RequestableSimpleTokenTransactor 

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

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

func NewRequestableSimpleTokenTransactor 

func NewRequestableSimpleTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*RequestableSimpleTokenTransactor, error)

NewRequestableSimpleTokenTransactor creates a new write-only instance of RequestableSimpleToken, bound to a specific deployed contract.

func (*RequestableSimpleTokenTransactor) ApplyRequestInChildChain 

func (_RequestableSimpleToken *RequestableSimpleTokenTransactor) ApplyRequestInChildChain(opts *bind.TransactOpts, isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error)

ApplyRequestInChildChain is a paid mutator transaction binding the contract method 0x141ecf46.

Solidity: function applyRequestInChildChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success)

func (*RequestableSimpleTokenTransactor) ApplyRequestInRootChain 

func (_RequestableSimpleToken *RequestableSimpleTokenTransactor) ApplyRequestInRootChain(opts *bind.TransactOpts, isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error)

ApplyRequestInRootChain is a paid mutator transaction binding the contract method 0xa9f79308.

Solidity: function applyRequestInRootChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success)

func (*RequestableSimpleTokenTransactor) Mint 

func (_RequestableSimpleToken *RequestableSimpleTokenTransactor) Mint(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (*types.Transaction, error)

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

Solidity: function mint(address _to, uint256 _value) returns()

func (*RequestableSimpleTokenTransactor) RenounceOwnership 

func (_RequestableSimpleToken *RequestableSimpleTokenTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*RequestableSimpleTokenTransactor) Transfer 

func (_RequestableSimpleToken *RequestableSimpleTokenTransactor) 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()

func (*RequestableSimpleTokenTransactor) TransferOwnership 

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

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

Solidity: function transferOwnership(address newOwner) returns()

type RequestableSimpleTokenTransactorRaw 

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

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

func (*RequestableSimpleTokenTransactorRaw) Transact 

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

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

func (*RequestableSimpleTokenTransactorRaw) Transfer 

func (_RequestableSimpleToken *RequestableSimpleTokenTransactorRaw) 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 RequestableSimpleTokenTransactorSession 

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

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

func (*RequestableSimpleTokenTransactorSession) ApplyRequestInChildChain 

func (_RequestableSimpleToken *RequestableSimpleTokenTransactorSession) ApplyRequestInChildChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error)

ApplyRequestInChildChain is a paid mutator transaction binding the contract method 0x141ecf46.

Solidity: function applyRequestInChildChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success)

func (*RequestableSimpleTokenTransactorSession) ApplyRequestInRootChain 

func (_RequestableSimpleToken *RequestableSimpleTokenTransactorSession) ApplyRequestInRootChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error)

ApplyRequestInRootChain is a paid mutator transaction binding the contract method 0xa9f79308.

Solidity: function applyRequestInRootChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success)

func (*RequestableSimpleTokenTransactorSession) Mint 

func (_RequestableSimpleToken *RequestableSimpleTokenTransactorSession) Mint(_to common.Address, _value *big.Int) (*types.Transaction, error)

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

Solidity: function mint(address _to, uint256 _value) returns()

func (*RequestableSimpleTokenTransactorSession) RenounceOwnership 

func (_RequestableSimpleToken *RequestableSimpleTokenTransactorSession) RenounceOwnership() (*types.Transaction, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*RequestableSimpleTokenTransactorSession) Transfer 

func (_RequestableSimpleToken *RequestableSimpleTokenTransactorSession) 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()

func (*RequestableSimpleTokenTransactorSession) TransferOwnership 

func (_RequestableSimpleToken *RequestableSimpleTokenTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

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

Solidity: function transferOwnership(address newOwner) returns()

type RequestableSimpleTokenTransfer 

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

RequestableSimpleTokenTransfer represents a Transfer event raised by the RequestableSimpleToken contract.

type RequestableSimpleTokenTransferIterator 

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

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

func (*RequestableSimpleTokenTransferIterator) Close 

func (it *RequestableSimpleTokenTransferIterator) Close() error

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

func (*RequestableSimpleTokenTransferIterator) Error 

func (it *RequestableSimpleTokenTransferIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RequestableSimpleTokenTransferIterator) Next 

func (it *RequestableSimpleTokenTransferIterator) 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 SafeMath 

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

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

func DeploySafeMath 

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

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

func NewSafeMath 

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

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

type SafeMathCaller 

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

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

func NewSafeMathCaller 

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

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

type SafeMathCallerRaw 

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

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

func (*SafeMathCallerRaw) Call 

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

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

type SafeMathCallerSession 

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

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

type SafeMathFilterer 

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

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

func NewSafeMathFilterer 

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

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

type SafeMathRaw 

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

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

func (*SafeMathRaw) Call 

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

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

func (*SafeMathRaw) Transact 

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

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

func (*SafeMathRaw) Transfer 

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

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

type SafeMathSession 

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

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

type SafeMathTransactor 

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

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

func NewSafeMathTransactor 

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

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

type SafeMathTransactorRaw 

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

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

func (*SafeMathTransactorRaw) Transact 

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

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

func (*SafeMathTransactorRaw) Transfer 

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

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

type SafeMathTransactorSession 

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

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

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.