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.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL