contract

package
v0.0.0 Latest Latest
Warning

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

 Go to latest Published: Apr 26, 2018 License: GPL-3.0 Imports: 8 Imported by: 0

Documentation

Index

Constants

View Source 
const ByteUtilsABI = "[]"

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

View Source 
const ByteUtilsBin = `` /* 162-byte string literal not displayed */

ByteUtilsBin is the compiled bytecode used for deploying new contracts.

View Source 
const ECRecoveryABI = "[]"

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

View Source 
const ECRecoveryBin = `` /* 162-byte string literal not displayed */

ECRecoveryBin is the compiled bytecode used for deploying new contracts.

View Source 
const MathABI = "[]"

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

View Source 
const MathBin = `` /* 162-byte string literal not displayed */

MathBin is the compiled bytecode used for deploying new contracts.

View Source 
const MerkleABI = "[]"

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

View Source 
const MerkleBin = `` /* 162-byte string literal not displayed */

MerkleBin is the compiled bytecode used for deploying new contracts.

View Source 
const PriorityQueueABI = "" /* 1024-byte string literal not displayed */

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

View Source 
const PriorityQueueBin = `` /* 3410-byte string literal not displayed */

PriorityQueueBin is the compiled bytecode used for deploying new contracts.

View Source 
const RLPABI = "[]"

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

View Source 
const RLPBin = `` /* 162-byte string literal not displayed */

RLPBin is the compiled bytecode used for deploying new contracts.

View Source 
const RLPEncodeABI = "[]"

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

View Source 
const RLPEncodeBin = `` /* 162-byte string literal not displayed */

RLPEncodeBin is the compiled bytecode used for deploying new contracts.

View Source 
const RootChainABI = "" /* 4576-byte string literal not displayed */

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

View Source 
const RootChainBin = `` /* 20730-byte string literal not displayed */

RootChainBin is the compiled bytecode used for deploying new contracts.

View Source 
const SafeMathABI = "[]"

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

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

SafeMathBin is the compiled bytecode used for deploying new contracts.

View Source 
const ValidateABI = "[]"

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

View Source 
const ValidateBin = `` /* 162-byte string literal not displayed */

ValidateBin is the compiled bytecode used for deploying new contracts.

Variables

This section is empty.

Functions

This section is empty.

Types

type ByteUtils 

type ByteUtils struct {
	ByteUtilsCaller     // Read-only binding to the contract
	ByteUtilsTransactor // Write-only binding to the contract
	ByteUtilsFilterer   // Log filterer for contract events
}

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

func DeployByteUtils 

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

DeployByteUtils deploys a new Ethereum contract, binding an instance of ByteUtils to it.

func NewByteUtils 

func NewByteUtils(address common.Address, backend bind.ContractBackend) (*ByteUtils, error)

NewByteUtils creates a new instance of ByteUtils, bound to a specific deployed contract.

type ByteUtilsCaller 

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

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

func NewByteUtilsCaller 

func NewByteUtilsCaller(address common.Address, caller bind.ContractCaller) (*ByteUtilsCaller, error)

NewByteUtilsCaller creates a new read-only instance of ByteUtils, bound to a specific deployed contract.

type ByteUtilsCallerRaw 

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

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

func (*ByteUtilsCallerRaw) Call 

func (_ByteUtils *ByteUtilsCallerRaw) 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 ByteUtilsCallerSession 

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

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

type ByteUtilsFilterer 

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

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

func NewByteUtilsFilterer 

func NewByteUtilsFilterer(address common.Address, filterer bind.ContractFilterer) (*ByteUtilsFilterer, error)

NewByteUtilsFilterer creates a new log filterer instance of ByteUtils, bound to a specific deployed contract.

type ByteUtilsRaw 

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

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

func (*ByteUtilsRaw) Call 

func (_ByteUtils *ByteUtilsRaw) 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 (*ByteUtilsRaw) Transact 

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

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

func (*ByteUtilsRaw) Transfer 

func (_ByteUtils *ByteUtilsRaw) 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 ByteUtilsSession 

type ByteUtilsSession struct {
	Contract     *ByteUtils        // 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
}

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

type ByteUtilsTransactor 

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

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

func NewByteUtilsTransactor 

func NewByteUtilsTransactor(address common.Address, transactor bind.ContractTransactor) (*ByteUtilsTransactor, error)

NewByteUtilsTransactor creates a new write-only instance of ByteUtils, bound to a specific deployed contract.

type ByteUtilsTransactorRaw 

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

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

func (*ByteUtilsTransactorRaw) Transact 

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

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

func (*ByteUtilsTransactorRaw) Transfer 

func (_ByteUtils *ByteUtilsTransactorRaw) 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 ByteUtilsTransactorSession 

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

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

type ECRecovery 

type ECRecovery struct {
	ECRecoveryCaller     // Read-only binding to the contract
	ECRecoveryTransactor // Write-only binding to the contract
	ECRecoveryFilterer   // Log filterer for contract events
}

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

func DeployECRecovery 

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

DeployECRecovery deploys a new Ethereum contract, binding an instance of ECRecovery to it.

func NewECRecovery 

func NewECRecovery(address common.Address, backend bind.ContractBackend) (*ECRecovery, error)

NewECRecovery creates a new instance of ECRecovery, bound to a specific deployed contract.

type ECRecoveryCaller 

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

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

func NewECRecoveryCaller 

func NewECRecoveryCaller(address common.Address, caller bind.ContractCaller) (*ECRecoveryCaller, error)

NewECRecoveryCaller creates a new read-only instance of ECRecovery, bound to a specific deployed contract.

type ECRecoveryCallerRaw 

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

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

func (*ECRecoveryCallerRaw) Call 

func (_ECRecovery *ECRecoveryCallerRaw) 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 ECRecoveryCallerSession 

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

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

type ECRecoveryFilterer 

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

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

func NewECRecoveryFilterer 

func NewECRecoveryFilterer(address common.Address, filterer bind.ContractFilterer) (*ECRecoveryFilterer, error)

NewECRecoveryFilterer creates a new log filterer instance of ECRecovery, bound to a specific deployed contract.

type ECRecoveryRaw 

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

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

func (*ECRecoveryRaw) Call 

func (_ECRecovery *ECRecoveryRaw) 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 (*ECRecoveryRaw) Transact 

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

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

func (*ECRecoveryRaw) Transfer 

func (_ECRecovery *ECRecoveryRaw) 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 ECRecoverySession 

type ECRecoverySession struct {
	Contract     *ECRecovery       // 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
}

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

type ECRecoveryTransactor 

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

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

func NewECRecoveryTransactor 

func NewECRecoveryTransactor(address common.Address, transactor bind.ContractTransactor) (*ECRecoveryTransactor, error)

NewECRecoveryTransactor creates a new write-only instance of ECRecovery, bound to a specific deployed contract.

type ECRecoveryTransactorRaw 

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

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

func (*ECRecoveryTransactorRaw) Transact 

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

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

func (*ECRecoveryTransactorRaw) Transfer 

func (_ECRecovery *ECRecoveryTransactorRaw) 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 ECRecoveryTransactorSession 

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

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

type Math 

type Math struct {
	MathCaller     // Read-only binding to the contract
	MathTransactor // Write-only binding to the contract
	MathFilterer   // Log filterer for contract events
}

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

func DeployMath 

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

DeployMath deploys a new Ethereum contract, binding an instance of Math to it.

func NewMath 

func NewMath(address common.Address, backend bind.ContractBackend) (*Math, error)

NewMath creates a new instance of Math, bound to a specific deployed contract.

type MathCaller 

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

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

func NewMathCaller 

func NewMathCaller(address common.Address, caller bind.ContractCaller) (*MathCaller, error)

NewMathCaller creates a new read-only instance of Math, bound to a specific deployed contract.

type MathCallerRaw 

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

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

func (*MathCallerRaw) Call 

func (_Math *MathCallerRaw) 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 MathCallerSession 

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

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

type MathFilterer 

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

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

func NewMathFilterer 

func NewMathFilterer(address common.Address, filterer bind.ContractFilterer) (*MathFilterer, error)

NewMathFilterer creates a new log filterer instance of Math, bound to a specific deployed contract.

type MathRaw 

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

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

func (*MathRaw) Call 

func (_Math *MathRaw) 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 (*MathRaw) Transact 

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

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

func (*MathRaw) Transfer 

func (_Math *MathRaw) 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 MathSession 

type MathSession struct {
	Contract     *Math             // 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
}

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

type MathTransactor 

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

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

func NewMathTransactor 

func NewMathTransactor(address common.Address, transactor bind.ContractTransactor) (*MathTransactor, error)

NewMathTransactor creates a new write-only instance of Math, bound to a specific deployed contract.

type MathTransactorRaw 

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

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

func (*MathTransactorRaw) Transact 

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

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

func (*MathTransactorRaw) Transfer 

func (_Math *MathTransactorRaw) 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 MathTransactorSession 

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

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

type Merkle 

type Merkle struct {
	MerkleCaller     // Read-only binding to the contract
	MerkleTransactor // Write-only binding to the contract
	MerkleFilterer   // Log filterer for contract events
}

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

func DeployMerkle 

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

DeployMerkle deploys a new Ethereum contract, binding an instance of Merkle to it.

func NewMerkle 

func NewMerkle(address common.Address, backend bind.ContractBackend) (*Merkle, error)

NewMerkle creates a new instance of Merkle, bound to a specific deployed contract.

type MerkleCaller 

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

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

func NewMerkleCaller 

func NewMerkleCaller(address common.Address, caller bind.ContractCaller) (*MerkleCaller, error)

NewMerkleCaller creates a new read-only instance of Merkle, bound to a specific deployed contract.

type MerkleCallerRaw 

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

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

func (*MerkleCallerRaw) Call 

func (_Merkle *MerkleCallerRaw) 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 MerkleCallerSession 

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

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

type MerkleFilterer 

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

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

func NewMerkleFilterer 

func NewMerkleFilterer(address common.Address, filterer bind.ContractFilterer) (*MerkleFilterer, error)

NewMerkleFilterer creates a new log filterer instance of Merkle, bound to a specific deployed contract.

type MerkleRaw 

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

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

func (*MerkleRaw) Call 

func (_Merkle *MerkleRaw) 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 (*MerkleRaw) Transact 

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

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

func (*MerkleRaw) Transfer 

func (_Merkle *MerkleRaw) 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 MerkleSession 

type MerkleSession struct {
	Contract     *Merkle           // 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
}

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

type MerkleTransactor 

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

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

func NewMerkleTransactor 

func NewMerkleTransactor(address common.Address, transactor bind.ContractTransactor) (*MerkleTransactor, error)

NewMerkleTransactor creates a new write-only instance of Merkle, bound to a specific deployed contract.

type MerkleTransactorRaw 

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

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

func (*MerkleTransactorRaw) Transact 

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

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

func (*MerkleTransactorRaw) Transfer 

func (_Merkle *MerkleTransactorRaw) 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 MerkleTransactorSession 

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

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

type PriorityQueue 

type PriorityQueue struct {
	PriorityQueueCaller     // Read-only binding to the contract
	PriorityQueueTransactor // Write-only binding to the contract
	PriorityQueueFilterer   // Log filterer for contract events
}

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

func DeployPriorityQueue 

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

DeployPriorityQueue deploys a new Ethereum contract, binding an instance of PriorityQueue to it.

func NewPriorityQueue 

func NewPriorityQueue(address common.Address, backend bind.ContractBackend) (*PriorityQueue, error)

NewPriorityQueue creates a new instance of PriorityQueue, bound to a specific deployed contract.

type PriorityQueueCaller 

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

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

func NewPriorityQueueCaller 

func NewPriorityQueueCaller(address common.Address, caller bind.ContractCaller) (*PriorityQueueCaller, error)

NewPriorityQueueCaller creates a new read-only instance of PriorityQueue, bound to a specific deployed contract.

func (*PriorityQueueCaller) CurrentSize 

func (_PriorityQueue *PriorityQueueCaller) CurrentSize(opts *bind.CallOpts) (*big.Int, error)

CurrentSize is a free data retrieval call binding the contract method 0xbda1504b.

Solidity: function currentSize() constant returns(uint256)

func (*PriorityQueueCaller) GetMin 

func (_PriorityQueue *PriorityQueueCaller) GetMin(opts *bind.CallOpts) (*big.Int, error)

GetMin is a free data retrieval call binding the contract method 0xd6362e97.

Solidity: function getMin() constant returns(uint256)

func (*PriorityQueueCaller) MinChild 

func (_PriorityQueue *PriorityQueueCaller) MinChild(opts *bind.CallOpts, i *big.Int) (*big.Int, error)

MinChild is a free data retrieval call binding the contract method 0x2dcdcd0c.

Solidity: function minChild(i uint256) constant returns(uint256)

type PriorityQueueCallerRaw 

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

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

func (*PriorityQueueCallerRaw) Call 

func (_PriorityQueue *PriorityQueueCallerRaw) 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 PriorityQueueCallerSession 

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

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

func (*PriorityQueueCallerSession) CurrentSize 

func (_PriorityQueue *PriorityQueueCallerSession) CurrentSize() (*big.Int, error)

CurrentSize is a free data retrieval call binding the contract method 0xbda1504b.

Solidity: function currentSize() constant returns(uint256)

func (*PriorityQueueCallerSession) GetMin 

func (_PriorityQueue *PriorityQueueCallerSession) GetMin() (*big.Int, error)

GetMin is a free data retrieval call binding the contract method 0xd6362e97.

Solidity: function getMin() constant returns(uint256)

func (*PriorityQueueCallerSession) MinChild 

func (_PriorityQueue *PriorityQueueCallerSession) MinChild(i *big.Int) (*big.Int, error)

MinChild is a free data retrieval call binding the contract method 0x2dcdcd0c.

Solidity: function minChild(i uint256) constant returns(uint256)

type PriorityQueueFilterer 

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

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

func NewPriorityQueueFilterer 

func NewPriorityQueueFilterer(address common.Address, filterer bind.ContractFilterer) (*PriorityQueueFilterer, error)

NewPriorityQueueFilterer creates a new log filterer instance of PriorityQueue, bound to a specific deployed contract.

type PriorityQueueRaw 

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

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

func (*PriorityQueueRaw) Call 

func (_PriorityQueue *PriorityQueueRaw) 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 (*PriorityQueueRaw) Transact 

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

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

func (*PriorityQueueRaw) Transfer 

func (_PriorityQueue *PriorityQueueRaw) 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 PriorityQueueSession 

type PriorityQueueSession struct {
	Contract     *PriorityQueue    // 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
}

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

func (*PriorityQueueSession) CurrentSize 

func (_PriorityQueue *PriorityQueueSession) CurrentSize() (*big.Int, error)

CurrentSize is a free data retrieval call binding the contract method 0xbda1504b.

Solidity: function currentSize() constant returns(uint256)

func (*PriorityQueueSession) DelMin 

func (_PriorityQueue *PriorityQueueSession) DelMin() (*types.Transaction, error)

DelMin is a paid mutator transaction binding the contract method 0xb07576ac.

Solidity: function delMin() returns(uint256)

func (*PriorityQueueSession) GetMin 

func (_PriorityQueue *PriorityQueueSession) GetMin() (*big.Int, error)

GetMin is a free data retrieval call binding the contract method 0xd6362e97.

Solidity: function getMin() constant returns(uint256)

func (*PriorityQueueSession) Insert 

func (_PriorityQueue *PriorityQueueSession) Insert(k *big.Int) (*types.Transaction, error)

Insert is a paid mutator transaction binding the contract method 0x90b5561d.

Solidity: function insert(k uint256) returns()

func (*PriorityQueueSession) MinChild 

func (_PriorityQueue *PriorityQueueSession) MinChild(i *big.Int) (*big.Int, error)

MinChild is a free data retrieval call binding the contract method 0x2dcdcd0c.

Solidity: function minChild(i uint256) constant returns(uint256)

type PriorityQueueTransactor 

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

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

func NewPriorityQueueTransactor 

func NewPriorityQueueTransactor(address common.Address, transactor bind.ContractTransactor) (*PriorityQueueTransactor, error)

NewPriorityQueueTransactor creates a new write-only instance of PriorityQueue, bound to a specific deployed contract.

func (*PriorityQueueTransactor) DelMin 

func (_PriorityQueue *PriorityQueueTransactor) DelMin(opts *bind.TransactOpts) (*types.Transaction, error)

DelMin is a paid mutator transaction binding the contract method 0xb07576ac.

Solidity: function delMin() returns(uint256)

func (*PriorityQueueTransactor) Insert 

func (_PriorityQueue *PriorityQueueTransactor) Insert(opts *bind.TransactOpts, k *big.Int) (*types.Transaction, error)

Insert is a paid mutator transaction binding the contract method 0x90b5561d.

Solidity: function insert(k uint256) returns()

type PriorityQueueTransactorRaw 

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

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

func (*PriorityQueueTransactorRaw) Transact 

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

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

func (*PriorityQueueTransactorRaw) Transfer 

func (_PriorityQueue *PriorityQueueTransactorRaw) 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 PriorityQueueTransactorSession 

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

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

func (*PriorityQueueTransactorSession) DelMin 

func (_PriorityQueue *PriorityQueueTransactorSession) DelMin() (*types.Transaction, error)

DelMin is a paid mutator transaction binding the contract method 0xb07576ac.

Solidity: function delMin() returns(uint256)

func (*PriorityQueueTransactorSession) Insert 

func (_PriorityQueue *PriorityQueueTransactorSession) Insert(k *big.Int) (*types.Transaction, error)

Insert is a paid mutator transaction binding the contract method 0x90b5561d.

Solidity: function insert(k uint256) returns()

type RLP 

type RLP struct {
	RLPCaller     // Read-only binding to the contract
	RLPTransactor // Write-only binding to the contract
	RLPFilterer   // Log filterer for contract events
}

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

func DeployRLP 

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

DeployRLP deploys a new Ethereum contract, binding an instance of RLP to it.

func NewRLP 

func NewRLP(address common.Address, backend bind.ContractBackend) (*RLP, error)

NewRLP creates a new instance of RLP, bound to a specific deployed contract.

type RLPCaller 

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

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

func NewRLPCaller 

func NewRLPCaller(address common.Address, caller bind.ContractCaller) (*RLPCaller, error)

NewRLPCaller creates a new read-only instance of RLP, bound to a specific deployed contract.

type RLPCallerRaw 

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

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

func (*RLPCallerRaw) Call 

func (_RLP *RLPCallerRaw) 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 RLPCallerSession 

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

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

type RLPEncode 

type RLPEncode struct {
	RLPEncodeCaller     // Read-only binding to the contract
	RLPEncodeTransactor // Write-only binding to the contract
	RLPEncodeFilterer   // Log filterer for contract events
}

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

func DeployRLPEncode 

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

DeployRLPEncode deploys a new Ethereum contract, binding an instance of RLPEncode to it.

func NewRLPEncode 

func NewRLPEncode(address common.Address, backend bind.ContractBackend) (*RLPEncode, error)

NewRLPEncode creates a new instance of RLPEncode, bound to a specific deployed contract.

type RLPEncodeCaller 

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

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

func NewRLPEncodeCaller 

func NewRLPEncodeCaller(address common.Address, caller bind.ContractCaller) (*RLPEncodeCaller, error)

NewRLPEncodeCaller creates a new read-only instance of RLPEncode, bound to a specific deployed contract.

type RLPEncodeCallerRaw 

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

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

func (*RLPEncodeCallerRaw) Call 

func (_RLPEncode *RLPEncodeCallerRaw) 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 RLPEncodeCallerSession 

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

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

type RLPEncodeFilterer 

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

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

func NewRLPEncodeFilterer 

func NewRLPEncodeFilterer(address common.Address, filterer bind.ContractFilterer) (*RLPEncodeFilterer, error)

NewRLPEncodeFilterer creates a new log filterer instance of RLPEncode, bound to a specific deployed contract.

type RLPEncodeRaw 

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

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

func (*RLPEncodeRaw) Call 

func (_RLPEncode *RLPEncodeRaw) 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 (*RLPEncodeRaw) Transact 

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

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

func (*RLPEncodeRaw) Transfer 

func (_RLPEncode *RLPEncodeRaw) 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 RLPEncodeSession 

type RLPEncodeSession struct {
	Contract     *RLPEncode        // 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
}

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

type RLPEncodeTransactor 

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

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

func NewRLPEncodeTransactor 

func NewRLPEncodeTransactor(address common.Address, transactor bind.ContractTransactor) (*RLPEncodeTransactor, error)

NewRLPEncodeTransactor creates a new write-only instance of RLPEncode, bound to a specific deployed contract.

type RLPEncodeTransactorRaw 

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

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

func (*RLPEncodeTransactorRaw) Transact 

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

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

func (*RLPEncodeTransactorRaw) Transfer 

func (_RLPEncode *RLPEncodeTransactorRaw) 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 RLPEncodeTransactorSession 

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

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

type RLPFilterer 

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

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

func NewRLPFilterer 

func NewRLPFilterer(address common.Address, filterer bind.ContractFilterer) (*RLPFilterer, error)

NewRLPFilterer creates a new log filterer instance of RLP, bound to a specific deployed contract.

type RLPRaw 

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

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

func (*RLPRaw) Call 

func (_RLP *RLPRaw) 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 (*RLPRaw) Transact 

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

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

func (*RLPRaw) Transfer 

func (_RLP *RLPRaw) 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 RLPSession 

type RLPSession struct {
	Contract     *RLP              // 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
}

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

type RLPTransactor 

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

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

func NewRLPTransactor 

func NewRLPTransactor(address common.Address, transactor bind.ContractTransactor) (*RLPTransactor, error)

NewRLPTransactor creates a new write-only instance of RLP, bound to a specific deployed contract.

type RLPTransactorRaw 

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

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

func (*RLPTransactorRaw) Transact 

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

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

func (*RLPTransactorRaw) Transfer 

func (_RLP *RLPTransactorRaw) 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 RLPTransactorSession 

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

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

type RootChain 

type RootChain struct {
	RootChainCaller     // Read-only binding to the contract
	RootChainTransactor // Write-only binding to the contract
	RootChainFilterer   // Log filterer for contract events
}

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

func DeployRootChain 

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

DeployRootChain deploys a new Ethereum contract, binding an instance of RootChain to it.

func NewRootChain 

func NewRootChain(address common.Address, backend bind.ContractBackend) (*RootChain, error)

NewRootChain creates a new instance of RootChain, bound to a specific deployed contract.

type RootChainCaller 

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

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

func NewRootChainCaller 

func NewRootChainCaller(address common.Address, caller bind.ContractCaller) (*RootChainCaller, error)

NewRootChainCaller creates a new read-only instance of RootChain, bound to a specific deployed contract.

func (*RootChainCaller) Authority 

func (_RootChain *RootChainCaller) Authority(opts *bind.CallOpts) (common.Address, error)

Authority is a free data retrieval call binding the contract method 0xbf7e214f.

Solidity: function authority() constant returns(address)

func (*RootChainCaller) ChildBlockInterval 

func (_RootChain *RootChainCaller) ChildBlockInterval(opts *bind.CallOpts) (*big.Int, error)

ChildBlockInterval is a free data retrieval call binding the contract method 0x38a9e0bc.

Solidity: function childBlockInterval() constant returns(uint256)

func (*RootChainCaller) ChildChain 

func (_RootChain *RootChainCaller) ChildChain(opts *bind.CallOpts, arg0 *big.Int) (struct {
	Root      [32]byte
	CreatedAt *big.Int
}, error)

ChildChain is a free data retrieval call binding the contract method 0xf95643b1.

Solidity: function childChain( uint256) constant returns(root bytes32, created_at uint256)

func (*RootChainCaller) CurrentChildBlock 

func (_RootChain *RootChainCaller) CurrentChildBlock(opts *bind.CallOpts) (*big.Int, error)

CurrentChildBlock is a free data retrieval call binding the contract method 0x7a95f1e8.

Solidity: function currentChildBlock() constant returns(uint256)

func (*RootChainCaller) CurrentDepositBlock 

func (_RootChain *RootChainCaller) CurrentDepositBlock(opts *bind.CallOpts) (*big.Int, error)

CurrentDepositBlock is a free data retrieval call binding the contract method 0xa98c7f2c.

Solidity: function currentDepositBlock() constant returns(uint256)

func (*RootChainCaller) ExitIds 

func (_RootChain *RootChainCaller) ExitIds(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error)

ExitIds is a free data retrieval call binding the contract method 0x16b38840.

Solidity: function exitIds( uint256) constant returns(uint256)

func (*RootChainCaller) Exits 

func (_RootChain *RootChainCaller) Exits(opts *bind.CallOpts, arg0 *big.Int) (struct {
	Owner   common.Address
	Amount  *big.Int
	UtxoPos *big.Int
}, error)

Exits is a free data retrieval call binding the contract method 0x342de179.

Solidity: function exits( uint256) constant returns(owner address, amount uint256, utxoPos uint256)

func (*RootChainCaller) GetChildChain 

func (_RootChain *RootChainCaller) GetChildChain(opts *bind.CallOpts, blockNumber *big.Int) ([32]byte, *big.Int, error)

GetChildChain is a free data retrieval call binding the contract method 0x85444de3.

Solidity: function getChildChain(blockNumber uint256) constant returns(bytes32, uint256)

func (*RootChainCaller) GetDepositBlock 

func (_RootChain *RootChainCaller) GetDepositBlock(opts *bind.CallOpts) (*big.Int, error)

GetDepositBlock is a free data retrieval call binding the contract method 0xbcd59261.

Solidity: function getDepositBlock() constant returns(uint256)

func (*RootChainCaller) GetExit 

func (_RootChain *RootChainCaller) GetExit(opts *bind.CallOpts, priority *big.Int) (common.Address, *big.Int, *big.Int, error)

GetExit is a free data retrieval call binding the contract method 0xe60f1ff1.

Solidity: function getExit(priority uint256) constant returns(address, uint256, uint256)

func (*RootChainCaller) NextWeekOldChildBlock 

func (_RootChain *RootChainCaller) NextWeekOldChildBlock(opts *bind.CallOpts, value *big.Int) (*big.Int, error)

NextWeekOldChildBlock is a free data retrieval call binding the contract method 0x107e58f1.

Solidity: function nextWeekOldChildBlock(value uint256) constant returns(uint256)

func (*RootChainCaller) RecentBlock 

func (_RootChain *RootChainCaller) RecentBlock(opts *bind.CallOpts) (*big.Int, error)

RecentBlock is a free data retrieval call binding the contract method 0x6f84b695.

Solidity: function recentBlock() constant returns(uint256)

func (*RootChainCaller) WeekOldBlock 

func (_RootChain *RootChainCaller) WeekOldBlock(opts *bind.CallOpts) (*big.Int, error)

WeekOldBlock is a free data retrieval call binding the contract method 0x4237b5f3.

Solidity: function weekOldBlock() constant returns(uint256)

type RootChainCallerRaw 

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

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

func (*RootChainCallerRaw) Call 

func (_RootChain *RootChainCallerRaw) 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 RootChainCallerSession 

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

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

func (*RootChainCallerSession) Authority 

func (_RootChain *RootChainCallerSession) Authority() (common.Address, error)

Authority is a free data retrieval call binding the contract method 0xbf7e214f.

Solidity: function authority() constant returns(address)

func (*RootChainCallerSession) ChildBlockInterval 

func (_RootChain *RootChainCallerSession) ChildBlockInterval() (*big.Int, error)

ChildBlockInterval is a free data retrieval call binding the contract method 0x38a9e0bc.

Solidity: function childBlockInterval() constant returns(uint256)

func (*RootChainCallerSession) ChildChain 

func (_RootChain *RootChainCallerSession) ChildChain(arg0 *big.Int) (struct {
	Root      [32]byte
	CreatedAt *big.Int
}, error)

ChildChain is a free data retrieval call binding the contract method 0xf95643b1.

Solidity: function childChain( uint256) constant returns(root bytes32, created_at uint256)

func (*RootChainCallerSession) CurrentChildBlock 

func (_RootChain *RootChainCallerSession) CurrentChildBlock() (*big.Int, error)

CurrentChildBlock is a free data retrieval call binding the contract method 0x7a95f1e8.

Solidity: function currentChildBlock() constant returns(uint256)

func (*RootChainCallerSession) CurrentDepositBlock 

func (_RootChain *RootChainCallerSession) CurrentDepositBlock() (*big.Int, error)

CurrentDepositBlock is a free data retrieval call binding the contract method 0xa98c7f2c.

Solidity: function currentDepositBlock() constant returns(uint256)

func (*RootChainCallerSession) ExitIds 

func (_RootChain *RootChainCallerSession) ExitIds(arg0 *big.Int) (*big.Int, error)

ExitIds is a free data retrieval call binding the contract method 0x16b38840.

Solidity: function exitIds( uint256) constant returns(uint256)

func (*RootChainCallerSession) Exits 

func (_RootChain *RootChainCallerSession) Exits(arg0 *big.Int) (struct {
	Owner   common.Address
	Amount  *big.Int
	UtxoPos *big.Int
}, error)

Exits is a free data retrieval call binding the contract method 0x342de179.

Solidity: function exits( uint256) constant returns(owner address, amount uint256, utxoPos uint256)

func (*RootChainCallerSession) GetChildChain 

func (_RootChain *RootChainCallerSession) GetChildChain(blockNumber *big.Int) ([32]byte, *big.Int, error)

GetChildChain is a free data retrieval call binding the contract method 0x85444de3.

Solidity: function getChildChain(blockNumber uint256) constant returns(bytes32, uint256)

func (*RootChainCallerSession) GetDepositBlock 

func (_RootChain *RootChainCallerSession) GetDepositBlock() (*big.Int, error)

GetDepositBlock is a free data retrieval call binding the contract method 0xbcd59261.

Solidity: function getDepositBlock() constant returns(uint256)

func (*RootChainCallerSession) GetExit 

func (_RootChain *RootChainCallerSession) GetExit(priority *big.Int) (common.Address, *big.Int, *big.Int, error)

GetExit is a free data retrieval call binding the contract method 0xe60f1ff1.

Solidity: function getExit(priority uint256) constant returns(address, uint256, uint256)

func (*RootChainCallerSession) NextWeekOldChildBlock 

func (_RootChain *RootChainCallerSession) NextWeekOldChildBlock(value *big.Int) (*big.Int, error)

NextWeekOldChildBlock is a free data retrieval call binding the contract method 0x107e58f1.

Solidity: function nextWeekOldChildBlock(value uint256) constant returns(uint256)

func (*RootChainCallerSession) RecentBlock 

func (_RootChain *RootChainCallerSession) RecentBlock() (*big.Int, error)

RecentBlock is a free data retrieval call binding the contract method 0x6f84b695.

Solidity: function recentBlock() constant returns(uint256)

func (*RootChainCallerSession) WeekOldBlock 

func (_RootChain *RootChainCallerSession) WeekOldBlock() (*big.Int, error)

WeekOldBlock is a free data retrieval call binding the contract method 0x4237b5f3.

Solidity: function weekOldBlock() constant returns(uint256)

type RootChainDeposit 

type RootChainDeposit struct {
	Depositor common.Address
	Amount    *big.Int
	Raw       types.Log // Blockchain specific contextual infos
}

RootChainDeposit represents a Deposit event raised by the RootChain contract.

type RootChainDepositIterator 

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

RootChainDepositIterator is returned from FilterDeposit and is used to iterate over the raw logs and unpacked data for Deposit events raised by the RootChain contract.

func (*RootChainDepositIterator) Close 

func (it *RootChainDepositIterator) Close() error

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

func (*RootChainDepositIterator) Error 

func (it *RootChainDepositIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainDepositIterator) Next 

func (it *RootChainDepositIterator) 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 RootChainExit 

type RootChainExit struct {
	Exitor  common.Address
	UtxoPos *big.Int
	Raw     types.Log // Blockchain specific contextual infos
}

RootChainExit represents a Exit event raised by the RootChain contract.

type RootChainExitIterator 

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

RootChainExitIterator is returned from FilterExit and is used to iterate over the raw logs and unpacked data for Exit events raised by the RootChain contract.

func (*RootChainExitIterator) Close 

func (it *RootChainExitIterator) Close() error

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

func (*RootChainExitIterator) Error 

func (it *RootChainExitIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainExitIterator) Next 

func (it *RootChainExitIterator) 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 RootChainFilterer 

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

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

func NewRootChainFilterer 

func NewRootChainFilterer(address common.Address, filterer bind.ContractFilterer) (*RootChainFilterer, error)

NewRootChainFilterer creates a new log filterer instance of RootChain, bound to a specific deployed contract.

func (*RootChainFilterer) FilterDeposit 

func (_RootChain *RootChainFilterer) FilterDeposit(opts *bind.FilterOpts) (*RootChainDepositIterator, error)

FilterDeposit is a free log retrieval operation binding the contract event 0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c.

Solidity: event Deposit(depositor address, amount uint256)

func (*RootChainFilterer) FilterExit 

func (_RootChain *RootChainFilterer) FilterExit(opts *bind.FilterOpts) (*RootChainExitIterator, error)

FilterExit is a free log retrieval operation binding the contract event 0x22d324652c93739755cf4581508b60875ebdd78c20c0cff5cf8e23452b299631.

Solidity: event Exit(exitor address, utxoPos uint256)

func (*RootChainFilterer) WatchDeposit 

func (_RootChain *RootChainFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *RootChainDeposit) (event.Subscription, error)

WatchDeposit is a free log subscription operation binding the contract event 0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c.

Solidity: event Deposit(depositor address, amount uint256)

func (*RootChainFilterer) WatchExit 

func (_RootChain *RootChainFilterer) WatchExit(opts *bind.WatchOpts, sink chan<- *RootChainExit) (event.Subscription, error)

WatchExit is a free log subscription operation binding the contract event 0x22d324652c93739755cf4581508b60875ebdd78c20c0cff5cf8e23452b299631.

Solidity: event Exit(exitor address, utxoPos uint256)

type RootChainRaw 

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

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

func (*RootChainRaw) Call 

func (_RootChain *RootChainRaw) 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 (*RootChainRaw) Transact 

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

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

func (*RootChainRaw) Transfer 

func (_RootChain *RootChainRaw) 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 RootChainSession 

type RootChainSession struct {
	Contract     *RootChain        // 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
}

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

func (*RootChainSession) Authority 

func (_RootChain *RootChainSession) Authority() (common.Address, error)

Authority is a free data retrieval call binding the contract method 0xbf7e214f.

Solidity: function authority() constant returns(address)

func (*RootChainSession) ChallengeExit 

func (_RootChain *RootChainSession) ChallengeExit(cUtxoPos *big.Int, eUtxoPos *big.Int, txBytes []byte, proof []byte, sigs []byte, confirmationSig []byte) (*types.Transaction, error)

ChallengeExit is a paid mutator transaction binding the contract method 0x32773ba3.

Solidity: function challengeExit(cUtxoPos uint256, eUtxoPos uint256, txBytes bytes, proof bytes, sigs bytes, confirmationSig bytes) returns()

func (*RootChainSession) ChildBlockInterval 

func (_RootChain *RootChainSession) ChildBlockInterval() (*big.Int, error)

ChildBlockInterval is a free data retrieval call binding the contract method 0x38a9e0bc.

Solidity: function childBlockInterval() constant returns(uint256)

func (*RootChainSession) ChildChain 

func (_RootChain *RootChainSession) ChildChain(arg0 *big.Int) (struct {
	Root      [32]byte
	CreatedAt *big.Int
}, error)

ChildChain is a free data retrieval call binding the contract method 0xf95643b1.

Solidity: function childChain( uint256) constant returns(root bytes32, created_at uint256)

func (*RootChainSession) CurrentChildBlock 

func (_RootChain *RootChainSession) CurrentChildBlock() (*big.Int, error)

CurrentChildBlock is a free data retrieval call binding the contract method 0x7a95f1e8.

Solidity: function currentChildBlock() constant returns(uint256)

func (*RootChainSession) CurrentDepositBlock 

func (_RootChain *RootChainSession) CurrentDepositBlock() (*big.Int, error)

CurrentDepositBlock is a free data retrieval call binding the contract method 0xa98c7f2c.

Solidity: function currentDepositBlock() constant returns(uint256)

func (*RootChainSession) Deposit 

func (_RootChain *RootChainSession) Deposit() (*types.Transaction, error)

Deposit is a paid mutator transaction binding the contract method 0xd0e30db0.

Solidity: function deposit() returns()

func (*RootChainSession) ExitIds 

func (_RootChain *RootChainSession) ExitIds(arg0 *big.Int) (*big.Int, error)

ExitIds is a free data retrieval call binding the contract method 0x16b38840.

Solidity: function exitIds( uint256) constant returns(uint256)

func (*RootChainSession) Exits 

func (_RootChain *RootChainSession) Exits(arg0 *big.Int) (struct {
	Owner   common.Address
	Amount  *big.Int
	UtxoPos *big.Int
}, error)

Exits is a free data retrieval call binding the contract method 0x342de179.

Solidity: function exits( uint256) constant returns(owner address, amount uint256, utxoPos uint256)

func (*RootChainSession) FinalizeExits 

func (_RootChain *RootChainSession) FinalizeExits() (*types.Transaction, error)

FinalizeExits is a paid mutator transaction binding the contract method 0xc6ab44cd.

Solidity: function finalizeExits() returns(uint256)

func (*RootChainSession) GetChildChain 

func (_RootChain *RootChainSession) GetChildChain(blockNumber *big.Int) ([32]byte, *big.Int, error)

GetChildChain is a free data retrieval call binding the contract method 0x85444de3.

Solidity: function getChildChain(blockNumber uint256) constant returns(bytes32, uint256)

func (*RootChainSession) GetDepositBlock 

func (_RootChain *RootChainSession) GetDepositBlock() (*big.Int, error)

GetDepositBlock is a free data retrieval call binding the contract method 0xbcd59261.

Solidity: function getDepositBlock() constant returns(uint256)

func (*RootChainSession) GetExit 

func (_RootChain *RootChainSession) GetExit(priority *big.Int) (common.Address, *big.Int, *big.Int, error)

GetExit is a free data retrieval call binding the contract method 0xe60f1ff1.

Solidity: function getExit(priority uint256) constant returns(address, uint256, uint256)

func (*RootChainSession) NextWeekOldChildBlock 

func (_RootChain *RootChainSession) NextWeekOldChildBlock(value *big.Int) (*big.Int, error)

NextWeekOldChildBlock is a free data retrieval call binding the contract method 0x107e58f1.

Solidity: function nextWeekOldChildBlock(value uint256) constant returns(uint256)

func (*RootChainSession) RecentBlock 

func (_RootChain *RootChainSession) RecentBlock() (*big.Int, error)

RecentBlock is a free data retrieval call binding the contract method 0x6f84b695.

Solidity: function recentBlock() constant returns(uint256)

func (*RootChainSession) StartExit 

func (_RootChain *RootChainSession) StartExit(utxoPos *big.Int, txBytes []byte, proof []byte, sigs []byte) (*types.Transaction, error)

StartExit is a paid mutator transaction binding the contract method 0x1c91a6b9.

Solidity: function startExit(utxoPos uint256, txBytes bytes, proof bytes, sigs bytes) returns()

func (*RootChainSession) SubmitBlock 

func (_RootChain *RootChainSession) SubmitBlock(root [32]byte) (*types.Transaction, error)

SubmitBlock is a paid mutator transaction binding the contract method 0xbaa47694.

Solidity: function submitBlock(root bytes32) returns()

func (*RootChainSession) WeekOldBlock 

func (_RootChain *RootChainSession) WeekOldBlock() (*big.Int, error)

WeekOldBlock is a free data retrieval call binding the contract method 0x4237b5f3.

Solidity: function weekOldBlock() constant returns(uint256)

type RootChainTransactor 

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

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

func NewRootChainTransactor 

func NewRootChainTransactor(address common.Address, transactor bind.ContractTransactor) (*RootChainTransactor, error)

NewRootChainTransactor creates a new write-only instance of RootChain, bound to a specific deployed contract.

func (*RootChainTransactor) ChallengeExit 

func (_RootChain *RootChainTransactor) ChallengeExit(opts *bind.TransactOpts, cUtxoPos *big.Int, eUtxoPos *big.Int, txBytes []byte, proof []byte, sigs []byte, confirmationSig []byte) (*types.Transaction, error)

ChallengeExit is a paid mutator transaction binding the contract method 0x32773ba3.

Solidity: function challengeExit(cUtxoPos uint256, eUtxoPos uint256, txBytes bytes, proof bytes, sigs bytes, confirmationSig bytes) returns()

func (*RootChainTransactor) Deposit 

func (_RootChain *RootChainTransactor) Deposit(opts *bind.TransactOpts) (*types.Transaction, error)

Deposit is a paid mutator transaction binding the contract method 0xd0e30db0.

Solidity: function deposit() returns()

func (*RootChainTransactor) FinalizeExits 

func (_RootChain *RootChainTransactor) FinalizeExits(opts *bind.TransactOpts) (*types.Transaction, error)

FinalizeExits is a paid mutator transaction binding the contract method 0xc6ab44cd.

Solidity: function finalizeExits() returns(uint256)

func (*RootChainTransactor) StartExit 

func (_RootChain *RootChainTransactor) StartExit(opts *bind.TransactOpts, utxoPos *big.Int, txBytes []byte, proof []byte, sigs []byte) (*types.Transaction, error)

StartExit is a paid mutator transaction binding the contract method 0x1c91a6b9.

Solidity: function startExit(utxoPos uint256, txBytes bytes, proof bytes, sigs bytes) returns()

func (*RootChainTransactor) SubmitBlock 

func (_RootChain *RootChainTransactor) SubmitBlock(opts *bind.TransactOpts, root [32]byte) (*types.Transaction, error)

SubmitBlock is a paid mutator transaction binding the contract method 0xbaa47694.

Solidity: function submitBlock(root bytes32) returns()

type RootChainTransactorRaw 

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

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

func (*RootChainTransactorRaw) Transact 

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

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

func (*RootChainTransactorRaw) Transfer 

func (_RootChain *RootChainTransactorRaw) 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 RootChainTransactorSession 

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

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

func (*RootChainTransactorSession) ChallengeExit 

func (_RootChain *RootChainTransactorSession) ChallengeExit(cUtxoPos *big.Int, eUtxoPos *big.Int, txBytes []byte, proof []byte, sigs []byte, confirmationSig []byte) (*types.Transaction, error)

ChallengeExit is a paid mutator transaction binding the contract method 0x32773ba3.

Solidity: function challengeExit(cUtxoPos uint256, eUtxoPos uint256, txBytes bytes, proof bytes, sigs bytes, confirmationSig bytes) returns()

func (*RootChainTransactorSession) Deposit 

func (_RootChain *RootChainTransactorSession) Deposit() (*types.Transaction, error)

Deposit is a paid mutator transaction binding the contract method 0xd0e30db0.

Solidity: function deposit() returns()

func (*RootChainTransactorSession) FinalizeExits 

func (_RootChain *RootChainTransactorSession) FinalizeExits() (*types.Transaction, error)

FinalizeExits is a paid mutator transaction binding the contract method 0xc6ab44cd.

Solidity: function finalizeExits() returns(uint256)

func (*RootChainTransactorSession) StartExit 

func (_RootChain *RootChainTransactorSession) StartExit(utxoPos *big.Int, txBytes []byte, proof []byte, sigs []byte) (*types.Transaction, error)

StartExit is a paid mutator transaction binding the contract method 0x1c91a6b9.

Solidity: function startExit(utxoPos uint256, txBytes bytes, proof bytes, sigs bytes) returns()

func (*RootChainTransactorSession) SubmitBlock 

func (_RootChain *RootChainTransactorSession) SubmitBlock(root [32]byte) (*types.Transaction, error)

SubmitBlock is a paid mutator transaction binding the contract method 0xbaa47694.

Solidity: function submitBlock(root bytes32) returns()

type SafeMath 

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

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

func DeploySafeMath 

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

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

func NewSafeMath 

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

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

type SafeMathCaller 

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

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

func NewSafeMathCaller 

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

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

type SafeMathCallerRaw 

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

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

func (*SafeMathCallerRaw) Call 

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

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

type SafeMathCallerSession 

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

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

type SafeMathFilterer 

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

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

func NewSafeMathFilterer 

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

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

type SafeMathRaw 

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

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

func (*SafeMathRaw) Call 

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

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

func (*SafeMathRaw) Transact 

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

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

func (*SafeMathRaw) Transfer 

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

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

type SafeMathSession 

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

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

type SafeMathTransactor 

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

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

func NewSafeMathTransactor 

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

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

type SafeMathTransactorRaw 

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

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

func (*SafeMathTransactorRaw) Transact 

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

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

func (*SafeMathTransactorRaw) Transfer 

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

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

type SafeMathTransactorSession 

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

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

type Validate 

type Validate struct {
	ValidateCaller     // Read-only binding to the contract
	ValidateTransactor // Write-only binding to the contract
	ValidateFilterer   // Log filterer for contract events
}

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

func DeployValidate 

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

DeployValidate deploys a new Ethereum contract, binding an instance of Validate to it.

func NewValidate 

func NewValidate(address common.Address, backend bind.ContractBackend) (*Validate, error)

NewValidate creates a new instance of Validate, bound to a specific deployed contract.

type ValidateCaller 

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

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

func NewValidateCaller 

func NewValidateCaller(address common.Address, caller bind.ContractCaller) (*ValidateCaller, error)

NewValidateCaller creates a new read-only instance of Validate, bound to a specific deployed contract.

type ValidateCallerRaw 

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

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

func (*ValidateCallerRaw) Call 

func (_Validate *ValidateCallerRaw) 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 ValidateCallerSession 

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

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

type ValidateFilterer 

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

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

func NewValidateFilterer 

func NewValidateFilterer(address common.Address, filterer bind.ContractFilterer) (*ValidateFilterer, error)

NewValidateFilterer creates a new log filterer instance of Validate, bound to a specific deployed contract.

type ValidateRaw 

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

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

func (*ValidateRaw) Call 

func (_Validate *ValidateRaw) 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 (*ValidateRaw) Transact 

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

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

func (*ValidateRaw) Transfer 

func (_Validate *ValidateRaw) 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 ValidateSession 

type ValidateSession struct {
	Contract     *Validate         // 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
}

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

type ValidateTransactor 

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

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

func NewValidateTransactor 

func NewValidateTransactor(address common.Address, transactor bind.ContractTransactor) (*ValidateTransactor, error)

NewValidateTransactor creates a new write-only instance of Validate, bound to a specific deployed contract.

type ValidateTransactorRaw 

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

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

func (*ValidateTransactorRaw) Transact 

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

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

func (*ValidateTransactorRaw) Transfer 

func (_Validate *ValidateTransactorRaw) 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 ValidateTransactorSession 

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

ValidateTransactorSession 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.