epochhandler

package
v0.0.0-rc5.2 Latest Latest
Warning

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

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

Documentation

Index

Constants

View Source 
const AddressABI = "[]"

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

View Source 
const BMTABI = "[]"

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

View Source 
const DataABI = "" /* 1071-byte string literal not displayed */

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

View Source 
const EpochHandlerABI = "" /* 18870-byte string literal not displayed */

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

View Source 
const MathABI = "[]"

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

View Source 
const RLPABI = "[]"

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

View Source 
const RLPEncodeABI = "[]"

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

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

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

View Source 
const RootChainEventABI = "" /* 6899-byte string literal not displayed */

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

View Source 
const RootChainStorageABI = "" /* 11129-byte string literal not displayed */

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

View Source 
const SafeMathABI = "[]"

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

Variables

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

AddressBin is the compiled bytecode used for deploying new contracts.

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

BMTBin is the compiled bytecode used for deploying new contracts.

View Source 
var DataBin = "" /* 1004-byte string literal not displayed */

DataBin is the compiled bytecode used for deploying new contracts.

View Source 
var DataFuncSigs = map[string]string{
	"a89ca766": "APPLY_IN_CHILDCHAIN_SIGNATURE()",
	"a7b6ae28": "APPLY_IN_ROOTCHAIN_SIGNATURE()",
	"ab73ff05": "NA()",
	"90e84f56": "NA_TX_GAS_LIMIT()",
	"1927ac58": "NA_TX_GAS_PRICE()",
}

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

View Source 
var EpochHandlerBin = "" /* 20506-byte string literal not displayed */

EpochHandlerBin is the compiled bytecode used for deploying new contracts.

View Source 
var EpochHandlerFuncSigs = map[string]string{
	"d691acd8": "COST_ERO()",
	"8b5172d0": "COST_ERU()",
	"94be3aa5": "COST_NRB()",
	"b2ae9ba8": "COST_ORB()",
	"192adc5b": "COST_URB()",
	"033cfbed": "COST_URB_PREPARE()",
	"08c4fff0": "CP_COMPUTATION()",
	"8155717d": "CP_EXIT()",
	"b17fa6e9": "CP_WITHHOLDING()",
	"2dc6bb7b": "EROIdToFinalize()",
	"b443f3cc": "EROs(uint256)",
	"c54626cc": "ERUIdToFinalize()",
	"f4f31de4": "ERUs(uint256)",
	"ab96da2d": "NRELength()",
	"de0ce17d": "NULL_ADDRESS()",
	"ea7f22a8": "ORBs(uint256)",
	"c2bc88fa": "PREPARE_TIMEOUT()",
	"8eb288ca": "REQUEST_GAS()",
	"c0e86064": "URBs(uint256)",
	"183d2d1c": "currentFork()",
	"7b929c27": "development()",
	"e7b88b80": "epochHandler()",
	"b8066bcb": "etherToken()",
	"72ecb9a8": "firstFilledORENumber(uint256)",
	"ca6f6380": "firstNonEmptyRequestEpoch(uint256)",
	"4ba3a126": "forks(uint256)",
	"420bb4b8": "isRootChain()",
	"fb788a27": "lastAppliedBlockNumber()",
	"c8ad329f": "lastAppliedEpochNumber()",
	"164bc2ae": "lastAppliedForkNumber()",
	"b6715647": "lastNonEmptyRequestEpoch(uint256)",
	"23691566": "numEnterForORB()",
	"570ca735": "operator()",
	"03787fa2": "prepareNRE()",
	"5656225b": "prepareNREAfterURE()",
	"12d87f07": "prepareORE()",
	"5e9ef4f3": "prepareOREAfterURE()",
	"e6925d08": "prepareToSubmitURB()",
	"da0185f8": "requestableContracts(address)",
	"6fb7f558": "seigManager()",
	"e259faf7": "submitHandler()",
}

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

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

MathBin is the compiled bytecode used for deploying new contracts.

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

RLPBin is the compiled bytecode used for deploying new contracts.

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

RLPEncodeBin is the compiled bytecode used for deploying new contracts.

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

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

View Source 
var RootChainEventBin = "" /* 184-byte string literal not displayed */

RootChainEventBin is the compiled bytecode used for deploying new contracts.

View Source 
var RootChainStorageBin = "" /* 4844-byte string literal not displayed */

RootChainStorageBin is the compiled bytecode used for deploying new contracts.

View Source 
var RootChainStorageFuncSigs = map[string]string{
	"d691acd8": "COST_ERO()",
	"8b5172d0": "COST_ERU()",
	"94be3aa5": "COST_NRB()",
	"b2ae9ba8": "COST_ORB()",
	"192adc5b": "COST_URB()",
	"033cfbed": "COST_URB_PREPARE()",
	"08c4fff0": "CP_COMPUTATION()",
	"8155717d": "CP_EXIT()",
	"b17fa6e9": "CP_WITHHOLDING()",
	"2dc6bb7b": "EROIdToFinalize()",
	"b443f3cc": "EROs(uint256)",
	"c54626cc": "ERUIdToFinalize()",
	"f4f31de4": "ERUs(uint256)",
	"ab96da2d": "NRELength()",
	"de0ce17d": "NULL_ADDRESS()",
	"ea7f22a8": "ORBs(uint256)",
	"c2bc88fa": "PREPARE_TIMEOUT()",
	"8eb288ca": "REQUEST_GAS()",
	"c0e86064": "URBs(uint256)",
	"183d2d1c": "currentFork()",
	"7b929c27": "development()",
	"e7b88b80": "epochHandler()",
	"b8066bcb": "etherToken()",
	"72ecb9a8": "firstFilledORENumber(uint256)",
	"ca6f6380": "firstNonEmptyRequestEpoch(uint256)",
	"4ba3a126": "forks(uint256)",
	"420bb4b8": "isRootChain()",
	"fb788a27": "lastAppliedBlockNumber()",
	"c8ad329f": "lastAppliedEpochNumber()",
	"164bc2ae": "lastAppliedForkNumber()",
	"b6715647": "lastNonEmptyRequestEpoch(uint256)",
	"23691566": "numEnterForORB()",
	"570ca735": "operator()",
	"da0185f8": "requestableContracts(address)",
	"6fb7f558": "seigManager()",
	"e259faf7": "submitHandler()",
}

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

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

SafeMathBin is the compiled bytecode used for deploying new contracts.

Functions

This section is empty.

Types

type Address 

type Address struct {
	AddressCaller     // Read-only binding to the contract
	AddressTransactor // Write-only binding to the contract
	AddressFilterer   // Log filterer for contract events
}

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

func DeployAddress 

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

DeployAddress deploys a new Ethereum contract, binding an instance of Address to it.

func NewAddress 

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

NewAddress creates a new instance of Address, bound to a specific deployed contract.

type AddressCaller 

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

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

func NewAddressCaller 

func NewAddressCaller(address common.Address, caller bind.ContractCaller) (*AddressCaller, error)

NewAddressCaller creates a new read-only instance of Address, bound to a specific deployed contract.

type AddressCallerRaw 

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

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

func (*AddressCallerRaw) Call 

func (_Address *AddressCallerRaw) 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 AddressCallerSession 

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

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

type AddressFilterer 

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

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

func NewAddressFilterer 

func NewAddressFilterer(address common.Address, filterer bind.ContractFilterer) (*AddressFilterer, error)

NewAddressFilterer creates a new log filterer instance of Address, bound to a specific deployed contract.

type AddressRaw 

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

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

func (*AddressRaw) Call 

func (_Address *AddressRaw) 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 (*AddressRaw) Transact 

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

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

func (*AddressRaw) Transfer 

func (_Address *AddressRaw) 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 AddressSession 

type AddressSession struct {
	Contract     *Address          // 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
}

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

type AddressTransactor 

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

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

func NewAddressTransactor 

func NewAddressTransactor(address common.Address, transactor bind.ContractTransactor) (*AddressTransactor, error)

NewAddressTransactor creates a new write-only instance of Address, bound to a specific deployed contract.

type AddressTransactorRaw 

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

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

func (*AddressTransactorRaw) Transact 

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

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

func (*AddressTransactorRaw) Transfer 

func (_Address *AddressTransactorRaw) 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 AddressTransactorSession 

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

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

type BMT 

type BMT struct {
	BMTCaller     // Read-only binding to the contract
	BMTTransactor // Write-only binding to the contract
	BMTFilterer   // Log filterer for contract events
}

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

func DeployBMT 

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

DeployBMT deploys a new Ethereum contract, binding an instance of BMT to it.

func NewBMT 

func NewBMT(address common.Address, backend bind.ContractBackend) (*BMT, error)

NewBMT creates a new instance of BMT, bound to a specific deployed contract.

type BMTCaller 

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

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

func NewBMTCaller 

func NewBMTCaller(address common.Address, caller bind.ContractCaller) (*BMTCaller, error)

NewBMTCaller creates a new read-only instance of BMT, bound to a specific deployed contract.

type BMTCallerRaw 

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

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

func (*BMTCallerRaw) Call 

func (_BMT *BMTCallerRaw) 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 BMTCallerSession 

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

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

type BMTFilterer 

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

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

func NewBMTFilterer 

func NewBMTFilterer(address common.Address, filterer bind.ContractFilterer) (*BMTFilterer, error)

NewBMTFilterer creates a new log filterer instance of BMT, bound to a specific deployed contract.

type BMTRaw 

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

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

func (*BMTRaw) Call 

func (_BMT *BMTRaw) 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 (*BMTRaw) Transact 

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

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

func (*BMTRaw) Transfer 

func (_BMT *BMTRaw) 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 BMTSession 

type BMTSession struct {
	Contract     *BMT              // 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
}

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

type BMTTransactor 

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

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

func NewBMTTransactor 

func NewBMTTransactor(address common.Address, transactor bind.ContractTransactor) (*BMTTransactor, error)

NewBMTTransactor creates a new write-only instance of BMT, bound to a specific deployed contract.

type BMTTransactorRaw 

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

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

func (*BMTTransactorRaw) Transact 

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

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

func (*BMTTransactorRaw) Transfer 

func (_BMT *BMTTransactorRaw) 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 BMTTransactorSession 

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

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

type Data 

type Data struct {
	DataCaller     // Read-only binding to the contract
	DataTransactor // Write-only binding to the contract
	DataFilterer   // Log filterer for contract events
}

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

func DeployData 

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

DeployData deploys a new Ethereum contract, binding an instance of Data to it.

func NewData 

func NewData(address common.Address, backend bind.ContractBackend) (*Data, error)

NewData creates a new instance of Data, bound to a specific deployed contract.

type DataCaller 

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

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

func NewDataCaller 

func NewDataCaller(address common.Address, caller bind.ContractCaller) (*DataCaller, error)

NewDataCaller creates a new read-only instance of Data, bound to a specific deployed contract.

func (*DataCaller) APPLYINCHILDCHAINSIGNATURE 

func (_Data *DataCaller) APPLYINCHILDCHAINSIGNATURE(opts *bind.CallOpts) ([4]byte, error)

APPLYINCHILDCHAINSIGNATURE is a free data retrieval call binding the contract method 0xa89ca766.

Solidity: function APPLY_IN_CHILDCHAIN_SIGNATURE() constant returns(bytes4)

func (*DataCaller) APPLYINROOTCHAINSIGNATURE 

func (_Data *DataCaller) APPLYINROOTCHAINSIGNATURE(opts *bind.CallOpts) ([4]byte, error)

APPLYINROOTCHAINSIGNATURE is a free data retrieval call binding the contract method 0xa7b6ae28.

Solidity: function APPLY_IN_ROOTCHAIN_SIGNATURE() constant returns(bytes4)

func (*DataCaller) NA 

func (_Data *DataCaller) NA(opts *bind.CallOpts) (common.Address, error)

NA is a free data retrieval call binding the contract method 0xab73ff05.

Solidity: function NA() constant returns(address)

func (*DataCaller) NATXGASLIMIT 

func (_Data *DataCaller) NATXGASLIMIT(opts *bind.CallOpts) (*big.Int, error)

NATXGASLIMIT is a free data retrieval call binding the contract method 0x90e84f56.

Solidity: function NA_TX_GAS_LIMIT() constant returns(uint256)

func (*DataCaller) NATXGASPRICE 

func (_Data *DataCaller) NATXGASPRICE(opts *bind.CallOpts) (*big.Int, error)

NATXGASPRICE is a free data retrieval call binding the contract method 0x1927ac58.

Solidity: function NA_TX_GAS_PRICE() constant returns(uint256)

type DataCallerRaw 

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

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

func (*DataCallerRaw) Call 

func (_Data *DataCallerRaw) 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 DataCallerSession 

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

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

func (*DataCallerSession) APPLYINCHILDCHAINSIGNATURE 

func (_Data *DataCallerSession) APPLYINCHILDCHAINSIGNATURE() ([4]byte, error)

APPLYINCHILDCHAINSIGNATURE is a free data retrieval call binding the contract method 0xa89ca766.

Solidity: function APPLY_IN_CHILDCHAIN_SIGNATURE() constant returns(bytes4)

func (*DataCallerSession) APPLYINROOTCHAINSIGNATURE 

func (_Data *DataCallerSession) APPLYINROOTCHAINSIGNATURE() ([4]byte, error)

APPLYINROOTCHAINSIGNATURE is a free data retrieval call binding the contract method 0xa7b6ae28.

Solidity: function APPLY_IN_ROOTCHAIN_SIGNATURE() constant returns(bytes4)

func (*DataCallerSession) NA 

func (_Data *DataCallerSession) NA() (common.Address, error)

NA is a free data retrieval call binding the contract method 0xab73ff05.

Solidity: function NA() constant returns(address)

func (*DataCallerSession) NATXGASLIMIT 

func (_Data *DataCallerSession) NATXGASLIMIT() (*big.Int, error)

NATXGASLIMIT is a free data retrieval call binding the contract method 0x90e84f56.

Solidity: function NA_TX_GAS_LIMIT() constant returns(uint256)

func (*DataCallerSession) NATXGASPRICE 

func (_Data *DataCallerSession) NATXGASPRICE() (*big.Int, error)

NATXGASPRICE is a free data retrieval call binding the contract method 0x1927ac58.

Solidity: function NA_TX_GAS_PRICE() constant returns(uint256)

type DataFilterer 

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

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

func NewDataFilterer 

func NewDataFilterer(address common.Address, filterer bind.ContractFilterer) (*DataFilterer, error)

NewDataFilterer creates a new log filterer instance of Data, bound to a specific deployed contract.

type DataRaw 

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

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

func (*DataRaw) Call 

func (_Data *DataRaw) 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 (*DataRaw) Transact 

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

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

func (*DataRaw) Transfer 

func (_Data *DataRaw) 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 DataSession 

type DataSession struct {
	Contract     *Data             // 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
}

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

func (*DataSession) APPLYINCHILDCHAINSIGNATURE 

func (_Data *DataSession) APPLYINCHILDCHAINSIGNATURE() ([4]byte, error)

APPLYINCHILDCHAINSIGNATURE is a free data retrieval call binding the contract method 0xa89ca766.

Solidity: function APPLY_IN_CHILDCHAIN_SIGNATURE() constant returns(bytes4)

func (*DataSession) APPLYINROOTCHAINSIGNATURE 

func (_Data *DataSession) APPLYINROOTCHAINSIGNATURE() ([4]byte, error)

APPLYINROOTCHAINSIGNATURE is a free data retrieval call binding the contract method 0xa7b6ae28.

Solidity: function APPLY_IN_ROOTCHAIN_SIGNATURE() constant returns(bytes4)

func (*DataSession) NA 

func (_Data *DataSession) NA() (common.Address, error)

NA is a free data retrieval call binding the contract method 0xab73ff05.

Solidity: function NA() constant returns(address)

func (*DataSession) NATXGASLIMIT 

func (_Data *DataSession) NATXGASLIMIT() (*big.Int, error)

NATXGASLIMIT is a free data retrieval call binding the contract method 0x90e84f56.

Solidity: function NA_TX_GAS_LIMIT() constant returns(uint256)

func (*DataSession) NATXGASPRICE 

func (_Data *DataSession) NATXGASPRICE() (*big.Int, error)

NATXGASPRICE is a free data retrieval call binding the contract method 0x1927ac58.

Solidity: function NA_TX_GAS_PRICE() constant returns(uint256)

type DataTransactor 

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

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

func NewDataTransactor 

func NewDataTransactor(address common.Address, transactor bind.ContractTransactor) (*DataTransactor, error)

NewDataTransactor creates a new write-only instance of Data, bound to a specific deployed contract.

type DataTransactorRaw 

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

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

func (*DataTransactorRaw) Transact 

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

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

func (*DataTransactorRaw) Transfer 

func (_Data *DataTransactorRaw) 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 DataTransactorSession 

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

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

type EpochHandler 

type EpochHandler struct {
	EpochHandlerCaller     // Read-only binding to the contract
	EpochHandlerTransactor // Write-only binding to the contract
	EpochHandlerFilterer   // Log filterer for contract events
}

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

func DeployEpochHandler 

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

DeployEpochHandler deploys a new Ethereum contract, binding an instance of EpochHandler to it.

func NewEpochHandler 

func NewEpochHandler(address common.Address, backend bind.ContractBackend) (*EpochHandler, error)

NewEpochHandler creates a new instance of EpochHandler, bound to a specific deployed contract.

type EpochHandlerBlockFinalized 

type EpochHandlerBlockFinalized struct {
	ForkNumber  *big.Int
	BlockNumber *big.Int
	Raw         types.Log // Blockchain specific contextual infos
}

EpochHandlerBlockFinalized represents a BlockFinalized event raised by the EpochHandler contract.

type EpochHandlerBlockFinalizedIterator 

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

EpochHandlerBlockFinalizedIterator is returned from FilterBlockFinalized and is used to iterate over the raw logs and unpacked data for BlockFinalized events raised by the EpochHandler contract.

func (*EpochHandlerBlockFinalizedIterator) Close 

func (it *EpochHandlerBlockFinalizedIterator) Close() error

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

func (*EpochHandlerBlockFinalizedIterator) Error 

func (it *EpochHandlerBlockFinalizedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EpochHandlerBlockFinalizedIterator) Next 

func (it *EpochHandlerBlockFinalizedIterator) 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 EpochHandlerBlockSubmitted 

type EpochHandlerBlockSubmitted struct {
	Fork          *big.Int
	EpochNumber   *big.Int
	BlockNumber   *big.Int
	IsRequest     bool
	UserActivated bool
	Raw           types.Log // Blockchain specific contextual infos
}

EpochHandlerBlockSubmitted represents a BlockSubmitted event raised by the EpochHandler contract.

type EpochHandlerBlockSubmittedIterator 

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

EpochHandlerBlockSubmittedIterator is returned from FilterBlockSubmitted and is used to iterate over the raw logs and unpacked data for BlockSubmitted events raised by the EpochHandler contract.

func (*EpochHandlerBlockSubmittedIterator) Close 

func (it *EpochHandlerBlockSubmittedIterator) Close() error

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

func (*EpochHandlerBlockSubmittedIterator) Error 

func (it *EpochHandlerBlockSubmittedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EpochHandlerBlockSubmittedIterator) Next 

func (it *EpochHandlerBlockSubmittedIterator) 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 EpochHandlerCaller 

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

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

func NewEpochHandlerCaller 

func NewEpochHandlerCaller(address common.Address, caller bind.ContractCaller) (*EpochHandlerCaller, error)

NewEpochHandlerCaller creates a new read-only instance of EpochHandler, bound to a specific deployed contract.

func (*EpochHandlerCaller) COSTERO 

func (_EpochHandler *EpochHandlerCaller) COSTERO(opts *bind.CallOpts) (*big.Int, error)

COSTERO is a free data retrieval call binding the contract method 0xd691acd8.

Solidity: function COST_ERO() constant returns(uint256)

func (*EpochHandlerCaller) COSTERU 

func (_EpochHandler *EpochHandlerCaller) COSTERU(opts *bind.CallOpts) (*big.Int, error)

COSTERU is a free data retrieval call binding the contract method 0x8b5172d0.

Solidity: function COST_ERU() constant returns(uint256)

func (*EpochHandlerCaller) COSTNRB 

func (_EpochHandler *EpochHandlerCaller) COSTNRB(opts *bind.CallOpts) (*big.Int, error)

COSTNRB is a free data retrieval call binding the contract method 0x94be3aa5.

Solidity: function COST_NRB() constant returns(uint256)

func (*EpochHandlerCaller) COSTORB 

func (_EpochHandler *EpochHandlerCaller) COSTORB(opts *bind.CallOpts) (*big.Int, error)

COSTORB is a free data retrieval call binding the contract method 0xb2ae9ba8.

Solidity: function COST_ORB() constant returns(uint256)

func (*EpochHandlerCaller) COSTURB 

func (_EpochHandler *EpochHandlerCaller) COSTURB(opts *bind.CallOpts) (*big.Int, error)

COSTURB is a free data retrieval call binding the contract method 0x192adc5b.

Solidity: function COST_URB() constant returns(uint256)

func (*EpochHandlerCaller) COSTURBPREPARE 

func (_EpochHandler *EpochHandlerCaller) COSTURBPREPARE(opts *bind.CallOpts) (*big.Int, error)

COSTURBPREPARE is a free data retrieval call binding the contract method 0x033cfbed.

Solidity: function COST_URB_PREPARE() constant returns(uint256)

func (*EpochHandlerCaller) CPCOMPUTATION 

func (_EpochHandler *EpochHandlerCaller) CPCOMPUTATION(opts *bind.CallOpts) (*big.Int, error)

CPCOMPUTATION is a free data retrieval call binding the contract method 0x08c4fff0.

Solidity: function CP_COMPUTATION() constant returns(uint256)

func (*EpochHandlerCaller) CPEXIT 

func (_EpochHandler *EpochHandlerCaller) CPEXIT(opts *bind.CallOpts) (*big.Int, error)

CPEXIT is a free data retrieval call binding the contract method 0x8155717d.

Solidity: function CP_EXIT() constant returns(uint256)

func (*EpochHandlerCaller) CPWITHHOLDING 

func (_EpochHandler *EpochHandlerCaller) CPWITHHOLDING(opts *bind.CallOpts) (*big.Int, error)

CPWITHHOLDING is a free data retrieval call binding the contract method 0xb17fa6e9.

Solidity: function CP_WITHHOLDING() constant returns(uint256)

func (*EpochHandlerCaller) CurrentFork 

func (_EpochHandler *EpochHandlerCaller) CurrentFork(opts *bind.CallOpts) (*big.Int, error)

CurrentFork is a free data retrieval call binding the contract method 0x183d2d1c.

Solidity: function currentFork() constant returns(uint256)

func (*EpochHandlerCaller) Development 

func (_EpochHandler *EpochHandlerCaller) Development(opts *bind.CallOpts) (bool, error)

Development is a free data retrieval call binding the contract method 0x7b929c27.

Solidity: function development() constant returns(bool)

func (*EpochHandlerCaller) EROIdToFinalize 

func (_EpochHandler *EpochHandlerCaller) EROIdToFinalize(opts *bind.CallOpts) (*big.Int, error)

EROIdToFinalize is a free data retrieval call binding the contract method 0x2dc6bb7b.

Solidity: function EROIdToFinalize() constant returns(uint256)

func (*EpochHandlerCaller) EROs 

func (_EpochHandler *EpochHandlerCaller) EROs(opts *bind.CallOpts, arg0 *big.Int) (struct {
	Timestamp  uint64
	IsExit     bool
	IsTransfer bool
	Finalized  bool
	Challenged bool
	Value      *big.Int
	Requestor  common.Address
	To         common.Address
	TrieKey    [32]byte
	Hash       [32]byte
	TrieValue  []byte
}, error)

EROs is a free data retrieval call binding the contract method 0xb443f3cc.

Solidity: function EROs(uint256 ) constant returns(uint64 timestamp, bool isExit, bool isTransfer, bool finalized, bool challenged, uint128 value, address requestor, address to, bytes32 trieKey, bytes32 hash, bytes trieValue)

func (*EpochHandlerCaller) ERUIdToFinalize 

func (_EpochHandler *EpochHandlerCaller) ERUIdToFinalize(opts *bind.CallOpts) (*big.Int, error)

ERUIdToFinalize is a free data retrieval call binding the contract method 0xc54626cc.

Solidity: function ERUIdToFinalize() constant returns(uint256)

func (*EpochHandlerCaller) ERUs 

func (_EpochHandler *EpochHandlerCaller) ERUs(opts *bind.CallOpts, arg0 *big.Int) (struct {
	Timestamp  uint64
	IsExit     bool
	IsTransfer bool
	Finalized  bool
	Challenged bool
	Value      *big.Int
	Requestor  common.Address
	To         common.Address
	TrieKey    [32]byte
	Hash       [32]byte
	TrieValue  []byte
}, error)

ERUs is a free data retrieval call binding the contract method 0xf4f31de4.

Solidity: function ERUs(uint256 ) constant returns(uint64 timestamp, bool isExit, bool isTransfer, bool finalized, bool challenged, uint128 value, address requestor, address to, bytes32 trieKey, bytes32 hash, bytes trieValue)

func (*EpochHandlerCaller) EpochHandler 

func (_EpochHandler *EpochHandlerCaller) EpochHandler(opts *bind.CallOpts) (common.Address, error)

EpochHandler is a free data retrieval call binding the contract method 0xe7b88b80.

Solidity: function epochHandler() constant returns(address)

func (*EpochHandlerCaller) EtherToken 

func (_EpochHandler *EpochHandlerCaller) EtherToken(opts *bind.CallOpts) (common.Address, error)

EtherToken is a free data retrieval call binding the contract method 0xb8066bcb.

Solidity: function etherToken() constant returns(address)

func (*EpochHandlerCaller) FirstFilledORENumber 

func (_EpochHandler *EpochHandlerCaller) FirstFilledORENumber(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error)

FirstFilledORENumber is a free data retrieval call binding the contract method 0x72ecb9a8.

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

func (*EpochHandlerCaller) FirstNonEmptyRequestEpoch 

func (_EpochHandler *EpochHandlerCaller) FirstNonEmptyRequestEpoch(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error)

FirstNonEmptyRequestEpoch is a free data retrieval call binding the contract method 0xca6f6380.

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

func (*EpochHandlerCaller) Forks 

func (_EpochHandler *EpochHandlerCaller) Forks(opts *bind.CallOpts, arg0 *big.Int) (struct {
	ForkedBlock        uint64
	FirstEpoch         uint64
	LastEpoch          uint64
	FirstBlock         uint64
	LastBlock          uint64
	LastFinalizedEpoch uint64
	LastFinalizedBlock uint64
	Timestamp          uint64
	FirstEnterEpoch    uint64
	LastEnterEpoch     uint64
	NextBlockToRebase  uint64
	Rebased            bool
}, error)

Forks is a free data retrieval call binding the contract method 0x4ba3a126.

Solidity: function forks(uint256 ) constant returns(uint64 forkedBlock, uint64 firstEpoch, uint64 lastEpoch, uint64 firstBlock, uint64 lastBlock, uint64 lastFinalizedEpoch, uint64 lastFinalizedBlock, uint64 timestamp, uint64 firstEnterEpoch, uint64 lastEnterEpoch, uint64 nextBlockToRebase, bool rebased)

func (*EpochHandlerCaller) IsRootChain 

func (_EpochHandler *EpochHandlerCaller) IsRootChain(opts *bind.CallOpts) (bool, error)

IsRootChain is a free data retrieval call binding the contract method 0x420bb4b8.

Solidity: function isRootChain() constant returns(bool)

func (*EpochHandlerCaller) LastAppliedBlockNumber 

func (_EpochHandler *EpochHandlerCaller) LastAppliedBlockNumber(opts *bind.CallOpts) (*big.Int, error)

LastAppliedBlockNumber is a free data retrieval call binding the contract method 0xfb788a27.

Solidity: function lastAppliedBlockNumber() constant returns(uint256)

func (*EpochHandlerCaller) LastAppliedEpochNumber 

func (_EpochHandler *EpochHandlerCaller) LastAppliedEpochNumber(opts *bind.CallOpts) (*big.Int, error)

LastAppliedEpochNumber is a free data retrieval call binding the contract method 0xc8ad329f.

Solidity: function lastAppliedEpochNumber() constant returns(uint256)

func (*EpochHandlerCaller) LastAppliedForkNumber 

func (_EpochHandler *EpochHandlerCaller) LastAppliedForkNumber(opts *bind.CallOpts) (*big.Int, error)

LastAppliedForkNumber is a free data retrieval call binding the contract method 0x164bc2ae.

Solidity: function lastAppliedForkNumber() constant returns(uint256)

func (*EpochHandlerCaller) LastNonEmptyRequestEpoch 

func (_EpochHandler *EpochHandlerCaller) LastNonEmptyRequestEpoch(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error)

LastNonEmptyRequestEpoch is a free data retrieval call binding the contract method 0xb6715647.

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

func (*EpochHandlerCaller) NRELength 

func (_EpochHandler *EpochHandlerCaller) NRELength(opts *bind.CallOpts) (*big.Int, error)

NRELength is a free data retrieval call binding the contract method 0xab96da2d.

Solidity: function NRELength() constant returns(uint256)

func (*EpochHandlerCaller) NULLADDRESS 

func (_EpochHandler *EpochHandlerCaller) NULLADDRESS(opts *bind.CallOpts) (common.Address, error)

NULLADDRESS is a free data retrieval call binding the contract method 0xde0ce17d.

Solidity: function NULL_ADDRESS() constant returns(address)

func (*EpochHandlerCaller) NumEnterForORB 

func (_EpochHandler *EpochHandlerCaller) NumEnterForORB(opts *bind.CallOpts) (*big.Int, error)

NumEnterForORB is a free data retrieval call binding the contract method 0x23691566.

Solidity: function numEnterForORB() constant returns(uint256)

func (*EpochHandlerCaller) ORBs 

func (_EpochHandler *EpochHandlerCaller) ORBs(opts *bind.CallOpts, arg0 *big.Int) (struct {
	Submitted    bool
	NumEnter     uint64
	EpochNumber  uint64
	RequestStart uint64
	RequestEnd   uint64
	Trie         common.Address
}, error)

ORBs is a free data retrieval call binding the contract method 0xea7f22a8.

Solidity: function ORBs(uint256 ) constant returns(bool submitted, uint64 numEnter, uint64 epochNumber, uint64 requestStart, uint64 requestEnd, address trie)

func (*EpochHandlerCaller) Operator 

func (_EpochHandler *EpochHandlerCaller) Operator(opts *bind.CallOpts) (common.Address, error)

Operator is a free data retrieval call binding the contract method 0x570ca735.

Solidity: function operator() constant returns(address)

func (*EpochHandlerCaller) PREPARETIMEOUT 

func (_EpochHandler *EpochHandlerCaller) PREPARETIMEOUT(opts *bind.CallOpts) (*big.Int, error)

PREPARETIMEOUT is a free data retrieval call binding the contract method 0xc2bc88fa.

Solidity: function PREPARE_TIMEOUT() constant returns(uint256)

func (*EpochHandlerCaller) REQUESTGAS 

func (_EpochHandler *EpochHandlerCaller) REQUESTGAS(opts *bind.CallOpts) (*big.Int, error)

REQUESTGAS is a free data retrieval call binding the contract method 0x8eb288ca.

Solidity: function REQUEST_GAS() constant returns(uint256)

func (*EpochHandlerCaller) RequestableContracts 

func (_EpochHandler *EpochHandlerCaller) RequestableContracts(opts *bind.CallOpts, arg0 common.Address) (common.Address, error)

RequestableContracts is a free data retrieval call binding the contract method 0xda0185f8.

Solidity: function requestableContracts(address ) constant returns(address)

func (*EpochHandlerCaller) SeigManager 

func (_EpochHandler *EpochHandlerCaller) SeigManager(opts *bind.CallOpts) (common.Address, error)

SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.

Solidity: function seigManager() constant returns(address)

func (*EpochHandlerCaller) SubmitHandler 

func (_EpochHandler *EpochHandlerCaller) SubmitHandler(opts *bind.CallOpts) (common.Address, error)

SubmitHandler is a free data retrieval call binding the contract method 0xe259faf7.

Solidity: function submitHandler() constant returns(address)

func (*EpochHandlerCaller) URBs 

func (_EpochHandler *EpochHandlerCaller) URBs(opts *bind.CallOpts, arg0 *big.Int) (struct {
	Submitted    bool
	NumEnter     uint64
	EpochNumber  uint64
	RequestStart uint64
	RequestEnd   uint64
	Trie         common.Address
}, error)

URBs is a free data retrieval call binding the contract method 0xc0e86064.

Solidity: function URBs(uint256 ) constant returns(bool submitted, uint64 numEnter, uint64 epochNumber, uint64 requestStart, uint64 requestEnd, address trie)

type EpochHandlerCallerRaw 

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

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

func (*EpochHandlerCallerRaw) Call 

func (_EpochHandler *EpochHandlerCallerRaw) 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 EpochHandlerCallerSession 

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

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

func (*EpochHandlerCallerSession) COSTERO 

func (_EpochHandler *EpochHandlerCallerSession) COSTERO() (*big.Int, error)

COSTERO is a free data retrieval call binding the contract method 0xd691acd8.

Solidity: function COST_ERO() constant returns(uint256)

func (*EpochHandlerCallerSession) COSTERU 

func (_EpochHandler *EpochHandlerCallerSession) COSTERU() (*big.Int, error)

COSTERU is a free data retrieval call binding the contract method 0x8b5172d0.

Solidity: function COST_ERU() constant returns(uint256)

func (*EpochHandlerCallerSession) COSTNRB 

func (_EpochHandler *EpochHandlerCallerSession) COSTNRB() (*big.Int, error)

COSTNRB is a free data retrieval call binding the contract method 0x94be3aa5.

Solidity: function COST_NRB() constant returns(uint256)

func (*EpochHandlerCallerSession) COSTORB 

func (_EpochHandler *EpochHandlerCallerSession) COSTORB() (*big.Int, error)

COSTORB is a free data retrieval call binding the contract method 0xb2ae9ba8.

Solidity: function COST_ORB() constant returns(uint256)

func (*EpochHandlerCallerSession) COSTURB 

func (_EpochHandler *EpochHandlerCallerSession) COSTURB() (*big.Int, error)

COSTURB is a free data retrieval call binding the contract method 0x192adc5b.

Solidity: function COST_URB() constant returns(uint256)

func (*EpochHandlerCallerSession) COSTURBPREPARE 

func (_EpochHandler *EpochHandlerCallerSession) COSTURBPREPARE() (*big.Int, error)

COSTURBPREPARE is a free data retrieval call binding the contract method 0x033cfbed.

Solidity: function COST_URB_PREPARE() constant returns(uint256)

func (*EpochHandlerCallerSession) CPCOMPUTATION 

func (_EpochHandler *EpochHandlerCallerSession) CPCOMPUTATION() (*big.Int, error)

CPCOMPUTATION is a free data retrieval call binding the contract method 0x08c4fff0.

Solidity: function CP_COMPUTATION() constant returns(uint256)

func (*EpochHandlerCallerSession) CPEXIT 

func (_EpochHandler *EpochHandlerCallerSession) CPEXIT() (*big.Int, error)

CPEXIT is a free data retrieval call binding the contract method 0x8155717d.

Solidity: function CP_EXIT() constant returns(uint256)

func (*EpochHandlerCallerSession) CPWITHHOLDING 

func (_EpochHandler *EpochHandlerCallerSession) CPWITHHOLDING() (*big.Int, error)

CPWITHHOLDING is a free data retrieval call binding the contract method 0xb17fa6e9.

Solidity: function CP_WITHHOLDING() constant returns(uint256)

func (*EpochHandlerCallerSession) CurrentFork 

func (_EpochHandler *EpochHandlerCallerSession) CurrentFork() (*big.Int, error)

CurrentFork is a free data retrieval call binding the contract method 0x183d2d1c.

Solidity: function currentFork() constant returns(uint256)

func (*EpochHandlerCallerSession) Development 

func (_EpochHandler *EpochHandlerCallerSession) Development() (bool, error)

Development is a free data retrieval call binding the contract method 0x7b929c27.

Solidity: function development() constant returns(bool)

func (*EpochHandlerCallerSession) EROIdToFinalize 

func (_EpochHandler *EpochHandlerCallerSession) EROIdToFinalize() (*big.Int, error)

EROIdToFinalize is a free data retrieval call binding the contract method 0x2dc6bb7b.

Solidity: function EROIdToFinalize() constant returns(uint256)

func (*EpochHandlerCallerSession) EROs 

func (_EpochHandler *EpochHandlerCallerSession) EROs(arg0 *big.Int) (struct {
	Timestamp  uint64
	IsExit     bool
	IsTransfer bool
	Finalized  bool
	Challenged bool
	Value      *big.Int
	Requestor  common.Address
	To         common.Address
	TrieKey    [32]byte
	Hash       [32]byte
	TrieValue  []byte
}, error)

EROs is a free data retrieval call binding the contract method 0xb443f3cc.

Solidity: function EROs(uint256 ) constant returns(uint64 timestamp, bool isExit, bool isTransfer, bool finalized, bool challenged, uint128 value, address requestor, address to, bytes32 trieKey, bytes32 hash, bytes trieValue)

func (*EpochHandlerCallerSession) ERUIdToFinalize 

func (_EpochHandler *EpochHandlerCallerSession) ERUIdToFinalize() (*big.Int, error)

ERUIdToFinalize is a free data retrieval call binding the contract method 0xc54626cc.

Solidity: function ERUIdToFinalize() constant returns(uint256)

func (*EpochHandlerCallerSession) ERUs 

func (_EpochHandler *EpochHandlerCallerSession) ERUs(arg0 *big.Int) (struct {
	Timestamp  uint64
	IsExit     bool
	IsTransfer bool
	Finalized  bool
	Challenged bool
	Value      *big.Int
	Requestor  common.Address
	To         common.Address
	TrieKey    [32]byte
	Hash       [32]byte
	TrieValue  []byte
}, error)

ERUs is a free data retrieval call binding the contract method 0xf4f31de4.

Solidity: function ERUs(uint256 ) constant returns(uint64 timestamp, bool isExit, bool isTransfer, bool finalized, bool challenged, uint128 value, address requestor, address to, bytes32 trieKey, bytes32 hash, bytes trieValue)

func (*EpochHandlerCallerSession) EpochHandler 

func (_EpochHandler *EpochHandlerCallerSession) EpochHandler() (common.Address, error)

EpochHandler is a free data retrieval call binding the contract method 0xe7b88b80.

Solidity: function epochHandler() constant returns(address)

func (*EpochHandlerCallerSession) EtherToken 

func (_EpochHandler *EpochHandlerCallerSession) EtherToken() (common.Address, error)

EtherToken is a free data retrieval call binding the contract method 0xb8066bcb.

Solidity: function etherToken() constant returns(address)

func (*EpochHandlerCallerSession) FirstFilledORENumber 

func (_EpochHandler *EpochHandlerCallerSession) FirstFilledORENumber(arg0 *big.Int) (*big.Int, error)

FirstFilledORENumber is a free data retrieval call binding the contract method 0x72ecb9a8.

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

func (*EpochHandlerCallerSession) FirstNonEmptyRequestEpoch 

func (_EpochHandler *EpochHandlerCallerSession) FirstNonEmptyRequestEpoch(arg0 *big.Int) (*big.Int, error)

FirstNonEmptyRequestEpoch is a free data retrieval call binding the contract method 0xca6f6380.

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

func (*EpochHandlerCallerSession) Forks 

func (_EpochHandler *EpochHandlerCallerSession) Forks(arg0 *big.Int) (struct {
	ForkedBlock        uint64
	FirstEpoch         uint64
	LastEpoch          uint64
	FirstBlock         uint64
	LastBlock          uint64
	LastFinalizedEpoch uint64
	LastFinalizedBlock uint64
	Timestamp          uint64
	FirstEnterEpoch    uint64
	LastEnterEpoch     uint64
	NextBlockToRebase  uint64
	Rebased            bool
}, error)

Forks is a free data retrieval call binding the contract method 0x4ba3a126.

Solidity: function forks(uint256 ) constant returns(uint64 forkedBlock, uint64 firstEpoch, uint64 lastEpoch, uint64 firstBlock, uint64 lastBlock, uint64 lastFinalizedEpoch, uint64 lastFinalizedBlock, uint64 timestamp, uint64 firstEnterEpoch, uint64 lastEnterEpoch, uint64 nextBlockToRebase, bool rebased)

func (*EpochHandlerCallerSession) IsRootChain 

func (_EpochHandler *EpochHandlerCallerSession) IsRootChain() (bool, error)

IsRootChain is a free data retrieval call binding the contract method 0x420bb4b8.

Solidity: function isRootChain() constant returns(bool)

func (*EpochHandlerCallerSession) LastAppliedBlockNumber 

func (_EpochHandler *EpochHandlerCallerSession) LastAppliedBlockNumber() (*big.Int, error)

LastAppliedBlockNumber is a free data retrieval call binding the contract method 0xfb788a27.

Solidity: function lastAppliedBlockNumber() constant returns(uint256)

func (*EpochHandlerCallerSession) LastAppliedEpochNumber 

func (_EpochHandler *EpochHandlerCallerSession) LastAppliedEpochNumber() (*big.Int, error)

LastAppliedEpochNumber is a free data retrieval call binding the contract method 0xc8ad329f.

Solidity: function lastAppliedEpochNumber() constant returns(uint256)

func (*EpochHandlerCallerSession) LastAppliedForkNumber 

func (_EpochHandler *EpochHandlerCallerSession) LastAppliedForkNumber() (*big.Int, error)

LastAppliedForkNumber is a free data retrieval call binding the contract method 0x164bc2ae.

Solidity: function lastAppliedForkNumber() constant returns(uint256)

func (*EpochHandlerCallerSession) LastNonEmptyRequestEpoch 

func (_EpochHandler *EpochHandlerCallerSession) LastNonEmptyRequestEpoch(arg0 *big.Int) (*big.Int, error)

LastNonEmptyRequestEpoch is a free data retrieval call binding the contract method 0xb6715647.

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

func (*EpochHandlerCallerSession) NRELength 

func (_EpochHandler *EpochHandlerCallerSession) NRELength() (*big.Int, error)

NRELength is a free data retrieval call binding the contract method 0xab96da2d.

Solidity: function NRELength() constant returns(uint256)

func (*EpochHandlerCallerSession) NULLADDRESS 

func (_EpochHandler *EpochHandlerCallerSession) NULLADDRESS() (common.Address, error)

NULLADDRESS is a free data retrieval call binding the contract method 0xde0ce17d.

Solidity: function NULL_ADDRESS() constant returns(address)

func (*EpochHandlerCallerSession) NumEnterForORB 

func (_EpochHandler *EpochHandlerCallerSession) NumEnterForORB() (*big.Int, error)

NumEnterForORB is a free data retrieval call binding the contract method 0x23691566.

Solidity: function numEnterForORB() constant returns(uint256)

func (*EpochHandlerCallerSession) ORBs 

func (_EpochHandler *EpochHandlerCallerSession) ORBs(arg0 *big.Int) (struct {
	Submitted    bool
	NumEnter     uint64
	EpochNumber  uint64
	RequestStart uint64
	RequestEnd   uint64
	Trie         common.Address
}, error)

ORBs is a free data retrieval call binding the contract method 0xea7f22a8.

Solidity: function ORBs(uint256 ) constant returns(bool submitted, uint64 numEnter, uint64 epochNumber, uint64 requestStart, uint64 requestEnd, address trie)

func (*EpochHandlerCallerSession) Operator 

func (_EpochHandler *EpochHandlerCallerSession) Operator() (common.Address, error)

Operator is a free data retrieval call binding the contract method 0x570ca735.

Solidity: function operator() constant returns(address)

func (*EpochHandlerCallerSession) PREPARETIMEOUT 

func (_EpochHandler *EpochHandlerCallerSession) PREPARETIMEOUT() (*big.Int, error)

PREPARETIMEOUT is a free data retrieval call binding the contract method 0xc2bc88fa.

Solidity: function PREPARE_TIMEOUT() constant returns(uint256)

func (*EpochHandlerCallerSession) REQUESTGAS 

func (_EpochHandler *EpochHandlerCallerSession) REQUESTGAS() (*big.Int, error)

REQUESTGAS is a free data retrieval call binding the contract method 0x8eb288ca.

Solidity: function REQUEST_GAS() constant returns(uint256)

func (*EpochHandlerCallerSession) RequestableContracts 

func (_EpochHandler *EpochHandlerCallerSession) RequestableContracts(arg0 common.Address) (common.Address, error)

RequestableContracts is a free data retrieval call binding the contract method 0xda0185f8.

Solidity: function requestableContracts(address ) constant returns(address)

func (*EpochHandlerCallerSession) SeigManager 

func (_EpochHandler *EpochHandlerCallerSession) SeigManager() (common.Address, error)

SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.

Solidity: function seigManager() constant returns(address)

func (*EpochHandlerCallerSession) SubmitHandler 

func (_EpochHandler *EpochHandlerCallerSession) SubmitHandler() (common.Address, error)

SubmitHandler is a free data retrieval call binding the contract method 0xe259faf7.

Solidity: function submitHandler() constant returns(address)

func (*EpochHandlerCallerSession) URBs 

func (_EpochHandler *EpochHandlerCallerSession) URBs(arg0 *big.Int) (struct {
	Submitted    bool
	NumEnter     uint64
	EpochNumber  uint64
	RequestStart uint64
	RequestEnd   uint64
	Trie         common.Address
}, error)

URBs is a free data retrieval call binding the contract method 0xc0e86064.

Solidity: function URBs(uint256 ) constant returns(bool submitted, uint64 numEnter, uint64 epochNumber, uint64 requestStart, uint64 requestEnd, address trie)

type EpochHandlerERUCreated 

type EpochHandlerERUCreated struct {
	RequestId *big.Int
	Requestor common.Address
	To        common.Address
	TrieKey   []byte
	TrieValue [32]byte
	Raw       types.Log // Blockchain specific contextual infos
}

EpochHandlerERUCreated represents a ERUCreated event raised by the EpochHandler contract.

type EpochHandlerERUCreatedIterator 

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

EpochHandlerERUCreatedIterator is returned from FilterERUCreated and is used to iterate over the raw logs and unpacked data for ERUCreated events raised by the EpochHandler contract.

func (*EpochHandlerERUCreatedIterator) Close 

func (it *EpochHandlerERUCreatedIterator) Close() error

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

func (*EpochHandlerERUCreatedIterator) Error 

func (it *EpochHandlerERUCreatedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EpochHandlerERUCreatedIterator) Next 

func (it *EpochHandlerERUCreatedIterator) 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 EpochHandlerEpochFilled 

type EpochHandlerEpochFilled struct {
	ForkNumber  *big.Int
	EpochNumber *big.Int
	Raw         types.Log // Blockchain specific contextual infos
}

EpochHandlerEpochFilled represents a EpochFilled event raised by the EpochHandler contract.

type EpochHandlerEpochFilledIterator 

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

EpochHandlerEpochFilledIterator is returned from FilterEpochFilled and is used to iterate over the raw logs and unpacked data for EpochFilled events raised by the EpochHandler contract.

func (*EpochHandlerEpochFilledIterator) Close 

func (it *EpochHandlerEpochFilledIterator) Close() error

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

func (*EpochHandlerEpochFilledIterator) Error 

func (it *EpochHandlerEpochFilledIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EpochHandlerEpochFilledIterator) Next 

func (it *EpochHandlerEpochFilledIterator) 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 EpochHandlerEpochFilling 

type EpochHandlerEpochFilling struct {
	ForkNumber  *big.Int
	EpochNumber *big.Int
	Raw         types.Log // Blockchain specific contextual infos
}

EpochHandlerEpochFilling represents a EpochFilling event raised by the EpochHandler contract.

type EpochHandlerEpochFillingIterator 

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

EpochHandlerEpochFillingIterator is returned from FilterEpochFilling and is used to iterate over the raw logs and unpacked data for EpochFilling events raised by the EpochHandler contract.

func (*EpochHandlerEpochFillingIterator) Close 

func (it *EpochHandlerEpochFillingIterator) Close() error

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

func (*EpochHandlerEpochFillingIterator) Error 

func (it *EpochHandlerEpochFillingIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EpochHandlerEpochFillingIterator) Next 

func (it *EpochHandlerEpochFillingIterator) 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 EpochHandlerEpochFinalized 

type EpochHandlerEpochFinalized struct {
	ForkNumber       *big.Int
	EpochNumber      *big.Int
	StartBlockNumber *big.Int
	EndBlockNumber   *big.Int
	Raw              types.Log // Blockchain specific contextual infos
}

EpochHandlerEpochFinalized represents a EpochFinalized event raised by the EpochHandler contract.

type EpochHandlerEpochFinalizedIterator 

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

EpochHandlerEpochFinalizedIterator is returned from FilterEpochFinalized and is used to iterate over the raw logs and unpacked data for EpochFinalized events raised by the EpochHandler contract.

func (*EpochHandlerEpochFinalizedIterator) Close 

func (it *EpochHandlerEpochFinalizedIterator) Close() error

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

func (*EpochHandlerEpochFinalizedIterator) Error 

func (it *EpochHandlerEpochFinalizedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EpochHandlerEpochFinalizedIterator) Next 

func (it *EpochHandlerEpochFinalizedIterator) 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 EpochHandlerEpochPrepared 

type EpochHandlerEpochPrepared struct {
	ForkNumber       *big.Int
	EpochNumber      *big.Int
	StartBlockNumber *big.Int
	EndBlockNumber   *big.Int
	RequestStart     *big.Int
	RequestEnd       *big.Int
	EpochIsEmpty     bool
	IsRequest        bool
	UserActivated    bool
	Rebase           bool
	Raw              types.Log // Blockchain specific contextual infos
}

EpochHandlerEpochPrepared represents a EpochPrepared event raised by the EpochHandler contract.

type EpochHandlerEpochPreparedIterator 

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

EpochHandlerEpochPreparedIterator is returned from FilterEpochPrepared and is used to iterate over the raw logs and unpacked data for EpochPrepared events raised by the EpochHandler contract.

func (*EpochHandlerEpochPreparedIterator) Close 

func (it *EpochHandlerEpochPreparedIterator) Close() error

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

func (*EpochHandlerEpochPreparedIterator) Error 

func (it *EpochHandlerEpochPreparedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EpochHandlerEpochPreparedIterator) Next 

func (it *EpochHandlerEpochPreparedIterator) 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 EpochHandlerEpochRebased 

type EpochHandlerEpochRebased struct {
	ForkNumber       *big.Int
	EpochNumber      *big.Int
	StartBlockNumber *big.Int
	EndBlockNumber   *big.Int
	RequestStart     *big.Int
	RequestEnd       *big.Int
	EpochIsEmpty     bool
	IsRequest        bool
	UserActivated    bool
	Raw              types.Log // Blockchain specific contextual infos
}

EpochHandlerEpochRebased represents a EpochRebased event raised by the EpochHandler contract.

type EpochHandlerEpochRebasedIterator 

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

EpochHandlerEpochRebasedIterator is returned from FilterEpochRebased and is used to iterate over the raw logs and unpacked data for EpochRebased events raised by the EpochHandler contract.

func (*EpochHandlerEpochRebasedIterator) Close 

func (it *EpochHandlerEpochRebasedIterator) Close() error

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

func (*EpochHandlerEpochRebasedIterator) Error 

func (it *EpochHandlerEpochRebasedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EpochHandlerEpochRebasedIterator) Next 

func (it *EpochHandlerEpochRebasedIterator) 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 EpochHandlerFilterer 

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

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

func NewEpochHandlerFilterer 

func NewEpochHandlerFilterer(address common.Address, filterer bind.ContractFilterer) (*EpochHandlerFilterer, error)

NewEpochHandlerFilterer creates a new log filterer instance of EpochHandler, bound to a specific deployed contract.

func (*EpochHandlerFilterer) FilterBlockFinalized 

func (_EpochHandler *EpochHandlerFilterer) FilterBlockFinalized(opts *bind.FilterOpts) (*EpochHandlerBlockFinalizedIterator, error)

FilterBlockFinalized is a free log retrieval operation binding the contract event 0xfb96205e4b3633fd57aa805b26b51ecf528714a10241a4af015929dce86768d9.

Solidity: event BlockFinalized(uint256 forkNumber, uint256 blockNumber)

func (*EpochHandlerFilterer) FilterBlockSubmitted 

func (_EpochHandler *EpochHandlerFilterer) FilterBlockSubmitted(opts *bind.FilterOpts) (*EpochHandlerBlockSubmittedIterator, error)

FilterBlockSubmitted is a free log retrieval operation binding the contract event 0x3d4a04291c66b06f39a4ecb817875b12b5485a05ec563133a56a905305c48e55.

Solidity: event BlockSubmitted(uint256 fork, uint256 epochNumber, uint256 blockNumber, bool isRequest, bool userActivated)

func (*EpochHandlerFilterer) FilterERUCreated 

func (_EpochHandler *EpochHandlerFilterer) FilterERUCreated(opts *bind.FilterOpts) (*EpochHandlerERUCreatedIterator, error)

FilterERUCreated is a free log retrieval operation binding the contract event 0xfcbdc2083dadd644b854d91b49aef8db06b8f5a3d5c1192de38ca0ba271d5a0d.

Solidity: event ERUCreated(uint256 requestId, address requestor, address to, bytes trieKey, bytes32 trieValue)

func (*EpochHandlerFilterer) FilterEpochFilled 

func (_EpochHandler *EpochHandlerFilterer) FilterEpochFilled(opts *bind.FilterOpts) (*EpochHandlerEpochFilledIterator, error)

FilterEpochFilled is a free log retrieval operation binding the contract event 0x2fdeb407bf5c2b621f04b5c784822dae806c45b49a68aba413cc270128c96816.

Solidity: event EpochFilled(uint256 forkNumber, uint256 epochNumber)

func (*EpochHandlerFilterer) FilterEpochFilling 

func (_EpochHandler *EpochHandlerFilterer) FilterEpochFilling(opts *bind.FilterOpts) (*EpochHandlerEpochFillingIterator, error)

FilterEpochFilling is a free log retrieval operation binding the contract event 0x27b09f0953d27bbff306fe25b2987ac5a813248ac30cb2bbd5daf95e7b0e6dc0.

Solidity: event EpochFilling(uint256 forkNumber, uint256 epochNumber)

func (*EpochHandlerFilterer) FilterEpochFinalized 

func (_EpochHandler *EpochHandlerFilterer) FilterEpochFinalized(opts *bind.FilterOpts) (*EpochHandlerEpochFinalizedIterator, error)

FilterEpochFinalized is a free log retrieval operation binding the contract event 0x70801d4d63b3da6c19ba7349911f45bed5a99ccdfb51b8138c105872529bebd5.

Solidity: event EpochFinalized(uint256 forkNumber, uint256 epochNumber, uint256 startBlockNumber, uint256 endBlockNumber)

func (*EpochHandlerFilterer) FilterEpochPrepared 

func (_EpochHandler *EpochHandlerFilterer) FilterEpochPrepared(opts *bind.FilterOpts) (*EpochHandlerEpochPreparedIterator, error)

FilterEpochPrepared is a free log retrieval operation binding the contract event 0x1a69c0760aa329b76f72579129869013ebd3d41594db019c0e997b939fcb32e3.

Solidity: event EpochPrepared(uint256 forkNumber, uint256 epochNumber, uint256 startBlockNumber, uint256 endBlockNumber, uint256 requestStart, uint256 requestEnd, bool epochIsEmpty, bool isRequest, bool userActivated, bool rebase)

func (*EpochHandlerFilterer) FilterEpochRebased 

func (_EpochHandler *EpochHandlerFilterer) FilterEpochRebased(opts *bind.FilterOpts) (*EpochHandlerEpochRebasedIterator, error)

FilterEpochRebased is a free log retrieval operation binding the contract event 0x030c1c69405c93021f28f57557240dee939a320b826a1fd0d39bf6e629ecab47.

Solidity: event EpochRebased(uint256 forkNumber, uint256 epochNumber, uint256 startBlockNumber, uint256 endBlockNumber, uint256 requestStart, uint256 requestEnd, bool epochIsEmpty, bool isRequest, bool userActivated)

func (*EpochHandlerFilterer) FilterForked 

func (_EpochHandler *EpochHandlerFilterer) FilterForked(opts *bind.FilterOpts) (*EpochHandlerForkedIterator, error)

FilterForked is a free log retrieval operation binding the contract event 0x0647d42ab02f6e0ae76959757dcb6aa6feac1d4ba6f077f1223fb4b1b429f06c.

Solidity: event Forked(uint256 newFork, uint256 epochNumber, uint256 forkedBlockNumber)

func (*EpochHandlerFilterer) FilterOperatorChanged 

func (_EpochHandler *EpochHandlerFilterer) FilterOperatorChanged(opts *bind.FilterOpts) (*EpochHandlerOperatorChangedIterator, error)

FilterOperatorChanged is a free log retrieval operation binding the contract event 0x4721129e0e676ed6a92909bb24e853ccdd63ad72280cc2e974e38e480e0e6e54.

Solidity: event OperatorChanged(address _newOperator)

func (*EpochHandlerFilterer) FilterRequestApplied 

func (_EpochHandler *EpochHandlerFilterer) FilterRequestApplied(opts *bind.FilterOpts) (*EpochHandlerRequestAppliedIterator, error)

FilterRequestApplied is a free log retrieval operation binding the contract event 0x6940a01870e576ceb735867e13863646d517ce10e66c0133186a4ebdfe9388c2.

Solidity: event RequestApplied(uint256 requestId, bool userActivated)

func (*EpochHandlerFilterer) FilterRequestChallenged 

func (_EpochHandler *EpochHandlerFilterer) FilterRequestChallenged(opts *bind.FilterOpts) (*EpochHandlerRequestChallengedIterator, error)

FilterRequestChallenged is a free log retrieval operation binding the contract event 0xc8135db115644ed4ae193313c4c801235ef740d2a57a8d5e6fe26ab66635698a.

Solidity: event RequestChallenged(uint256 requestId, bool userActivated)

func (*EpochHandlerFilterer) FilterRequestCreated 

func (_EpochHandler *EpochHandlerFilterer) FilterRequestCreated(opts *bind.FilterOpts) (*EpochHandlerRequestCreatedIterator, error)

FilterRequestCreated is a free log retrieval operation binding the contract event 0x879922cf5fcada9ebaf8bd7424dc62877f4b220cae07fb6695cc1e8f94c52b4d.

Solidity: event RequestCreated(uint256 requestId, address requestor, address to, uint256 weiAmount, bytes32 trieKey, bytes trieValue, bool isExit, bool userActivated)

func (*EpochHandlerFilterer) FilterRequestFinalized 

func (_EpochHandler *EpochHandlerFilterer) FilterRequestFinalized(opts *bind.FilterOpts) (*EpochHandlerRequestFinalizedIterator, error)

FilterRequestFinalized is a free log retrieval operation binding the contract event 0x134017cf3262b18f892ee95dde3b0aec9a80cc70a7c96f09c64bd237aceb0473.

Solidity: event RequestFinalized(uint256 requestId, bool userActivated)

func (*EpochHandlerFilterer) FilterRequestableContractMapped 

func (_EpochHandler *EpochHandlerFilterer) FilterRequestableContractMapped(opts *bind.FilterOpts) (*EpochHandlerRequestableContractMappedIterator, error)

FilterRequestableContractMapped is a free log retrieval operation binding the contract event 0xc5ec2ed49686197edd2ed642c7e6096893cc81e6658cde2527030316037715d0.

Solidity: event RequestableContractMapped(address contractInRootchain, address contractInChildchain)

func (*EpochHandlerFilterer) FilterSessionTimeout 

func (_EpochHandler *EpochHandlerFilterer) FilterSessionTimeout(opts *bind.FilterOpts) (*EpochHandlerSessionTimeoutIterator, error)

FilterSessionTimeout is a free log retrieval operation binding the contract event 0x2122ec719581cd177f225f59a1ee005831211196831f8f1ccffa817d2e7bd108.

Solidity: event SessionTimeout(bool userActivated)

func (*EpochHandlerFilterer) ParseBlockFinalized 

func (_EpochHandler *EpochHandlerFilterer) ParseBlockFinalized(log types.Log) (*EpochHandlerBlockFinalized, error)

ParseBlockFinalized is a log parse operation binding the contract event 0xfb96205e4b3633fd57aa805b26b51ecf528714a10241a4af015929dce86768d9.

Solidity: event BlockFinalized(uint256 forkNumber, uint256 blockNumber)

func (*EpochHandlerFilterer) ParseBlockSubmitted 

func (_EpochHandler *EpochHandlerFilterer) ParseBlockSubmitted(log types.Log) (*EpochHandlerBlockSubmitted, error)

ParseBlockSubmitted is a log parse operation binding the contract event 0x3d4a04291c66b06f39a4ecb817875b12b5485a05ec563133a56a905305c48e55.

Solidity: event BlockSubmitted(uint256 fork, uint256 epochNumber, uint256 blockNumber, bool isRequest, bool userActivated)

func (*EpochHandlerFilterer) ParseERUCreated 

func (_EpochHandler *EpochHandlerFilterer) ParseERUCreated(log types.Log) (*EpochHandlerERUCreated, error)

ParseERUCreated is a log parse operation binding the contract event 0xfcbdc2083dadd644b854d91b49aef8db06b8f5a3d5c1192de38ca0ba271d5a0d.

Solidity: event ERUCreated(uint256 requestId, address requestor, address to, bytes trieKey, bytes32 trieValue)

func (*EpochHandlerFilterer) ParseEpochFilled 

func (_EpochHandler *EpochHandlerFilterer) ParseEpochFilled(log types.Log) (*EpochHandlerEpochFilled, error)

ParseEpochFilled is a log parse operation binding the contract event 0x2fdeb407bf5c2b621f04b5c784822dae806c45b49a68aba413cc270128c96816.

Solidity: event EpochFilled(uint256 forkNumber, uint256 epochNumber)

func (*EpochHandlerFilterer) ParseEpochFilling 

func (_EpochHandler *EpochHandlerFilterer) ParseEpochFilling(log types.Log) (*EpochHandlerEpochFilling, error)

ParseEpochFilling is a log parse operation binding the contract event 0x27b09f0953d27bbff306fe25b2987ac5a813248ac30cb2bbd5daf95e7b0e6dc0.

Solidity: event EpochFilling(uint256 forkNumber, uint256 epochNumber)

func (*EpochHandlerFilterer) ParseEpochFinalized 

func (_EpochHandler *EpochHandlerFilterer) ParseEpochFinalized(log types.Log) (*EpochHandlerEpochFinalized, error)

ParseEpochFinalized is a log parse operation binding the contract event 0x70801d4d63b3da6c19ba7349911f45bed5a99ccdfb51b8138c105872529bebd5.

Solidity: event EpochFinalized(uint256 forkNumber, uint256 epochNumber, uint256 startBlockNumber, uint256 endBlockNumber)

func (*EpochHandlerFilterer) ParseEpochPrepared 

func (_EpochHandler *EpochHandlerFilterer) ParseEpochPrepared(log types.Log) (*EpochHandlerEpochPrepared, error)

ParseEpochPrepared is a log parse operation binding the contract event 0x1a69c0760aa329b76f72579129869013ebd3d41594db019c0e997b939fcb32e3.

Solidity: event EpochPrepared(uint256 forkNumber, uint256 epochNumber, uint256 startBlockNumber, uint256 endBlockNumber, uint256 requestStart, uint256 requestEnd, bool epochIsEmpty, bool isRequest, bool userActivated, bool rebase)

func (*EpochHandlerFilterer) ParseEpochRebased 

func (_EpochHandler *EpochHandlerFilterer) ParseEpochRebased(log types.Log) (*EpochHandlerEpochRebased, error)

ParseEpochRebased is a log parse operation binding the contract event 0x030c1c69405c93021f28f57557240dee939a320b826a1fd0d39bf6e629ecab47.

Solidity: event EpochRebased(uint256 forkNumber, uint256 epochNumber, uint256 startBlockNumber, uint256 endBlockNumber, uint256 requestStart, uint256 requestEnd, bool epochIsEmpty, bool isRequest, bool userActivated)

func (*EpochHandlerFilterer) ParseForked 

func (_EpochHandler *EpochHandlerFilterer) ParseForked(log types.Log) (*EpochHandlerForked, error)

ParseForked is a log parse operation binding the contract event 0x0647d42ab02f6e0ae76959757dcb6aa6feac1d4ba6f077f1223fb4b1b429f06c.

Solidity: event Forked(uint256 newFork, uint256 epochNumber, uint256 forkedBlockNumber)

func (*EpochHandlerFilterer) ParseOperatorChanged 

func (_EpochHandler *EpochHandlerFilterer) ParseOperatorChanged(log types.Log) (*EpochHandlerOperatorChanged, error)

ParseOperatorChanged is a log parse operation binding the contract event 0x4721129e0e676ed6a92909bb24e853ccdd63ad72280cc2e974e38e480e0e6e54.

Solidity: event OperatorChanged(address _newOperator)

func (*EpochHandlerFilterer) ParseRequestApplied 

func (_EpochHandler *EpochHandlerFilterer) ParseRequestApplied(log types.Log) (*EpochHandlerRequestApplied, error)

ParseRequestApplied is a log parse operation binding the contract event 0x6940a01870e576ceb735867e13863646d517ce10e66c0133186a4ebdfe9388c2.

Solidity: event RequestApplied(uint256 requestId, bool userActivated)

func (*EpochHandlerFilterer) ParseRequestChallenged 

func (_EpochHandler *EpochHandlerFilterer) ParseRequestChallenged(log types.Log) (*EpochHandlerRequestChallenged, error)

ParseRequestChallenged is a log parse operation binding the contract event 0xc8135db115644ed4ae193313c4c801235ef740d2a57a8d5e6fe26ab66635698a.

Solidity: event RequestChallenged(uint256 requestId, bool userActivated)

func (*EpochHandlerFilterer) ParseRequestCreated 

func (_EpochHandler *EpochHandlerFilterer) ParseRequestCreated(log types.Log) (*EpochHandlerRequestCreated, error)

ParseRequestCreated is a log parse operation binding the contract event 0x879922cf5fcada9ebaf8bd7424dc62877f4b220cae07fb6695cc1e8f94c52b4d.

Solidity: event RequestCreated(uint256 requestId, address requestor, address to, uint256 weiAmount, bytes32 trieKey, bytes trieValue, bool isExit, bool userActivated)

func (*EpochHandlerFilterer) ParseRequestFinalized 

func (_EpochHandler *EpochHandlerFilterer) ParseRequestFinalized(log types.Log) (*EpochHandlerRequestFinalized, error)

ParseRequestFinalized is a log parse operation binding the contract event 0x134017cf3262b18f892ee95dde3b0aec9a80cc70a7c96f09c64bd237aceb0473.

Solidity: event RequestFinalized(uint256 requestId, bool userActivated)

func (*EpochHandlerFilterer) ParseRequestableContractMapped 

func (_EpochHandler *EpochHandlerFilterer) ParseRequestableContractMapped(log types.Log) (*EpochHandlerRequestableContractMapped, error)

ParseRequestableContractMapped is a log parse operation binding the contract event 0xc5ec2ed49686197edd2ed642c7e6096893cc81e6658cde2527030316037715d0.

Solidity: event RequestableContractMapped(address contractInRootchain, address contractInChildchain)

func (*EpochHandlerFilterer) ParseSessionTimeout 

func (_EpochHandler *EpochHandlerFilterer) ParseSessionTimeout(log types.Log) (*EpochHandlerSessionTimeout, error)

ParseSessionTimeout is a log parse operation binding the contract event 0x2122ec719581cd177f225f59a1ee005831211196831f8f1ccffa817d2e7bd108.

Solidity: event SessionTimeout(bool userActivated)

func (*EpochHandlerFilterer) WatchBlockFinalized 

func (_EpochHandler *EpochHandlerFilterer) WatchBlockFinalized(opts *bind.WatchOpts, sink chan<- *EpochHandlerBlockFinalized) (event.Subscription, error)

WatchBlockFinalized is a free log subscription operation binding the contract event 0xfb96205e4b3633fd57aa805b26b51ecf528714a10241a4af015929dce86768d9.

Solidity: event BlockFinalized(uint256 forkNumber, uint256 blockNumber)

func (*EpochHandlerFilterer) WatchBlockSubmitted 

func (_EpochHandler *EpochHandlerFilterer) WatchBlockSubmitted(opts *bind.WatchOpts, sink chan<- *EpochHandlerBlockSubmitted) (event.Subscription, error)

WatchBlockSubmitted is a free log subscription operation binding the contract event 0x3d4a04291c66b06f39a4ecb817875b12b5485a05ec563133a56a905305c48e55.

Solidity: event BlockSubmitted(uint256 fork, uint256 epochNumber, uint256 blockNumber, bool isRequest, bool userActivated)

func (*EpochHandlerFilterer) WatchERUCreated 

func (_EpochHandler *EpochHandlerFilterer) WatchERUCreated(opts *bind.WatchOpts, sink chan<- *EpochHandlerERUCreated) (event.Subscription, error)

WatchERUCreated is a free log subscription operation binding the contract event 0xfcbdc2083dadd644b854d91b49aef8db06b8f5a3d5c1192de38ca0ba271d5a0d.

Solidity: event ERUCreated(uint256 requestId, address requestor, address to, bytes trieKey, bytes32 trieValue)

func (*EpochHandlerFilterer) WatchEpochFilled 

func (_EpochHandler *EpochHandlerFilterer) WatchEpochFilled(opts *bind.WatchOpts, sink chan<- *EpochHandlerEpochFilled) (event.Subscription, error)

WatchEpochFilled is a free log subscription operation binding the contract event 0x2fdeb407bf5c2b621f04b5c784822dae806c45b49a68aba413cc270128c96816.

Solidity: event EpochFilled(uint256 forkNumber, uint256 epochNumber)

func (*EpochHandlerFilterer) WatchEpochFilling 

func (_EpochHandler *EpochHandlerFilterer) WatchEpochFilling(opts *bind.WatchOpts, sink chan<- *EpochHandlerEpochFilling) (event.Subscription, error)

WatchEpochFilling is a free log subscription operation binding the contract event 0x27b09f0953d27bbff306fe25b2987ac5a813248ac30cb2bbd5daf95e7b0e6dc0.

Solidity: event EpochFilling(uint256 forkNumber, uint256 epochNumber)

func (*EpochHandlerFilterer) WatchEpochFinalized 

func (_EpochHandler *EpochHandlerFilterer) WatchEpochFinalized(opts *bind.WatchOpts, sink chan<- *EpochHandlerEpochFinalized) (event.Subscription, error)

WatchEpochFinalized is a free log subscription operation binding the contract event 0x70801d4d63b3da6c19ba7349911f45bed5a99ccdfb51b8138c105872529bebd5.

Solidity: event EpochFinalized(uint256 forkNumber, uint256 epochNumber, uint256 startBlockNumber, uint256 endBlockNumber)

func (*EpochHandlerFilterer) WatchEpochPrepared 

func (_EpochHandler *EpochHandlerFilterer) WatchEpochPrepared(opts *bind.WatchOpts, sink chan<- *EpochHandlerEpochPrepared) (event.Subscription, error)

WatchEpochPrepared is a free log subscription operation binding the contract event 0x1a69c0760aa329b76f72579129869013ebd3d41594db019c0e997b939fcb32e3.

Solidity: event EpochPrepared(uint256 forkNumber, uint256 epochNumber, uint256 startBlockNumber, uint256 endBlockNumber, uint256 requestStart, uint256 requestEnd, bool epochIsEmpty, bool isRequest, bool userActivated, bool rebase)

func (*EpochHandlerFilterer) WatchEpochRebased 

func (_EpochHandler *EpochHandlerFilterer) WatchEpochRebased(opts *bind.WatchOpts, sink chan<- *EpochHandlerEpochRebased) (event.Subscription, error)

WatchEpochRebased is a free log subscription operation binding the contract event 0x030c1c69405c93021f28f57557240dee939a320b826a1fd0d39bf6e629ecab47.

Solidity: event EpochRebased(uint256 forkNumber, uint256 epochNumber, uint256 startBlockNumber, uint256 endBlockNumber, uint256 requestStart, uint256 requestEnd, bool epochIsEmpty, bool isRequest, bool userActivated)

func (*EpochHandlerFilterer) WatchForked 

func (_EpochHandler *EpochHandlerFilterer) WatchForked(opts *bind.WatchOpts, sink chan<- *EpochHandlerForked) (event.Subscription, error)

WatchForked is a free log subscription operation binding the contract event 0x0647d42ab02f6e0ae76959757dcb6aa6feac1d4ba6f077f1223fb4b1b429f06c.

Solidity: event Forked(uint256 newFork, uint256 epochNumber, uint256 forkedBlockNumber)

func (*EpochHandlerFilterer) WatchOperatorChanged 

func (_EpochHandler *EpochHandlerFilterer) WatchOperatorChanged(opts *bind.WatchOpts, sink chan<- *EpochHandlerOperatorChanged) (event.Subscription, error)

WatchOperatorChanged is a free log subscription operation binding the contract event 0x4721129e0e676ed6a92909bb24e853ccdd63ad72280cc2e974e38e480e0e6e54.

Solidity: event OperatorChanged(address _newOperator)

func (*EpochHandlerFilterer) WatchRequestApplied 

func (_EpochHandler *EpochHandlerFilterer) WatchRequestApplied(opts *bind.WatchOpts, sink chan<- *EpochHandlerRequestApplied) (event.Subscription, error)

WatchRequestApplied is a free log subscription operation binding the contract event 0x6940a01870e576ceb735867e13863646d517ce10e66c0133186a4ebdfe9388c2.

Solidity: event RequestApplied(uint256 requestId, bool userActivated)

func (*EpochHandlerFilterer) WatchRequestChallenged 

func (_EpochHandler *EpochHandlerFilterer) WatchRequestChallenged(opts *bind.WatchOpts, sink chan<- *EpochHandlerRequestChallenged) (event.Subscription, error)

WatchRequestChallenged is a free log subscription operation binding the contract event 0xc8135db115644ed4ae193313c4c801235ef740d2a57a8d5e6fe26ab66635698a.

Solidity: event RequestChallenged(uint256 requestId, bool userActivated)

func (*EpochHandlerFilterer) WatchRequestCreated 

func (_EpochHandler *EpochHandlerFilterer) WatchRequestCreated(opts *bind.WatchOpts, sink chan<- *EpochHandlerRequestCreated) (event.Subscription, error)

WatchRequestCreated is a free log subscription operation binding the contract event 0x879922cf5fcada9ebaf8bd7424dc62877f4b220cae07fb6695cc1e8f94c52b4d.

Solidity: event RequestCreated(uint256 requestId, address requestor, address to, uint256 weiAmount, bytes32 trieKey, bytes trieValue, bool isExit, bool userActivated)

func (*EpochHandlerFilterer) WatchRequestFinalized 

func (_EpochHandler *EpochHandlerFilterer) WatchRequestFinalized(opts *bind.WatchOpts, sink chan<- *EpochHandlerRequestFinalized) (event.Subscription, error)

WatchRequestFinalized is a free log subscription operation binding the contract event 0x134017cf3262b18f892ee95dde3b0aec9a80cc70a7c96f09c64bd237aceb0473.

Solidity: event RequestFinalized(uint256 requestId, bool userActivated)

func (*EpochHandlerFilterer) WatchRequestableContractMapped 

func (_EpochHandler *EpochHandlerFilterer) WatchRequestableContractMapped(opts *bind.WatchOpts, sink chan<- *EpochHandlerRequestableContractMapped) (event.Subscription, error)

WatchRequestableContractMapped is a free log subscription operation binding the contract event 0xc5ec2ed49686197edd2ed642c7e6096893cc81e6658cde2527030316037715d0.

Solidity: event RequestableContractMapped(address contractInRootchain, address contractInChildchain)

func (*EpochHandlerFilterer) WatchSessionTimeout 

func (_EpochHandler *EpochHandlerFilterer) WatchSessionTimeout(opts *bind.WatchOpts, sink chan<- *EpochHandlerSessionTimeout) (event.Subscription, error)

WatchSessionTimeout is a free log subscription operation binding the contract event 0x2122ec719581cd177f225f59a1ee005831211196831f8f1ccffa817d2e7bd108.

Solidity: event SessionTimeout(bool userActivated)

type EpochHandlerForked 

type EpochHandlerForked struct {
	NewFork           *big.Int
	EpochNumber       *big.Int
	ForkedBlockNumber *big.Int
	Raw               types.Log // Blockchain specific contextual infos
}

EpochHandlerForked represents a Forked event raised by the EpochHandler contract.

type EpochHandlerForkedIterator 

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

EpochHandlerForkedIterator is returned from FilterForked and is used to iterate over the raw logs and unpacked data for Forked events raised by the EpochHandler contract.

func (*EpochHandlerForkedIterator) Close 

func (it *EpochHandlerForkedIterator) Close() error

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

func (*EpochHandlerForkedIterator) Error 

func (it *EpochHandlerForkedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EpochHandlerForkedIterator) Next 

func (it *EpochHandlerForkedIterator) 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 EpochHandlerOperatorChanged 

type EpochHandlerOperatorChanged struct {
	NewOperator common.Address
	Raw         types.Log // Blockchain specific contextual infos
}

EpochHandlerOperatorChanged represents a OperatorChanged event raised by the EpochHandler contract.

type EpochHandlerOperatorChangedIterator 

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

EpochHandlerOperatorChangedIterator is returned from FilterOperatorChanged and is used to iterate over the raw logs and unpacked data for OperatorChanged events raised by the EpochHandler contract.

func (*EpochHandlerOperatorChangedIterator) Close 

func (it *EpochHandlerOperatorChangedIterator) Close() error

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

func (*EpochHandlerOperatorChangedIterator) Error 

func (it *EpochHandlerOperatorChangedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EpochHandlerOperatorChangedIterator) Next 

func (it *EpochHandlerOperatorChangedIterator) 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 EpochHandlerRaw 

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

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

func (*EpochHandlerRaw) Call 

func (_EpochHandler *EpochHandlerRaw) 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 (*EpochHandlerRaw) Transact 

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

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

func (*EpochHandlerRaw) Transfer 

func (_EpochHandler *EpochHandlerRaw) 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 EpochHandlerRequestApplied 

type EpochHandlerRequestApplied struct {
	RequestId     *big.Int
	UserActivated bool
	Raw           types.Log // Blockchain specific contextual infos
}

EpochHandlerRequestApplied represents a RequestApplied event raised by the EpochHandler contract.

type EpochHandlerRequestAppliedIterator 

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

EpochHandlerRequestAppliedIterator is returned from FilterRequestApplied and is used to iterate over the raw logs and unpacked data for RequestApplied events raised by the EpochHandler contract.

func (*EpochHandlerRequestAppliedIterator) Close 

func (it *EpochHandlerRequestAppliedIterator) Close() error

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

func (*EpochHandlerRequestAppliedIterator) Error 

func (it *EpochHandlerRequestAppliedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EpochHandlerRequestAppliedIterator) Next 

func (it *EpochHandlerRequestAppliedIterator) 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 EpochHandlerRequestChallenged 

type EpochHandlerRequestChallenged struct {
	RequestId     *big.Int
	UserActivated bool
	Raw           types.Log // Blockchain specific contextual infos
}

EpochHandlerRequestChallenged represents a RequestChallenged event raised by the EpochHandler contract.

type EpochHandlerRequestChallengedIterator 

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

EpochHandlerRequestChallengedIterator is returned from FilterRequestChallenged and is used to iterate over the raw logs and unpacked data for RequestChallenged events raised by the EpochHandler contract.

func (*EpochHandlerRequestChallengedIterator) Close 

func (it *EpochHandlerRequestChallengedIterator) Close() error

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

func (*EpochHandlerRequestChallengedIterator) Error 

func (it *EpochHandlerRequestChallengedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EpochHandlerRequestChallengedIterator) Next 

func (it *EpochHandlerRequestChallengedIterator) 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 EpochHandlerRequestCreated 

type EpochHandlerRequestCreated struct {
	RequestId     *big.Int
	Requestor     common.Address
	To            common.Address
	WeiAmount     *big.Int
	TrieKey       [32]byte
	TrieValue     []byte
	IsExit        bool
	UserActivated bool
	Raw           types.Log // Blockchain specific contextual infos
}

EpochHandlerRequestCreated represents a RequestCreated event raised by the EpochHandler contract.

type EpochHandlerRequestCreatedIterator 

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

EpochHandlerRequestCreatedIterator is returned from FilterRequestCreated and is used to iterate over the raw logs and unpacked data for RequestCreated events raised by the EpochHandler contract.

func (*EpochHandlerRequestCreatedIterator) Close 

func (it *EpochHandlerRequestCreatedIterator) Close() error

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

func (*EpochHandlerRequestCreatedIterator) Error 

func (it *EpochHandlerRequestCreatedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EpochHandlerRequestCreatedIterator) Next 

func (it *EpochHandlerRequestCreatedIterator) 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 EpochHandlerRequestFinalized 

type EpochHandlerRequestFinalized struct {
	RequestId     *big.Int
	UserActivated bool
	Raw           types.Log // Blockchain specific contextual infos
}

EpochHandlerRequestFinalized represents a RequestFinalized event raised by the EpochHandler contract.

type EpochHandlerRequestFinalizedIterator 

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

EpochHandlerRequestFinalizedIterator is returned from FilterRequestFinalized and is used to iterate over the raw logs and unpacked data for RequestFinalized events raised by the EpochHandler contract.

func (*EpochHandlerRequestFinalizedIterator) Close 

func (it *EpochHandlerRequestFinalizedIterator) Close() error

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

func (*EpochHandlerRequestFinalizedIterator) Error 

func (it *EpochHandlerRequestFinalizedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EpochHandlerRequestFinalizedIterator) Next 

func (it *EpochHandlerRequestFinalizedIterator) 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 EpochHandlerRequestableContractMapped 

type EpochHandlerRequestableContractMapped struct {
	ContractInRootchain  common.Address
	ContractInChildchain common.Address
	Raw                  types.Log // Blockchain specific contextual infos
}

EpochHandlerRequestableContractMapped represents a RequestableContractMapped event raised by the EpochHandler contract.

type EpochHandlerRequestableContractMappedIterator 

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

EpochHandlerRequestableContractMappedIterator is returned from FilterRequestableContractMapped and is used to iterate over the raw logs and unpacked data for RequestableContractMapped events raised by the EpochHandler contract.

func (*EpochHandlerRequestableContractMappedIterator) Close 

func (it *EpochHandlerRequestableContractMappedIterator) Close() error

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

func (*EpochHandlerRequestableContractMappedIterator) Error 

func (it *EpochHandlerRequestableContractMappedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EpochHandlerRequestableContractMappedIterator) Next 

func (it *EpochHandlerRequestableContractMappedIterator) 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 EpochHandlerSession 

type EpochHandlerSession struct {
	Contract     *EpochHandler     // 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
}

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

func (*EpochHandlerSession) COSTERO 

func (_EpochHandler *EpochHandlerSession) COSTERO() (*big.Int, error)

COSTERO is a free data retrieval call binding the contract method 0xd691acd8.

Solidity: function COST_ERO() constant returns(uint256)

func (*EpochHandlerSession) COSTERU 

func (_EpochHandler *EpochHandlerSession) COSTERU() (*big.Int, error)

COSTERU is a free data retrieval call binding the contract method 0x8b5172d0.

Solidity: function COST_ERU() constant returns(uint256)

func (*EpochHandlerSession) COSTNRB 

func (_EpochHandler *EpochHandlerSession) COSTNRB() (*big.Int, error)

COSTNRB is a free data retrieval call binding the contract method 0x94be3aa5.

Solidity: function COST_NRB() constant returns(uint256)

func (*EpochHandlerSession) COSTORB 

func (_EpochHandler *EpochHandlerSession) COSTORB() (*big.Int, error)

COSTORB is a free data retrieval call binding the contract method 0xb2ae9ba8.

Solidity: function COST_ORB() constant returns(uint256)

func (*EpochHandlerSession) COSTURB 

func (_EpochHandler *EpochHandlerSession) COSTURB() (*big.Int, error)

COSTURB is a free data retrieval call binding the contract method 0x192adc5b.

Solidity: function COST_URB() constant returns(uint256)

func (*EpochHandlerSession) COSTURBPREPARE 

func (_EpochHandler *EpochHandlerSession) COSTURBPREPARE() (*big.Int, error)

COSTURBPREPARE is a free data retrieval call binding the contract method 0x033cfbed.

Solidity: function COST_URB_PREPARE() constant returns(uint256)

func (*EpochHandlerSession) CPCOMPUTATION 

func (_EpochHandler *EpochHandlerSession) CPCOMPUTATION() (*big.Int, error)

CPCOMPUTATION is a free data retrieval call binding the contract method 0x08c4fff0.

Solidity: function CP_COMPUTATION() constant returns(uint256)

func (*EpochHandlerSession) CPEXIT 

func (_EpochHandler *EpochHandlerSession) CPEXIT() (*big.Int, error)

CPEXIT is a free data retrieval call binding the contract method 0x8155717d.

Solidity: function CP_EXIT() constant returns(uint256)

func (*EpochHandlerSession) CPWITHHOLDING 

func (_EpochHandler *EpochHandlerSession) CPWITHHOLDING() (*big.Int, error)

CPWITHHOLDING is a free data retrieval call binding the contract method 0xb17fa6e9.

Solidity: function CP_WITHHOLDING() constant returns(uint256)

func (*EpochHandlerSession) CurrentFork 

func (_EpochHandler *EpochHandlerSession) CurrentFork() (*big.Int, error)

CurrentFork is a free data retrieval call binding the contract method 0x183d2d1c.

Solidity: function currentFork() constant returns(uint256)

func (*EpochHandlerSession) Development 

func (_EpochHandler *EpochHandlerSession) Development() (bool, error)

Development is a free data retrieval call binding the contract method 0x7b929c27.

Solidity: function development() constant returns(bool)

func (*EpochHandlerSession) EROIdToFinalize 

func (_EpochHandler *EpochHandlerSession) EROIdToFinalize() (*big.Int, error)

EROIdToFinalize is a free data retrieval call binding the contract method 0x2dc6bb7b.

Solidity: function EROIdToFinalize() constant returns(uint256)

func (*EpochHandlerSession) EROs 

func (_EpochHandler *EpochHandlerSession) EROs(arg0 *big.Int) (struct {
	Timestamp  uint64
	IsExit     bool
	IsTransfer bool
	Finalized  bool
	Challenged bool
	Value      *big.Int
	Requestor  common.Address
	To         common.Address
	TrieKey    [32]byte
	Hash       [32]byte
	TrieValue  []byte
}, error)

EROs is a free data retrieval call binding the contract method 0xb443f3cc.

Solidity: function EROs(uint256 ) constant returns(uint64 timestamp, bool isExit, bool isTransfer, bool finalized, bool challenged, uint128 value, address requestor, address to, bytes32 trieKey, bytes32 hash, bytes trieValue)

func (*EpochHandlerSession) ERUIdToFinalize 

func (_EpochHandler *EpochHandlerSession) ERUIdToFinalize() (*big.Int, error)

ERUIdToFinalize is a free data retrieval call binding the contract method 0xc54626cc.

Solidity: function ERUIdToFinalize() constant returns(uint256)

func (*EpochHandlerSession) ERUs 

func (_EpochHandler *EpochHandlerSession) ERUs(arg0 *big.Int) (struct {
	Timestamp  uint64
	IsExit     bool
	IsTransfer bool
	Finalized  bool
	Challenged bool
	Value      *big.Int
	Requestor  common.Address
	To         common.Address
	TrieKey    [32]byte
	Hash       [32]byte
	TrieValue  []byte
}, error)

ERUs is a free data retrieval call binding the contract method 0xf4f31de4.

Solidity: function ERUs(uint256 ) constant returns(uint64 timestamp, bool isExit, bool isTransfer, bool finalized, bool challenged, uint128 value, address requestor, address to, bytes32 trieKey, bytes32 hash, bytes trieValue)

func (*EpochHandlerSession) EpochHandler 

func (_EpochHandler *EpochHandlerSession) EpochHandler() (common.Address, error)

EpochHandler is a free data retrieval call binding the contract method 0xe7b88b80.

Solidity: function epochHandler() constant returns(address)

func (*EpochHandlerSession) EtherToken 

func (_EpochHandler *EpochHandlerSession) EtherToken() (common.Address, error)

EtherToken is a free data retrieval call binding the contract method 0xb8066bcb.

Solidity: function etherToken() constant returns(address)

func (*EpochHandlerSession) FirstFilledORENumber 

func (_EpochHandler *EpochHandlerSession) FirstFilledORENumber(arg0 *big.Int) (*big.Int, error)

FirstFilledORENumber is a free data retrieval call binding the contract method 0x72ecb9a8.

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

func (*EpochHandlerSession) FirstNonEmptyRequestEpoch 

func (_EpochHandler *EpochHandlerSession) FirstNonEmptyRequestEpoch(arg0 *big.Int) (*big.Int, error)

FirstNonEmptyRequestEpoch is a free data retrieval call binding the contract method 0xca6f6380.

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

func (*EpochHandlerSession) Forks 

func (_EpochHandler *EpochHandlerSession) Forks(arg0 *big.Int) (struct {
	ForkedBlock        uint64
	FirstEpoch         uint64
	LastEpoch          uint64
	FirstBlock         uint64
	LastBlock          uint64
	LastFinalizedEpoch uint64
	LastFinalizedBlock uint64
	Timestamp          uint64
	FirstEnterEpoch    uint64
	LastEnterEpoch     uint64
	NextBlockToRebase  uint64
	Rebased            bool
}, error)

Forks is a free data retrieval call binding the contract method 0x4ba3a126.

Solidity: function forks(uint256 ) constant returns(uint64 forkedBlock, uint64 firstEpoch, uint64 lastEpoch, uint64 firstBlock, uint64 lastBlock, uint64 lastFinalizedEpoch, uint64 lastFinalizedBlock, uint64 timestamp, uint64 firstEnterEpoch, uint64 lastEnterEpoch, uint64 nextBlockToRebase, bool rebased)

func (*EpochHandlerSession) IsRootChain 

func (_EpochHandler *EpochHandlerSession) IsRootChain() (bool, error)

IsRootChain is a free data retrieval call binding the contract method 0x420bb4b8.

Solidity: function isRootChain() constant returns(bool)

func (*EpochHandlerSession) LastAppliedBlockNumber 

func (_EpochHandler *EpochHandlerSession) LastAppliedBlockNumber() (*big.Int, error)

LastAppliedBlockNumber is a free data retrieval call binding the contract method 0xfb788a27.

Solidity: function lastAppliedBlockNumber() constant returns(uint256)

func (*EpochHandlerSession) LastAppliedEpochNumber 

func (_EpochHandler *EpochHandlerSession) LastAppliedEpochNumber() (*big.Int, error)

LastAppliedEpochNumber is a free data retrieval call binding the contract method 0xc8ad329f.

Solidity: function lastAppliedEpochNumber() constant returns(uint256)

func (*EpochHandlerSession) LastAppliedForkNumber 

func (_EpochHandler *EpochHandlerSession) LastAppliedForkNumber() (*big.Int, error)

LastAppliedForkNumber is a free data retrieval call binding the contract method 0x164bc2ae.

Solidity: function lastAppliedForkNumber() constant returns(uint256)

func (*EpochHandlerSession) LastNonEmptyRequestEpoch 

func (_EpochHandler *EpochHandlerSession) LastNonEmptyRequestEpoch(arg0 *big.Int) (*big.Int, error)

LastNonEmptyRequestEpoch is a free data retrieval call binding the contract method 0xb6715647.

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

func (*EpochHandlerSession) NRELength 

func (_EpochHandler *EpochHandlerSession) NRELength() (*big.Int, error)

NRELength is a free data retrieval call binding the contract method 0xab96da2d.

Solidity: function NRELength() constant returns(uint256)

func (*EpochHandlerSession) NULLADDRESS 

func (_EpochHandler *EpochHandlerSession) NULLADDRESS() (common.Address, error)

NULLADDRESS is a free data retrieval call binding the contract method 0xde0ce17d.

Solidity: function NULL_ADDRESS() constant returns(address)

func (*EpochHandlerSession) NumEnterForORB 

func (_EpochHandler *EpochHandlerSession) NumEnterForORB() (*big.Int, error)

NumEnterForORB is a free data retrieval call binding the contract method 0x23691566.

Solidity: function numEnterForORB() constant returns(uint256)

func (*EpochHandlerSession) ORBs 

func (_EpochHandler *EpochHandlerSession) ORBs(arg0 *big.Int) (struct {
	Submitted    bool
	NumEnter     uint64
	EpochNumber  uint64
	RequestStart uint64
	RequestEnd   uint64
	Trie         common.Address
}, error)

ORBs is a free data retrieval call binding the contract method 0xea7f22a8.

Solidity: function ORBs(uint256 ) constant returns(bool submitted, uint64 numEnter, uint64 epochNumber, uint64 requestStart, uint64 requestEnd, address trie)

func (*EpochHandlerSession) Operator 

func (_EpochHandler *EpochHandlerSession) Operator() (common.Address, error)

Operator is a free data retrieval call binding the contract method 0x570ca735.

Solidity: function operator() constant returns(address)

func (*EpochHandlerSession) PREPARETIMEOUT 

func (_EpochHandler *EpochHandlerSession) PREPARETIMEOUT() (*big.Int, error)

PREPARETIMEOUT is a free data retrieval call binding the contract method 0xc2bc88fa.

Solidity: function PREPARE_TIMEOUT() constant returns(uint256)

func (*EpochHandlerSession) PrepareNRE 

func (_EpochHandler *EpochHandlerSession) PrepareNRE() (*types.Transaction, error)

PrepareNRE is a paid mutator transaction binding the contract method 0x03787fa2.

Solidity: function prepareNRE() returns()

func (*EpochHandlerSession) PrepareNREAfterURE 

func (_EpochHandler *EpochHandlerSession) PrepareNREAfterURE() (*types.Transaction, error)

PrepareNREAfterURE is a paid mutator transaction binding the contract method 0x5656225b.

Solidity: function prepareNREAfterURE() returns()

func (*EpochHandlerSession) PrepareORE 

func (_EpochHandler *EpochHandlerSession) PrepareORE() (*types.Transaction, error)

PrepareORE is a paid mutator transaction binding the contract method 0x12d87f07.

Solidity: function prepareORE() returns()

func (*EpochHandlerSession) PrepareOREAfterURE 

func (_EpochHandler *EpochHandlerSession) PrepareOREAfterURE() (*types.Transaction, error)

PrepareOREAfterURE is a paid mutator transaction binding the contract method 0x5e9ef4f3.

Solidity: function prepareOREAfterURE() returns()

func (*EpochHandlerSession) PrepareToSubmitURB 

func (_EpochHandler *EpochHandlerSession) PrepareToSubmitURB() (*types.Transaction, error)

PrepareToSubmitURB is a paid mutator transaction binding the contract method 0xe6925d08.

Solidity: function prepareToSubmitURB() returns()

func (*EpochHandlerSession) REQUESTGAS 

func (_EpochHandler *EpochHandlerSession) REQUESTGAS() (*big.Int, error)

REQUESTGAS is a free data retrieval call binding the contract method 0x8eb288ca.

Solidity: function REQUEST_GAS() constant returns(uint256)

func (*EpochHandlerSession) RequestableContracts 

func (_EpochHandler *EpochHandlerSession) RequestableContracts(arg0 common.Address) (common.Address, error)

RequestableContracts is a free data retrieval call binding the contract method 0xda0185f8.

Solidity: function requestableContracts(address ) constant returns(address)

func (*EpochHandlerSession) SeigManager 

func (_EpochHandler *EpochHandlerSession) SeigManager() (common.Address, error)

SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.

Solidity: function seigManager() constant returns(address)

func (*EpochHandlerSession) SubmitHandler 

func (_EpochHandler *EpochHandlerSession) SubmitHandler() (common.Address, error)

SubmitHandler is a free data retrieval call binding the contract method 0xe259faf7.

Solidity: function submitHandler() constant returns(address)

func (*EpochHandlerSession) URBs 

func (_EpochHandler *EpochHandlerSession) URBs(arg0 *big.Int) (struct {
	Submitted    bool
	NumEnter     uint64
	EpochNumber  uint64
	RequestStart uint64
	RequestEnd   uint64
	Trie         common.Address
}, error)

URBs is a free data retrieval call binding the contract method 0xc0e86064.

Solidity: function URBs(uint256 ) constant returns(bool submitted, uint64 numEnter, uint64 epochNumber, uint64 requestStart, uint64 requestEnd, address trie)

type EpochHandlerSessionTimeout 

type EpochHandlerSessionTimeout struct {
	UserActivated bool
	Raw           types.Log // Blockchain specific contextual infos
}

EpochHandlerSessionTimeout represents a SessionTimeout event raised by the EpochHandler contract.

type EpochHandlerSessionTimeoutIterator 

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

EpochHandlerSessionTimeoutIterator is returned from FilterSessionTimeout and is used to iterate over the raw logs and unpacked data for SessionTimeout events raised by the EpochHandler contract.

func (*EpochHandlerSessionTimeoutIterator) Close 

func (it *EpochHandlerSessionTimeoutIterator) Close() error

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

func (*EpochHandlerSessionTimeoutIterator) Error 

func (it *EpochHandlerSessionTimeoutIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EpochHandlerSessionTimeoutIterator) Next 

func (it *EpochHandlerSessionTimeoutIterator) 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 EpochHandlerTransactor 

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

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

func NewEpochHandlerTransactor 

func NewEpochHandlerTransactor(address common.Address, transactor bind.ContractTransactor) (*EpochHandlerTransactor, error)

NewEpochHandlerTransactor creates a new write-only instance of EpochHandler, bound to a specific deployed contract.

func (*EpochHandlerTransactor) PrepareNRE 

func (_EpochHandler *EpochHandlerTransactor) PrepareNRE(opts *bind.TransactOpts) (*types.Transaction, error)

PrepareNRE is a paid mutator transaction binding the contract method 0x03787fa2.

Solidity: function prepareNRE() returns()

func (*EpochHandlerTransactor) PrepareNREAfterURE 

func (_EpochHandler *EpochHandlerTransactor) PrepareNREAfterURE(opts *bind.TransactOpts) (*types.Transaction, error)

PrepareNREAfterURE is a paid mutator transaction binding the contract method 0x5656225b.

Solidity: function prepareNREAfterURE() returns()

func (*EpochHandlerTransactor) PrepareORE 

func (_EpochHandler *EpochHandlerTransactor) PrepareORE(opts *bind.TransactOpts) (*types.Transaction, error)

PrepareORE is a paid mutator transaction binding the contract method 0x12d87f07.

Solidity: function prepareORE() returns()

func (*EpochHandlerTransactor) PrepareOREAfterURE 

func (_EpochHandler *EpochHandlerTransactor) PrepareOREAfterURE(opts *bind.TransactOpts) (*types.Transaction, error)

PrepareOREAfterURE is a paid mutator transaction binding the contract method 0x5e9ef4f3.

Solidity: function prepareOREAfterURE() returns()

func (*EpochHandlerTransactor) PrepareToSubmitURB 

func (_EpochHandler *EpochHandlerTransactor) PrepareToSubmitURB(opts *bind.TransactOpts) (*types.Transaction, error)

PrepareToSubmitURB is a paid mutator transaction binding the contract method 0xe6925d08.

Solidity: function prepareToSubmitURB() returns()

type EpochHandlerTransactorRaw 

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

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

func (*EpochHandlerTransactorRaw) Transact 

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

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

func (*EpochHandlerTransactorRaw) Transfer 

func (_EpochHandler *EpochHandlerTransactorRaw) 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 EpochHandlerTransactorSession 

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

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

func (*EpochHandlerTransactorSession) PrepareNRE 

func (_EpochHandler *EpochHandlerTransactorSession) PrepareNRE() (*types.Transaction, error)

PrepareNRE is a paid mutator transaction binding the contract method 0x03787fa2.

Solidity: function prepareNRE() returns()

func (*EpochHandlerTransactorSession) PrepareNREAfterURE 

func (_EpochHandler *EpochHandlerTransactorSession) PrepareNREAfterURE() (*types.Transaction, error)

PrepareNREAfterURE is a paid mutator transaction binding the contract method 0x5656225b.

Solidity: function prepareNREAfterURE() returns()

func (*EpochHandlerTransactorSession) PrepareORE 

func (_EpochHandler *EpochHandlerTransactorSession) PrepareORE() (*types.Transaction, error)

PrepareORE is a paid mutator transaction binding the contract method 0x12d87f07.

Solidity: function prepareORE() returns()

func (*EpochHandlerTransactorSession) PrepareOREAfterURE 

func (_EpochHandler *EpochHandlerTransactorSession) PrepareOREAfterURE() (*types.Transaction, error)

PrepareOREAfterURE is a paid mutator transaction binding the contract method 0x5e9ef4f3.

Solidity: function prepareOREAfterURE() returns()

func (*EpochHandlerTransactorSession) PrepareToSubmitURB 

func (_EpochHandler *EpochHandlerTransactorSession) PrepareToSubmitURB() (*types.Transaction, error)

PrepareToSubmitURB is a paid mutator transaction binding the contract method 0xe6925d08.

Solidity: function prepareToSubmitURB() returns()

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 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 RequestableI 

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

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

func NewRequestableI 

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

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

type RequestableICaller 

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

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

func NewRequestableICaller 

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

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

type RequestableICallerRaw 

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

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

func (*RequestableICallerRaw) Call 

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

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

type RequestableICallerSession 

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

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

type RequestableIFilterer 

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

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

func NewRequestableIFilterer 

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

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

type RequestableIRaw 

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

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

func (*RequestableIRaw) Call 

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

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

func (*RequestableIRaw) Transact 

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

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

func (*RequestableIRaw) Transfer 

func (_RequestableI *RequestableIRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

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

type RequestableISession 

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

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

func (*RequestableISession) ApplyRequestInChildChain 

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

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

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

func (*RequestableISession) ApplyRequestInRootChain 

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

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

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

type RequestableITransactor 

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

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

func NewRequestableITransactor 

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

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

func (*RequestableITransactor) ApplyRequestInChildChain 

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

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

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

func (*RequestableITransactor) ApplyRequestInRootChain 

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

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

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

type RequestableITransactorRaw 

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

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

func (*RequestableITransactorRaw) Transact 

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

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

func (*RequestableITransactorRaw) Transfer 

func (_RequestableI *RequestableITransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

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

type RequestableITransactorSession 

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

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

func (*RequestableITransactorSession) ApplyRequestInChildChain 

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

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

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

func (*RequestableITransactorSession) ApplyRequestInRootChain 

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

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

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

type RootChainEvent 

type RootChainEvent struct {
	RootChainEventCaller     // Read-only binding to the contract
	RootChainEventTransactor // Write-only binding to the contract
	RootChainEventFilterer   // Log filterer for contract events
}

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

func DeployRootChainEvent 

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

DeployRootChainEvent deploys a new Ethereum contract, binding an instance of RootChainEvent to it.

func NewRootChainEvent 

func NewRootChainEvent(address common.Address, backend bind.ContractBackend) (*RootChainEvent, error)

NewRootChainEvent creates a new instance of RootChainEvent, bound to a specific deployed contract.

type RootChainEventBlockFinalized 

type RootChainEventBlockFinalized struct {
	ForkNumber  *big.Int
	BlockNumber *big.Int
	Raw         types.Log // Blockchain specific contextual infos
}

RootChainEventBlockFinalized represents a BlockFinalized event raised by the RootChainEvent contract.

type RootChainEventBlockFinalizedIterator 

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

RootChainEventBlockFinalizedIterator is returned from FilterBlockFinalized and is used to iterate over the raw logs and unpacked data for BlockFinalized events raised by the RootChainEvent contract.

func (*RootChainEventBlockFinalizedIterator) Close 

func (it *RootChainEventBlockFinalizedIterator) Close() error

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

func (*RootChainEventBlockFinalizedIterator) Error 

func (it *RootChainEventBlockFinalizedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainEventBlockFinalizedIterator) Next 

func (it *RootChainEventBlockFinalizedIterator) 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 RootChainEventBlockSubmitted 

type RootChainEventBlockSubmitted struct {
	Fork          *big.Int
	EpochNumber   *big.Int
	BlockNumber   *big.Int
	IsRequest     bool
	UserActivated bool
	Raw           types.Log // Blockchain specific contextual infos
}

RootChainEventBlockSubmitted represents a BlockSubmitted event raised by the RootChainEvent contract.

type RootChainEventBlockSubmittedIterator 

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

RootChainEventBlockSubmittedIterator is returned from FilterBlockSubmitted and is used to iterate over the raw logs and unpacked data for BlockSubmitted events raised by the RootChainEvent contract.

func (*RootChainEventBlockSubmittedIterator) Close 

func (it *RootChainEventBlockSubmittedIterator) Close() error

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

func (*RootChainEventBlockSubmittedIterator) Error 

func (it *RootChainEventBlockSubmittedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainEventBlockSubmittedIterator) Next 

func (it *RootChainEventBlockSubmittedIterator) 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 RootChainEventCaller 

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

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

func NewRootChainEventCaller 

func NewRootChainEventCaller(address common.Address, caller bind.ContractCaller) (*RootChainEventCaller, error)

NewRootChainEventCaller creates a new read-only instance of RootChainEvent, bound to a specific deployed contract.

type RootChainEventCallerRaw 

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

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

func (*RootChainEventCallerRaw) Call 

func (_RootChainEvent *RootChainEventCallerRaw) 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 RootChainEventCallerSession 

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

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

type RootChainEventERUCreated 

type RootChainEventERUCreated struct {
	RequestId *big.Int
	Requestor common.Address
	To        common.Address
	TrieKey   []byte
	TrieValue [32]byte
	Raw       types.Log // Blockchain specific contextual infos
}

RootChainEventERUCreated represents a ERUCreated event raised by the RootChainEvent contract.

type RootChainEventERUCreatedIterator 

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

RootChainEventERUCreatedIterator is returned from FilterERUCreated and is used to iterate over the raw logs and unpacked data for ERUCreated events raised by the RootChainEvent contract.

func (*RootChainEventERUCreatedIterator) Close 

func (it *RootChainEventERUCreatedIterator) Close() error

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

func (*RootChainEventERUCreatedIterator) Error 

func (it *RootChainEventERUCreatedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainEventERUCreatedIterator) Next 

func (it *RootChainEventERUCreatedIterator) 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 RootChainEventEpochFilled 

type RootChainEventEpochFilled struct {
	ForkNumber  *big.Int
	EpochNumber *big.Int
	Raw         types.Log // Blockchain specific contextual infos
}

RootChainEventEpochFilled represents a EpochFilled event raised by the RootChainEvent contract.

type RootChainEventEpochFilledIterator 

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

RootChainEventEpochFilledIterator is returned from FilterEpochFilled and is used to iterate over the raw logs and unpacked data for EpochFilled events raised by the RootChainEvent contract.

func (*RootChainEventEpochFilledIterator) Close 

func (it *RootChainEventEpochFilledIterator) Close() error

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

func (*RootChainEventEpochFilledIterator) Error 

func (it *RootChainEventEpochFilledIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainEventEpochFilledIterator) Next 

func (it *RootChainEventEpochFilledIterator) 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 RootChainEventEpochFilling 

type RootChainEventEpochFilling struct {
	ForkNumber  *big.Int
	EpochNumber *big.Int
	Raw         types.Log // Blockchain specific contextual infos
}

RootChainEventEpochFilling represents a EpochFilling event raised by the RootChainEvent contract.

type RootChainEventEpochFillingIterator 

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

RootChainEventEpochFillingIterator is returned from FilterEpochFilling and is used to iterate over the raw logs and unpacked data for EpochFilling events raised by the RootChainEvent contract.

func (*RootChainEventEpochFillingIterator) Close 

func (it *RootChainEventEpochFillingIterator) Close() error

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

func (*RootChainEventEpochFillingIterator) Error 

func (it *RootChainEventEpochFillingIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainEventEpochFillingIterator) Next 

func (it *RootChainEventEpochFillingIterator) 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 RootChainEventEpochFinalized 

type RootChainEventEpochFinalized struct {
	ForkNumber       *big.Int
	EpochNumber      *big.Int
	StartBlockNumber *big.Int
	EndBlockNumber   *big.Int
	Raw              types.Log // Blockchain specific contextual infos
}

RootChainEventEpochFinalized represents a EpochFinalized event raised by the RootChainEvent contract.

type RootChainEventEpochFinalizedIterator 

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

RootChainEventEpochFinalizedIterator is returned from FilterEpochFinalized and is used to iterate over the raw logs and unpacked data for EpochFinalized events raised by the RootChainEvent contract.

func (*RootChainEventEpochFinalizedIterator) Close 

func (it *RootChainEventEpochFinalizedIterator) Close() error

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

func (*RootChainEventEpochFinalizedIterator) Error 

func (it *RootChainEventEpochFinalizedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainEventEpochFinalizedIterator) Next 

func (it *RootChainEventEpochFinalizedIterator) 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 RootChainEventEpochPrepared 

type RootChainEventEpochPrepared struct {
	ForkNumber       *big.Int
	EpochNumber      *big.Int
	StartBlockNumber *big.Int
	EndBlockNumber   *big.Int
	RequestStart     *big.Int
	RequestEnd       *big.Int
	EpochIsEmpty     bool
	IsRequest        bool
	UserActivated    bool
	Rebase           bool
	Raw              types.Log // Blockchain specific contextual infos
}

RootChainEventEpochPrepared represents a EpochPrepared event raised by the RootChainEvent contract.

type RootChainEventEpochPreparedIterator 

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

RootChainEventEpochPreparedIterator is returned from FilterEpochPrepared and is used to iterate over the raw logs and unpacked data for EpochPrepared events raised by the RootChainEvent contract.

func (*RootChainEventEpochPreparedIterator) Close 

func (it *RootChainEventEpochPreparedIterator) Close() error

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

func (*RootChainEventEpochPreparedIterator) Error 

func (it *RootChainEventEpochPreparedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainEventEpochPreparedIterator) Next 

func (it *RootChainEventEpochPreparedIterator) 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 RootChainEventEpochRebased 

type RootChainEventEpochRebased struct {
	ForkNumber       *big.Int
	EpochNumber      *big.Int
	StartBlockNumber *big.Int
	EndBlockNumber   *big.Int
	RequestStart     *big.Int
	RequestEnd       *big.Int
	EpochIsEmpty     bool
	IsRequest        bool
	UserActivated    bool
	Raw              types.Log // Blockchain specific contextual infos
}

RootChainEventEpochRebased represents a EpochRebased event raised by the RootChainEvent contract.

type RootChainEventEpochRebasedIterator 

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

RootChainEventEpochRebasedIterator is returned from FilterEpochRebased and is used to iterate over the raw logs and unpacked data for EpochRebased events raised by the RootChainEvent contract.

func (*RootChainEventEpochRebasedIterator) Close 

func (it *RootChainEventEpochRebasedIterator) Close() error

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

func (*RootChainEventEpochRebasedIterator) Error 

func (it *RootChainEventEpochRebasedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainEventEpochRebasedIterator) Next 

func (it *RootChainEventEpochRebasedIterator) 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 RootChainEventFilterer 

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

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

func NewRootChainEventFilterer 

func NewRootChainEventFilterer(address common.Address, filterer bind.ContractFilterer) (*RootChainEventFilterer, error)

NewRootChainEventFilterer creates a new log filterer instance of RootChainEvent, bound to a specific deployed contract.

func (*RootChainEventFilterer) FilterBlockFinalized 

func (_RootChainEvent *RootChainEventFilterer) FilterBlockFinalized(opts *bind.FilterOpts) (*RootChainEventBlockFinalizedIterator, error)

FilterBlockFinalized is a free log retrieval operation binding the contract event 0xfb96205e4b3633fd57aa805b26b51ecf528714a10241a4af015929dce86768d9.

Solidity: event BlockFinalized(uint256 forkNumber, uint256 blockNumber)

func (*RootChainEventFilterer) FilterBlockSubmitted 

func (_RootChainEvent *RootChainEventFilterer) FilterBlockSubmitted(opts *bind.FilterOpts) (*RootChainEventBlockSubmittedIterator, error)

FilterBlockSubmitted is a free log retrieval operation binding the contract event 0x3d4a04291c66b06f39a4ecb817875b12b5485a05ec563133a56a905305c48e55.

Solidity: event BlockSubmitted(uint256 fork, uint256 epochNumber, uint256 blockNumber, bool isRequest, bool userActivated)

func (*RootChainEventFilterer) FilterERUCreated 

func (_RootChainEvent *RootChainEventFilterer) FilterERUCreated(opts *bind.FilterOpts) (*RootChainEventERUCreatedIterator, error)

FilterERUCreated is a free log retrieval operation binding the contract event 0xfcbdc2083dadd644b854d91b49aef8db06b8f5a3d5c1192de38ca0ba271d5a0d.

Solidity: event ERUCreated(uint256 requestId, address requestor, address to, bytes trieKey, bytes32 trieValue)

func (*RootChainEventFilterer) FilterEpochFilled 

func (_RootChainEvent *RootChainEventFilterer) FilterEpochFilled(opts *bind.FilterOpts) (*RootChainEventEpochFilledIterator, error)

FilterEpochFilled is a free log retrieval operation binding the contract event 0x2fdeb407bf5c2b621f04b5c784822dae806c45b49a68aba413cc270128c96816.

Solidity: event EpochFilled(uint256 forkNumber, uint256 epochNumber)

func (*RootChainEventFilterer) FilterEpochFilling 

func (_RootChainEvent *RootChainEventFilterer) FilterEpochFilling(opts *bind.FilterOpts) (*RootChainEventEpochFillingIterator, error)

FilterEpochFilling is a free log retrieval operation binding the contract event 0x27b09f0953d27bbff306fe25b2987ac5a813248ac30cb2bbd5daf95e7b0e6dc0.

Solidity: event EpochFilling(uint256 forkNumber, uint256 epochNumber)

func (*RootChainEventFilterer) FilterEpochFinalized 

func (_RootChainEvent *RootChainEventFilterer) FilterEpochFinalized(opts *bind.FilterOpts) (*RootChainEventEpochFinalizedIterator, error)

FilterEpochFinalized is a free log retrieval operation binding the contract event 0x70801d4d63b3da6c19ba7349911f45bed5a99ccdfb51b8138c105872529bebd5.

Solidity: event EpochFinalized(uint256 forkNumber, uint256 epochNumber, uint256 startBlockNumber, uint256 endBlockNumber)

func (*RootChainEventFilterer) FilterEpochPrepared 

func (_RootChainEvent *RootChainEventFilterer) FilterEpochPrepared(opts *bind.FilterOpts) (*RootChainEventEpochPreparedIterator, error)

FilterEpochPrepared is a free log retrieval operation binding the contract event 0x1a69c0760aa329b76f72579129869013ebd3d41594db019c0e997b939fcb32e3.

Solidity: event EpochPrepared(uint256 forkNumber, uint256 epochNumber, uint256 startBlockNumber, uint256 endBlockNumber, uint256 requestStart, uint256 requestEnd, bool epochIsEmpty, bool isRequest, bool userActivated, bool rebase)

func (*RootChainEventFilterer) FilterEpochRebased 

func (_RootChainEvent *RootChainEventFilterer) FilterEpochRebased(opts *bind.FilterOpts) (*RootChainEventEpochRebasedIterator, error)

FilterEpochRebased is a free log retrieval operation binding the contract event 0x030c1c69405c93021f28f57557240dee939a320b826a1fd0d39bf6e629ecab47.

Solidity: event EpochRebased(uint256 forkNumber, uint256 epochNumber, uint256 startBlockNumber, uint256 endBlockNumber, uint256 requestStart, uint256 requestEnd, bool epochIsEmpty, bool isRequest, bool userActivated)

func (*RootChainEventFilterer) FilterForked 

func (_RootChainEvent *RootChainEventFilterer) FilterForked(opts *bind.FilterOpts) (*RootChainEventForkedIterator, error)

FilterForked is a free log retrieval operation binding the contract event 0x0647d42ab02f6e0ae76959757dcb6aa6feac1d4ba6f077f1223fb4b1b429f06c.

Solidity: event Forked(uint256 newFork, uint256 epochNumber, uint256 forkedBlockNumber)

func (*RootChainEventFilterer) FilterOperatorChanged 

func (_RootChainEvent *RootChainEventFilterer) FilterOperatorChanged(opts *bind.FilterOpts) (*RootChainEventOperatorChangedIterator, error)

FilterOperatorChanged is a free log retrieval operation binding the contract event 0x4721129e0e676ed6a92909bb24e853ccdd63ad72280cc2e974e38e480e0e6e54.

Solidity: event OperatorChanged(address _newOperator)

func (*RootChainEventFilterer) FilterRequestApplied 

func (_RootChainEvent *RootChainEventFilterer) FilterRequestApplied(opts *bind.FilterOpts) (*RootChainEventRequestAppliedIterator, error)

FilterRequestApplied is a free log retrieval operation binding the contract event 0x6940a01870e576ceb735867e13863646d517ce10e66c0133186a4ebdfe9388c2.

Solidity: event RequestApplied(uint256 requestId, bool userActivated)

func (*RootChainEventFilterer) FilterRequestChallenged 

func (_RootChainEvent *RootChainEventFilterer) FilterRequestChallenged(opts *bind.FilterOpts) (*RootChainEventRequestChallengedIterator, error)

FilterRequestChallenged is a free log retrieval operation binding the contract event 0xc8135db115644ed4ae193313c4c801235ef740d2a57a8d5e6fe26ab66635698a.

Solidity: event RequestChallenged(uint256 requestId, bool userActivated)

func (*RootChainEventFilterer) FilterRequestCreated 

func (_RootChainEvent *RootChainEventFilterer) FilterRequestCreated(opts *bind.FilterOpts) (*RootChainEventRequestCreatedIterator, error)

FilterRequestCreated is a free log retrieval operation binding the contract event 0x879922cf5fcada9ebaf8bd7424dc62877f4b220cae07fb6695cc1e8f94c52b4d.

Solidity: event RequestCreated(uint256 requestId, address requestor, address to, uint256 weiAmount, bytes32 trieKey, bytes trieValue, bool isExit, bool userActivated)

func (*RootChainEventFilterer) FilterRequestFinalized 

func (_RootChainEvent *RootChainEventFilterer) FilterRequestFinalized(opts *bind.FilterOpts) (*RootChainEventRequestFinalizedIterator, error)

FilterRequestFinalized is a free log retrieval operation binding the contract event 0x134017cf3262b18f892ee95dde3b0aec9a80cc70a7c96f09c64bd237aceb0473.

Solidity: event RequestFinalized(uint256 requestId, bool userActivated)

func (*RootChainEventFilterer) FilterRequestableContractMapped 

func (_RootChainEvent *RootChainEventFilterer) FilterRequestableContractMapped(opts *bind.FilterOpts) (*RootChainEventRequestableContractMappedIterator, error)

FilterRequestableContractMapped is a free log retrieval operation binding the contract event 0xc5ec2ed49686197edd2ed642c7e6096893cc81e6658cde2527030316037715d0.

Solidity: event RequestableContractMapped(address contractInRootchain, address contractInChildchain)

func (*RootChainEventFilterer) FilterSessionTimeout 

func (_RootChainEvent *RootChainEventFilterer) FilterSessionTimeout(opts *bind.FilterOpts) (*RootChainEventSessionTimeoutIterator, error)

FilterSessionTimeout is a free log retrieval operation binding the contract event 0x2122ec719581cd177f225f59a1ee005831211196831f8f1ccffa817d2e7bd108.

Solidity: event SessionTimeout(bool userActivated)

func (*RootChainEventFilterer) ParseBlockFinalized 

func (_RootChainEvent *RootChainEventFilterer) ParseBlockFinalized(log types.Log) (*RootChainEventBlockFinalized, error)

ParseBlockFinalized is a log parse operation binding the contract event 0xfb96205e4b3633fd57aa805b26b51ecf528714a10241a4af015929dce86768d9.

Solidity: event BlockFinalized(uint256 forkNumber, uint256 blockNumber)

func (*RootChainEventFilterer) ParseBlockSubmitted 

func (_RootChainEvent *RootChainEventFilterer) ParseBlockSubmitted(log types.Log) (*RootChainEventBlockSubmitted, error)

ParseBlockSubmitted is a log parse operation binding the contract event 0x3d4a04291c66b06f39a4ecb817875b12b5485a05ec563133a56a905305c48e55.

Solidity: event BlockSubmitted(uint256 fork, uint256 epochNumber, uint256 blockNumber, bool isRequest, bool userActivated)

func (*RootChainEventFilterer) ParseERUCreated 

func (_RootChainEvent *RootChainEventFilterer) ParseERUCreated(log types.Log) (*RootChainEventERUCreated, error)

ParseERUCreated is a log parse operation binding the contract event 0xfcbdc2083dadd644b854d91b49aef8db06b8f5a3d5c1192de38ca0ba271d5a0d.

Solidity: event ERUCreated(uint256 requestId, address requestor, address to, bytes trieKey, bytes32 trieValue)

func (*RootChainEventFilterer) ParseEpochFilled 

func (_RootChainEvent *RootChainEventFilterer) ParseEpochFilled(log types.Log) (*RootChainEventEpochFilled, error)

ParseEpochFilled is a log parse operation binding the contract event 0x2fdeb407bf5c2b621f04b5c784822dae806c45b49a68aba413cc270128c96816.

Solidity: event EpochFilled(uint256 forkNumber, uint256 epochNumber)

func (*RootChainEventFilterer) ParseEpochFilling 

func (_RootChainEvent *RootChainEventFilterer) ParseEpochFilling(log types.Log) (*RootChainEventEpochFilling, error)

ParseEpochFilling is a log parse operation binding the contract event 0x27b09f0953d27bbff306fe25b2987ac5a813248ac30cb2bbd5daf95e7b0e6dc0.

Solidity: event EpochFilling(uint256 forkNumber, uint256 epochNumber)

func (*RootChainEventFilterer) ParseEpochFinalized 

func (_RootChainEvent *RootChainEventFilterer) ParseEpochFinalized(log types.Log) (*RootChainEventEpochFinalized, error)

ParseEpochFinalized is a log parse operation binding the contract event 0x70801d4d63b3da6c19ba7349911f45bed5a99ccdfb51b8138c105872529bebd5.

Solidity: event EpochFinalized(uint256 forkNumber, uint256 epochNumber, uint256 startBlockNumber, uint256 endBlockNumber)

func (*RootChainEventFilterer) ParseEpochPrepared 

func (_RootChainEvent *RootChainEventFilterer) ParseEpochPrepared(log types.Log) (*RootChainEventEpochPrepared, error)

ParseEpochPrepared is a log parse operation binding the contract event 0x1a69c0760aa329b76f72579129869013ebd3d41594db019c0e997b939fcb32e3.

Solidity: event EpochPrepared(uint256 forkNumber, uint256 epochNumber, uint256 startBlockNumber, uint256 endBlockNumber, uint256 requestStart, uint256 requestEnd, bool epochIsEmpty, bool isRequest, bool userActivated, bool rebase)

func (*RootChainEventFilterer) ParseEpochRebased 

func (_RootChainEvent *RootChainEventFilterer) ParseEpochRebased(log types.Log) (*RootChainEventEpochRebased, error)

ParseEpochRebased is a log parse operation binding the contract event 0x030c1c69405c93021f28f57557240dee939a320b826a1fd0d39bf6e629ecab47.

Solidity: event EpochRebased(uint256 forkNumber, uint256 epochNumber, uint256 startBlockNumber, uint256 endBlockNumber, uint256 requestStart, uint256 requestEnd, bool epochIsEmpty, bool isRequest, bool userActivated)

func (*RootChainEventFilterer) ParseForked 

func (_RootChainEvent *RootChainEventFilterer) ParseForked(log types.Log) (*RootChainEventForked, error)

ParseForked is a log parse operation binding the contract event 0x0647d42ab02f6e0ae76959757dcb6aa6feac1d4ba6f077f1223fb4b1b429f06c.

Solidity: event Forked(uint256 newFork, uint256 epochNumber, uint256 forkedBlockNumber)

func (*RootChainEventFilterer) ParseOperatorChanged 

func (_RootChainEvent *RootChainEventFilterer) ParseOperatorChanged(log types.Log) (*RootChainEventOperatorChanged, error)

ParseOperatorChanged is a log parse operation binding the contract event 0x4721129e0e676ed6a92909bb24e853ccdd63ad72280cc2e974e38e480e0e6e54.

Solidity: event OperatorChanged(address _newOperator)

func (*RootChainEventFilterer) ParseRequestApplied 

func (_RootChainEvent *RootChainEventFilterer) ParseRequestApplied(log types.Log) (*RootChainEventRequestApplied, error)

ParseRequestApplied is a log parse operation binding the contract event 0x6940a01870e576ceb735867e13863646d517ce10e66c0133186a4ebdfe9388c2.

Solidity: event RequestApplied(uint256 requestId, bool userActivated)

func (*RootChainEventFilterer) ParseRequestChallenged 

func (_RootChainEvent *RootChainEventFilterer) ParseRequestChallenged(log types.Log) (*RootChainEventRequestChallenged, error)

ParseRequestChallenged is a log parse operation binding the contract event 0xc8135db115644ed4ae193313c4c801235ef740d2a57a8d5e6fe26ab66635698a.

Solidity: event RequestChallenged(uint256 requestId, bool userActivated)

func (*RootChainEventFilterer) ParseRequestCreated 

func (_RootChainEvent *RootChainEventFilterer) ParseRequestCreated(log types.Log) (*RootChainEventRequestCreated, error)

ParseRequestCreated is a log parse operation binding the contract event 0x879922cf5fcada9ebaf8bd7424dc62877f4b220cae07fb6695cc1e8f94c52b4d.

Solidity: event RequestCreated(uint256 requestId, address requestor, address to, uint256 weiAmount, bytes32 trieKey, bytes trieValue, bool isExit, bool userActivated)

func (*RootChainEventFilterer) ParseRequestFinalized 

func (_RootChainEvent *RootChainEventFilterer) ParseRequestFinalized(log types.Log) (*RootChainEventRequestFinalized, error)

ParseRequestFinalized is a log parse operation binding the contract event 0x134017cf3262b18f892ee95dde3b0aec9a80cc70a7c96f09c64bd237aceb0473.

Solidity: event RequestFinalized(uint256 requestId, bool userActivated)

func (*RootChainEventFilterer) ParseRequestableContractMapped 

func (_RootChainEvent *RootChainEventFilterer) ParseRequestableContractMapped(log types.Log) (*RootChainEventRequestableContractMapped, error)

ParseRequestableContractMapped is a log parse operation binding the contract event 0xc5ec2ed49686197edd2ed642c7e6096893cc81e6658cde2527030316037715d0.

Solidity: event RequestableContractMapped(address contractInRootchain, address contractInChildchain)

func (*RootChainEventFilterer) ParseSessionTimeout 

func (_RootChainEvent *RootChainEventFilterer) ParseSessionTimeout(log types.Log) (*RootChainEventSessionTimeout, error)

ParseSessionTimeout is a log parse operation binding the contract event 0x2122ec719581cd177f225f59a1ee005831211196831f8f1ccffa817d2e7bd108.

Solidity: event SessionTimeout(bool userActivated)

func (*RootChainEventFilterer) WatchBlockFinalized 

func (_RootChainEvent *RootChainEventFilterer) WatchBlockFinalized(opts *bind.WatchOpts, sink chan<- *RootChainEventBlockFinalized) (event.Subscription, error)

WatchBlockFinalized is a free log subscription operation binding the contract event 0xfb96205e4b3633fd57aa805b26b51ecf528714a10241a4af015929dce86768d9.

Solidity: event BlockFinalized(uint256 forkNumber, uint256 blockNumber)

func (*RootChainEventFilterer) WatchBlockSubmitted 

func (_RootChainEvent *RootChainEventFilterer) WatchBlockSubmitted(opts *bind.WatchOpts, sink chan<- *RootChainEventBlockSubmitted) (event.Subscription, error)

WatchBlockSubmitted is a free log subscription operation binding the contract event 0x3d4a04291c66b06f39a4ecb817875b12b5485a05ec563133a56a905305c48e55.

Solidity: event BlockSubmitted(uint256 fork, uint256 epochNumber, uint256 blockNumber, bool isRequest, bool userActivated)

func (*RootChainEventFilterer) WatchERUCreated 

func (_RootChainEvent *RootChainEventFilterer) WatchERUCreated(opts *bind.WatchOpts, sink chan<- *RootChainEventERUCreated) (event.Subscription, error)

WatchERUCreated is a free log subscription operation binding the contract event 0xfcbdc2083dadd644b854d91b49aef8db06b8f5a3d5c1192de38ca0ba271d5a0d.

Solidity: event ERUCreated(uint256 requestId, address requestor, address to, bytes trieKey, bytes32 trieValue)

func (*RootChainEventFilterer) WatchEpochFilled 

func (_RootChainEvent *RootChainEventFilterer) WatchEpochFilled(opts *bind.WatchOpts, sink chan<- *RootChainEventEpochFilled) (event.Subscription, error)

WatchEpochFilled is a free log subscription operation binding the contract event 0x2fdeb407bf5c2b621f04b5c784822dae806c45b49a68aba413cc270128c96816.

Solidity: event EpochFilled(uint256 forkNumber, uint256 epochNumber)

func (*RootChainEventFilterer) WatchEpochFilling 

func (_RootChainEvent *RootChainEventFilterer) WatchEpochFilling(opts *bind.WatchOpts, sink chan<- *RootChainEventEpochFilling) (event.Subscription, error)

WatchEpochFilling is a free log subscription operation binding the contract event 0x27b09f0953d27bbff306fe25b2987ac5a813248ac30cb2bbd5daf95e7b0e6dc0.

Solidity: event EpochFilling(uint256 forkNumber, uint256 epochNumber)

func (*RootChainEventFilterer) WatchEpochFinalized 

func (_RootChainEvent *RootChainEventFilterer) WatchEpochFinalized(opts *bind.WatchOpts, sink chan<- *RootChainEventEpochFinalized) (event.Subscription, error)

WatchEpochFinalized is a free log subscription operation binding the contract event 0x70801d4d63b3da6c19ba7349911f45bed5a99ccdfb51b8138c105872529bebd5.

Solidity: event EpochFinalized(uint256 forkNumber, uint256 epochNumber, uint256 startBlockNumber, uint256 endBlockNumber)

func (*RootChainEventFilterer) WatchEpochPrepared 

func (_RootChainEvent *RootChainEventFilterer) WatchEpochPrepared(opts *bind.WatchOpts, sink chan<- *RootChainEventEpochPrepared) (event.Subscription, error)

WatchEpochPrepared is a free log subscription operation binding the contract event 0x1a69c0760aa329b76f72579129869013ebd3d41594db019c0e997b939fcb32e3.

Solidity: event EpochPrepared(uint256 forkNumber, uint256 epochNumber, uint256 startBlockNumber, uint256 endBlockNumber, uint256 requestStart, uint256 requestEnd, bool epochIsEmpty, bool isRequest, bool userActivated, bool rebase)

func (*RootChainEventFilterer) WatchEpochRebased 

func (_RootChainEvent *RootChainEventFilterer) WatchEpochRebased(opts *bind.WatchOpts, sink chan<- *RootChainEventEpochRebased) (event.Subscription, error)

WatchEpochRebased is a free log subscription operation binding the contract event 0x030c1c69405c93021f28f57557240dee939a320b826a1fd0d39bf6e629ecab47.

Solidity: event EpochRebased(uint256 forkNumber, uint256 epochNumber, uint256 startBlockNumber, uint256 endBlockNumber, uint256 requestStart, uint256 requestEnd, bool epochIsEmpty, bool isRequest, bool userActivated)

func (*RootChainEventFilterer) WatchForked 

func (_RootChainEvent *RootChainEventFilterer) WatchForked(opts *bind.WatchOpts, sink chan<- *RootChainEventForked) (event.Subscription, error)

WatchForked is a free log subscription operation binding the contract event 0x0647d42ab02f6e0ae76959757dcb6aa6feac1d4ba6f077f1223fb4b1b429f06c.

Solidity: event Forked(uint256 newFork, uint256 epochNumber, uint256 forkedBlockNumber)

func (*RootChainEventFilterer) WatchOperatorChanged 

func (_RootChainEvent *RootChainEventFilterer) WatchOperatorChanged(opts *bind.WatchOpts, sink chan<- *RootChainEventOperatorChanged) (event.Subscription, error)

WatchOperatorChanged is a free log subscription operation binding the contract event 0x4721129e0e676ed6a92909bb24e853ccdd63ad72280cc2e974e38e480e0e6e54.

Solidity: event OperatorChanged(address _newOperator)

func (*RootChainEventFilterer) WatchRequestApplied 

func (_RootChainEvent *RootChainEventFilterer) WatchRequestApplied(opts *bind.WatchOpts, sink chan<- *RootChainEventRequestApplied) (event.Subscription, error)

WatchRequestApplied is a free log subscription operation binding the contract event 0x6940a01870e576ceb735867e13863646d517ce10e66c0133186a4ebdfe9388c2.

Solidity: event RequestApplied(uint256 requestId, bool userActivated)

func (*RootChainEventFilterer) WatchRequestChallenged 

func (_RootChainEvent *RootChainEventFilterer) WatchRequestChallenged(opts *bind.WatchOpts, sink chan<- *RootChainEventRequestChallenged) (event.Subscription, error)

WatchRequestChallenged is a free log subscription operation binding the contract event 0xc8135db115644ed4ae193313c4c801235ef740d2a57a8d5e6fe26ab66635698a.

Solidity: event RequestChallenged(uint256 requestId, bool userActivated)

func (*RootChainEventFilterer) WatchRequestCreated 

func (_RootChainEvent *RootChainEventFilterer) WatchRequestCreated(opts *bind.WatchOpts, sink chan<- *RootChainEventRequestCreated) (event.Subscription, error)

WatchRequestCreated is a free log subscription operation binding the contract event 0x879922cf5fcada9ebaf8bd7424dc62877f4b220cae07fb6695cc1e8f94c52b4d.

Solidity: event RequestCreated(uint256 requestId, address requestor, address to, uint256 weiAmount, bytes32 trieKey, bytes trieValue, bool isExit, bool userActivated)

func (*RootChainEventFilterer) WatchRequestFinalized 

func (_RootChainEvent *RootChainEventFilterer) WatchRequestFinalized(opts *bind.WatchOpts, sink chan<- *RootChainEventRequestFinalized) (event.Subscription, error)

WatchRequestFinalized is a free log subscription operation binding the contract event 0x134017cf3262b18f892ee95dde3b0aec9a80cc70a7c96f09c64bd237aceb0473.

Solidity: event RequestFinalized(uint256 requestId, bool userActivated)

func (*RootChainEventFilterer) WatchRequestableContractMapped 

func (_RootChainEvent *RootChainEventFilterer) WatchRequestableContractMapped(opts *bind.WatchOpts, sink chan<- *RootChainEventRequestableContractMapped) (event.Subscription, error)

WatchRequestableContractMapped is a free log subscription operation binding the contract event 0xc5ec2ed49686197edd2ed642c7e6096893cc81e6658cde2527030316037715d0.

Solidity: event RequestableContractMapped(address contractInRootchain, address contractInChildchain)

func (*RootChainEventFilterer) WatchSessionTimeout 

func (_RootChainEvent *RootChainEventFilterer) WatchSessionTimeout(opts *bind.WatchOpts, sink chan<- *RootChainEventSessionTimeout) (event.Subscription, error)

WatchSessionTimeout is a free log subscription operation binding the contract event 0x2122ec719581cd177f225f59a1ee005831211196831f8f1ccffa817d2e7bd108.

Solidity: event SessionTimeout(bool userActivated)

type RootChainEventForked 

type RootChainEventForked struct {
	NewFork           *big.Int
	EpochNumber       *big.Int
	ForkedBlockNumber *big.Int
	Raw               types.Log // Blockchain specific contextual infos
}

RootChainEventForked represents a Forked event raised by the RootChainEvent contract.

type RootChainEventForkedIterator 

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

RootChainEventForkedIterator is returned from FilterForked and is used to iterate over the raw logs and unpacked data for Forked events raised by the RootChainEvent contract.

func (*RootChainEventForkedIterator) Close 

func (it *RootChainEventForkedIterator) Close() error

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

func (*RootChainEventForkedIterator) Error 

func (it *RootChainEventForkedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainEventForkedIterator) Next 

func (it *RootChainEventForkedIterator) 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 RootChainEventOperatorChanged 

type RootChainEventOperatorChanged struct {
	NewOperator common.Address
	Raw         types.Log // Blockchain specific contextual infos
}

RootChainEventOperatorChanged represents a OperatorChanged event raised by the RootChainEvent contract.

type RootChainEventOperatorChangedIterator 

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

RootChainEventOperatorChangedIterator is returned from FilterOperatorChanged and is used to iterate over the raw logs and unpacked data for OperatorChanged events raised by the RootChainEvent contract.

func (*RootChainEventOperatorChangedIterator) Close 

func (it *RootChainEventOperatorChangedIterator) Close() error

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

func (*RootChainEventOperatorChangedIterator) Error 

func (it *RootChainEventOperatorChangedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainEventOperatorChangedIterator) Next 

func (it *RootChainEventOperatorChangedIterator) 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 RootChainEventRaw 

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

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

func (*RootChainEventRaw) Call 

func (_RootChainEvent *RootChainEventRaw) 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 (*RootChainEventRaw) Transact 

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

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

func (*RootChainEventRaw) Transfer 

func (_RootChainEvent *RootChainEventRaw) 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 RootChainEventRequestApplied 

type RootChainEventRequestApplied struct {
	RequestId     *big.Int
	UserActivated bool
	Raw           types.Log // Blockchain specific contextual infos
}

RootChainEventRequestApplied represents a RequestApplied event raised by the RootChainEvent contract.

type RootChainEventRequestAppliedIterator 

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

RootChainEventRequestAppliedIterator is returned from FilterRequestApplied and is used to iterate over the raw logs and unpacked data for RequestApplied events raised by the RootChainEvent contract.

func (*RootChainEventRequestAppliedIterator) Close 

func (it *RootChainEventRequestAppliedIterator) Close() error

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

func (*RootChainEventRequestAppliedIterator) Error 

func (it *RootChainEventRequestAppliedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainEventRequestAppliedIterator) Next 

func (it *RootChainEventRequestAppliedIterator) 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 RootChainEventRequestChallenged 

type RootChainEventRequestChallenged struct {
	RequestId     *big.Int
	UserActivated bool
	Raw           types.Log // Blockchain specific contextual infos
}

RootChainEventRequestChallenged represents a RequestChallenged event raised by the RootChainEvent contract.

type RootChainEventRequestChallengedIterator 

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

RootChainEventRequestChallengedIterator is returned from FilterRequestChallenged and is used to iterate over the raw logs and unpacked data for RequestChallenged events raised by the RootChainEvent contract.

func (*RootChainEventRequestChallengedIterator) Close 

func (it *RootChainEventRequestChallengedIterator) Close() error

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

func (*RootChainEventRequestChallengedIterator) Error 

func (it *RootChainEventRequestChallengedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainEventRequestChallengedIterator) Next 

func (it *RootChainEventRequestChallengedIterator) 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 RootChainEventRequestCreated 

type RootChainEventRequestCreated struct {
	RequestId     *big.Int
	Requestor     common.Address
	To            common.Address
	WeiAmount     *big.Int
	TrieKey       [32]byte
	TrieValue     []byte
	IsExit        bool
	UserActivated bool
	Raw           types.Log // Blockchain specific contextual infos
}

RootChainEventRequestCreated represents a RequestCreated event raised by the RootChainEvent contract.

type RootChainEventRequestCreatedIterator 

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

RootChainEventRequestCreatedIterator is returned from FilterRequestCreated and is used to iterate over the raw logs and unpacked data for RequestCreated events raised by the RootChainEvent contract.

func (*RootChainEventRequestCreatedIterator) Close 

func (it *RootChainEventRequestCreatedIterator) Close() error

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

func (*RootChainEventRequestCreatedIterator) Error 

func (it *RootChainEventRequestCreatedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainEventRequestCreatedIterator) Next 

func (it *RootChainEventRequestCreatedIterator) 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 RootChainEventRequestFinalized 

type RootChainEventRequestFinalized struct {
	RequestId     *big.Int
	UserActivated bool
	Raw           types.Log // Blockchain specific contextual infos
}

RootChainEventRequestFinalized represents a RequestFinalized event raised by the RootChainEvent contract.

type RootChainEventRequestFinalizedIterator 

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

RootChainEventRequestFinalizedIterator is returned from FilterRequestFinalized and is used to iterate over the raw logs and unpacked data for RequestFinalized events raised by the RootChainEvent contract.

func (*RootChainEventRequestFinalizedIterator) Close 

func (it *RootChainEventRequestFinalizedIterator) Close() error

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

func (*RootChainEventRequestFinalizedIterator) Error 

func (it *RootChainEventRequestFinalizedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainEventRequestFinalizedIterator) Next 

func (it *RootChainEventRequestFinalizedIterator) 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 RootChainEventRequestableContractMapped 

type RootChainEventRequestableContractMapped struct {
	ContractInRootchain  common.Address
	ContractInChildchain common.Address
	Raw                  types.Log // Blockchain specific contextual infos
}

RootChainEventRequestableContractMapped represents a RequestableContractMapped event raised by the RootChainEvent contract.

type RootChainEventRequestableContractMappedIterator 

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

RootChainEventRequestableContractMappedIterator is returned from FilterRequestableContractMapped and is used to iterate over the raw logs and unpacked data for RequestableContractMapped events raised by the RootChainEvent contract.

func (*RootChainEventRequestableContractMappedIterator) Close 

func (it *RootChainEventRequestableContractMappedIterator) Close() error

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

func (*RootChainEventRequestableContractMappedIterator) Error 

func (it *RootChainEventRequestableContractMappedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainEventRequestableContractMappedIterator) Next 

func (it *RootChainEventRequestableContractMappedIterator) 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 RootChainEventSession 

type RootChainEventSession struct {
	Contract     *RootChainEvent   // 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
}

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

type RootChainEventSessionTimeout 

type RootChainEventSessionTimeout struct {
	UserActivated bool
	Raw           types.Log // Blockchain specific contextual infos
}

RootChainEventSessionTimeout represents a SessionTimeout event raised by the RootChainEvent contract.

type RootChainEventSessionTimeoutIterator 

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

RootChainEventSessionTimeoutIterator is returned from FilterSessionTimeout and is used to iterate over the raw logs and unpacked data for SessionTimeout events raised by the RootChainEvent contract.

func (*RootChainEventSessionTimeoutIterator) Close 

func (it *RootChainEventSessionTimeoutIterator) Close() error

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

func (*RootChainEventSessionTimeoutIterator) Error 

func (it *RootChainEventSessionTimeoutIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainEventSessionTimeoutIterator) Next 

func (it *RootChainEventSessionTimeoutIterator) 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 RootChainEventTransactor 

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

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

func NewRootChainEventTransactor 

func NewRootChainEventTransactor(address common.Address, transactor bind.ContractTransactor) (*RootChainEventTransactor, error)

NewRootChainEventTransactor creates a new write-only instance of RootChainEvent, bound to a specific deployed contract.

type RootChainEventTransactorRaw 

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

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

func (*RootChainEventTransactorRaw) Transact 

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

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

func (*RootChainEventTransactorRaw) Transfer 

func (_RootChainEvent *RootChainEventTransactorRaw) 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 RootChainEventTransactorSession 

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

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

type RootChainStorage 

type RootChainStorage struct {
	RootChainStorageCaller     // Read-only binding to the contract
	RootChainStorageTransactor // Write-only binding to the contract
	RootChainStorageFilterer   // Log filterer for contract events
}

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

func DeployRootChainStorage 

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

DeployRootChainStorage deploys a new Ethereum contract, binding an instance of RootChainStorage to it.

func NewRootChainStorage 

func NewRootChainStorage(address common.Address, backend bind.ContractBackend) (*RootChainStorage, error)

NewRootChainStorage creates a new instance of RootChainStorage, bound to a specific deployed contract.

type RootChainStorageCaller 

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

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

func NewRootChainStorageCaller 

func NewRootChainStorageCaller(address common.Address, caller bind.ContractCaller) (*RootChainStorageCaller, error)

NewRootChainStorageCaller creates a new read-only instance of RootChainStorage, bound to a specific deployed contract.

func (*RootChainStorageCaller) COSTERO 

func (_RootChainStorage *RootChainStorageCaller) COSTERO(opts *bind.CallOpts) (*big.Int, error)

COSTERO is a free data retrieval call binding the contract method 0xd691acd8.

Solidity: function COST_ERO() constant returns(uint256)

func (*RootChainStorageCaller) COSTERU 

func (_RootChainStorage *RootChainStorageCaller) COSTERU(opts *bind.CallOpts) (*big.Int, error)

COSTERU is a free data retrieval call binding the contract method 0x8b5172d0.

Solidity: function COST_ERU() constant returns(uint256)

func (*RootChainStorageCaller) COSTNRB 

func (_RootChainStorage *RootChainStorageCaller) COSTNRB(opts *bind.CallOpts) (*big.Int, error)

COSTNRB is a free data retrieval call binding the contract method 0x94be3aa5.

Solidity: function COST_NRB() constant returns(uint256)

func (*RootChainStorageCaller) COSTORB 

func (_RootChainStorage *RootChainStorageCaller) COSTORB(opts *bind.CallOpts) (*big.Int, error)

COSTORB is a free data retrieval call binding the contract method 0xb2ae9ba8.

Solidity: function COST_ORB() constant returns(uint256)

func (*RootChainStorageCaller) COSTURB 

func (_RootChainStorage *RootChainStorageCaller) COSTURB(opts *bind.CallOpts) (*big.Int, error)

COSTURB is a free data retrieval call binding the contract method 0x192adc5b.

Solidity: function COST_URB() constant returns(uint256)

func (*RootChainStorageCaller) COSTURBPREPARE 

func (_RootChainStorage *RootChainStorageCaller) COSTURBPREPARE(opts *bind.CallOpts) (*big.Int, error)

COSTURBPREPARE is a free data retrieval call binding the contract method 0x033cfbed.

Solidity: function COST_URB_PREPARE() constant returns(uint256)

func (*RootChainStorageCaller) CPCOMPUTATION 

func (_RootChainStorage *RootChainStorageCaller) CPCOMPUTATION(opts *bind.CallOpts) (*big.Int, error)

CPCOMPUTATION is a free data retrieval call binding the contract method 0x08c4fff0.

Solidity: function CP_COMPUTATION() constant returns(uint256)

func (*RootChainStorageCaller) CPEXIT 

func (_RootChainStorage *RootChainStorageCaller) CPEXIT(opts *bind.CallOpts) (*big.Int, error)

CPEXIT is a free data retrieval call binding the contract method 0x8155717d.

Solidity: function CP_EXIT() constant returns(uint256)

func (*RootChainStorageCaller) CPWITHHOLDING 

func (_RootChainStorage *RootChainStorageCaller) CPWITHHOLDING(opts *bind.CallOpts) (*big.Int, error)

CPWITHHOLDING is a free data retrieval call binding the contract method 0xb17fa6e9.

Solidity: function CP_WITHHOLDING() constant returns(uint256)

func (*RootChainStorageCaller) CurrentFork 

func (_RootChainStorage *RootChainStorageCaller) CurrentFork(opts *bind.CallOpts) (*big.Int, error)

CurrentFork is a free data retrieval call binding the contract method 0x183d2d1c.

Solidity: function currentFork() constant returns(uint256)

func (*RootChainStorageCaller) Development 

func (_RootChainStorage *RootChainStorageCaller) Development(opts *bind.CallOpts) (bool, error)

Development is a free data retrieval call binding the contract method 0x7b929c27.

Solidity: function development() constant returns(bool)

func (*RootChainStorageCaller) EROIdToFinalize 

func (_RootChainStorage *RootChainStorageCaller) EROIdToFinalize(opts *bind.CallOpts) (*big.Int, error)

EROIdToFinalize is a free data retrieval call binding the contract method 0x2dc6bb7b.

Solidity: function EROIdToFinalize() constant returns(uint256)

func (*RootChainStorageCaller) EROs 

func (_RootChainStorage *RootChainStorageCaller) EROs(opts *bind.CallOpts, arg0 *big.Int) (struct {
	Timestamp  uint64
	IsExit     bool
	IsTransfer bool
	Finalized  bool
	Challenged bool
	Value      *big.Int
	Requestor  common.Address
	To         common.Address
	TrieKey    [32]byte
	Hash       [32]byte
	TrieValue  []byte
}, error)

EROs is a free data retrieval call binding the contract method 0xb443f3cc.

Solidity: function EROs(uint256 ) constant returns(uint64 timestamp, bool isExit, bool isTransfer, bool finalized, bool challenged, uint128 value, address requestor, address to, bytes32 trieKey, bytes32 hash, bytes trieValue)

func (*RootChainStorageCaller) ERUIdToFinalize 

func (_RootChainStorage *RootChainStorageCaller) ERUIdToFinalize(opts *bind.CallOpts) (*big.Int, error)

ERUIdToFinalize is a free data retrieval call binding the contract method 0xc54626cc.

Solidity: function ERUIdToFinalize() constant returns(uint256)

func (*RootChainStorageCaller) ERUs 

func (_RootChainStorage *RootChainStorageCaller) ERUs(opts *bind.CallOpts, arg0 *big.Int) (struct {
	Timestamp  uint64
	IsExit     bool
	IsTransfer bool
	Finalized  bool
	Challenged bool
	Value      *big.Int
	Requestor  common.Address
	To         common.Address
	TrieKey    [32]byte
	Hash       [32]byte
	TrieValue  []byte
}, error)

ERUs is a free data retrieval call binding the contract method 0xf4f31de4.

Solidity: function ERUs(uint256 ) constant returns(uint64 timestamp, bool isExit, bool isTransfer, bool finalized, bool challenged, uint128 value, address requestor, address to, bytes32 trieKey, bytes32 hash, bytes trieValue)

func (*RootChainStorageCaller) EpochHandler 

func (_RootChainStorage *RootChainStorageCaller) EpochHandler(opts *bind.CallOpts) (common.Address, error)

EpochHandler is a free data retrieval call binding the contract method 0xe7b88b80.

Solidity: function epochHandler() constant returns(address)

func (*RootChainStorageCaller) EtherToken 

func (_RootChainStorage *RootChainStorageCaller) EtherToken(opts *bind.CallOpts) (common.Address, error)

EtherToken is a free data retrieval call binding the contract method 0xb8066bcb.

Solidity: function etherToken() constant returns(address)

func (*RootChainStorageCaller) FirstFilledORENumber 

func (_RootChainStorage *RootChainStorageCaller) FirstFilledORENumber(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error)

FirstFilledORENumber is a free data retrieval call binding the contract method 0x72ecb9a8.

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

func (*RootChainStorageCaller) FirstNonEmptyRequestEpoch 

func (_RootChainStorage *RootChainStorageCaller) FirstNonEmptyRequestEpoch(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error)

FirstNonEmptyRequestEpoch is a free data retrieval call binding the contract method 0xca6f6380.

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

func (*RootChainStorageCaller) Forks 

func (_RootChainStorage *RootChainStorageCaller) Forks(opts *bind.CallOpts, arg0 *big.Int) (struct {
	ForkedBlock        uint64
	FirstEpoch         uint64
	LastEpoch          uint64
	FirstBlock         uint64
	LastBlock          uint64
	LastFinalizedEpoch uint64
	LastFinalizedBlock uint64
	Timestamp          uint64
	FirstEnterEpoch    uint64
	LastEnterEpoch     uint64
	NextBlockToRebase  uint64
	Rebased            bool
}, error)

Forks is a free data retrieval call binding the contract method 0x4ba3a126.

Solidity: function forks(uint256 ) constant returns(uint64 forkedBlock, uint64 firstEpoch, uint64 lastEpoch, uint64 firstBlock, uint64 lastBlock, uint64 lastFinalizedEpoch, uint64 lastFinalizedBlock, uint64 timestamp, uint64 firstEnterEpoch, uint64 lastEnterEpoch, uint64 nextBlockToRebase, bool rebased)

func (*RootChainStorageCaller) IsRootChain 

func (_RootChainStorage *RootChainStorageCaller) IsRootChain(opts *bind.CallOpts) (bool, error)

IsRootChain is a free data retrieval call binding the contract method 0x420bb4b8.

Solidity: function isRootChain() constant returns(bool)

func (*RootChainStorageCaller) LastAppliedBlockNumber 

func (_RootChainStorage *RootChainStorageCaller) LastAppliedBlockNumber(opts *bind.CallOpts) (*big.Int, error)

LastAppliedBlockNumber is a free data retrieval call binding the contract method 0xfb788a27.

Solidity: function lastAppliedBlockNumber() constant returns(uint256)

func (*RootChainStorageCaller) LastAppliedEpochNumber 

func (_RootChainStorage *RootChainStorageCaller) LastAppliedEpochNumber(opts *bind.CallOpts) (*big.Int, error)

LastAppliedEpochNumber is a free data retrieval call binding the contract method 0xc8ad329f.

Solidity: function lastAppliedEpochNumber() constant returns(uint256)

func (*RootChainStorageCaller) LastAppliedForkNumber 

func (_RootChainStorage *RootChainStorageCaller) LastAppliedForkNumber(opts *bind.CallOpts) (*big.Int, error)

LastAppliedForkNumber is a free data retrieval call binding the contract method 0x164bc2ae.

Solidity: function lastAppliedForkNumber() constant returns(uint256)

func (*RootChainStorageCaller) LastNonEmptyRequestEpoch 

func (_RootChainStorage *RootChainStorageCaller) LastNonEmptyRequestEpoch(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error)

LastNonEmptyRequestEpoch is a free data retrieval call binding the contract method 0xb6715647.

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

func (*RootChainStorageCaller) NRELength 

func (_RootChainStorage *RootChainStorageCaller) NRELength(opts *bind.CallOpts) (*big.Int, error)

NRELength is a free data retrieval call binding the contract method 0xab96da2d.

Solidity: function NRELength() constant returns(uint256)

func (*RootChainStorageCaller) NULLADDRESS 

func (_RootChainStorage *RootChainStorageCaller) NULLADDRESS(opts *bind.CallOpts) (common.Address, error)

NULLADDRESS is a free data retrieval call binding the contract method 0xde0ce17d.

Solidity: function NULL_ADDRESS() constant returns(address)

func (*RootChainStorageCaller) NumEnterForORB 

func (_RootChainStorage *RootChainStorageCaller) NumEnterForORB(opts *bind.CallOpts) (*big.Int, error)

NumEnterForORB is a free data retrieval call binding the contract method 0x23691566.

Solidity: function numEnterForORB() constant returns(uint256)

func (*RootChainStorageCaller) ORBs 

func (_RootChainStorage *RootChainStorageCaller) ORBs(opts *bind.CallOpts, arg0 *big.Int) (struct {
	Submitted    bool
	NumEnter     uint64
	EpochNumber  uint64
	RequestStart uint64
	RequestEnd   uint64
	Trie         common.Address
}, error)

ORBs is a free data retrieval call binding the contract method 0xea7f22a8.

Solidity: function ORBs(uint256 ) constant returns(bool submitted, uint64 numEnter, uint64 epochNumber, uint64 requestStart, uint64 requestEnd, address trie)

func (*RootChainStorageCaller) Operator 

func (_RootChainStorage *RootChainStorageCaller) Operator(opts *bind.CallOpts) (common.Address, error)

Operator is a free data retrieval call binding the contract method 0x570ca735.

Solidity: function operator() constant returns(address)

func (*RootChainStorageCaller) PREPARETIMEOUT 

func (_RootChainStorage *RootChainStorageCaller) PREPARETIMEOUT(opts *bind.CallOpts) (*big.Int, error)

PREPARETIMEOUT is a free data retrieval call binding the contract method 0xc2bc88fa.

Solidity: function PREPARE_TIMEOUT() constant returns(uint256)

func (*RootChainStorageCaller) REQUESTGAS 

func (_RootChainStorage *RootChainStorageCaller) REQUESTGAS(opts *bind.CallOpts) (*big.Int, error)

REQUESTGAS is a free data retrieval call binding the contract method 0x8eb288ca.

Solidity: function REQUEST_GAS() constant returns(uint256)

func (*RootChainStorageCaller) RequestableContracts 

func (_RootChainStorage *RootChainStorageCaller) RequestableContracts(opts *bind.CallOpts, arg0 common.Address) (common.Address, error)

RequestableContracts is a free data retrieval call binding the contract method 0xda0185f8.

Solidity: function requestableContracts(address ) constant returns(address)

func (*RootChainStorageCaller) SeigManager 

func (_RootChainStorage *RootChainStorageCaller) SeigManager(opts *bind.CallOpts) (common.Address, error)

SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.

Solidity: function seigManager() constant returns(address)

func (*RootChainStorageCaller) SubmitHandler 

func (_RootChainStorage *RootChainStorageCaller) SubmitHandler(opts *bind.CallOpts) (common.Address, error)

SubmitHandler is a free data retrieval call binding the contract method 0xe259faf7.

Solidity: function submitHandler() constant returns(address)

func (*RootChainStorageCaller) URBs 

func (_RootChainStorage *RootChainStorageCaller) URBs(opts *bind.CallOpts, arg0 *big.Int) (struct {
	Submitted    bool
	NumEnter     uint64
	EpochNumber  uint64
	RequestStart uint64
	RequestEnd   uint64
	Trie         common.Address
}, error)

URBs is a free data retrieval call binding the contract method 0xc0e86064.

Solidity: function URBs(uint256 ) constant returns(bool submitted, uint64 numEnter, uint64 epochNumber, uint64 requestStart, uint64 requestEnd, address trie)

type RootChainStorageCallerRaw 

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

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

func (*RootChainStorageCallerRaw) Call 

func (_RootChainStorage *RootChainStorageCallerRaw) 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 RootChainStorageCallerSession 

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

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

func (*RootChainStorageCallerSession) COSTERO 

func (_RootChainStorage *RootChainStorageCallerSession) COSTERO() (*big.Int, error)

COSTERO is a free data retrieval call binding the contract method 0xd691acd8.

Solidity: function COST_ERO() constant returns(uint256)

func (*RootChainStorageCallerSession) COSTERU 

func (_RootChainStorage *RootChainStorageCallerSession) COSTERU() (*big.Int, error)

COSTERU is a free data retrieval call binding the contract method 0x8b5172d0.

Solidity: function COST_ERU() constant returns(uint256)

func (*RootChainStorageCallerSession) COSTNRB 

func (_RootChainStorage *RootChainStorageCallerSession) COSTNRB() (*big.Int, error)

COSTNRB is a free data retrieval call binding the contract method 0x94be3aa5.

Solidity: function COST_NRB() constant returns(uint256)

func (*RootChainStorageCallerSession) COSTORB 

func (_RootChainStorage *RootChainStorageCallerSession) COSTORB() (*big.Int, error)

COSTORB is a free data retrieval call binding the contract method 0xb2ae9ba8.

Solidity: function COST_ORB() constant returns(uint256)

func (*RootChainStorageCallerSession) COSTURB 

func (_RootChainStorage *RootChainStorageCallerSession) COSTURB() (*big.Int, error)

COSTURB is a free data retrieval call binding the contract method 0x192adc5b.

Solidity: function COST_URB() constant returns(uint256)

func (*RootChainStorageCallerSession) COSTURBPREPARE 

func (_RootChainStorage *RootChainStorageCallerSession) COSTURBPREPARE() (*big.Int, error)

COSTURBPREPARE is a free data retrieval call binding the contract method 0x033cfbed.

Solidity: function COST_URB_PREPARE() constant returns(uint256)

func (*RootChainStorageCallerSession) CPCOMPUTATION 

func (_RootChainStorage *RootChainStorageCallerSession) CPCOMPUTATION() (*big.Int, error)

CPCOMPUTATION is a free data retrieval call binding the contract method 0x08c4fff0.

Solidity: function CP_COMPUTATION() constant returns(uint256)

func (*RootChainStorageCallerSession) CPEXIT 

func (_RootChainStorage *RootChainStorageCallerSession) CPEXIT() (*big.Int, error)

CPEXIT is a free data retrieval call binding the contract method 0x8155717d.

Solidity: function CP_EXIT() constant returns(uint256)

func (*RootChainStorageCallerSession) CPWITHHOLDING 

func (_RootChainStorage *RootChainStorageCallerSession) CPWITHHOLDING() (*big.Int, error)

CPWITHHOLDING is a free data retrieval call binding the contract method 0xb17fa6e9.

Solidity: function CP_WITHHOLDING() constant returns(uint256)

func (*RootChainStorageCallerSession) CurrentFork 

func (_RootChainStorage *RootChainStorageCallerSession) CurrentFork() (*big.Int, error)

CurrentFork is a free data retrieval call binding the contract method 0x183d2d1c.

Solidity: function currentFork() constant returns(uint256)

func (*RootChainStorageCallerSession) Development 

func (_RootChainStorage *RootChainStorageCallerSession) Development() (bool, error)

Development is a free data retrieval call binding the contract method 0x7b929c27.

Solidity: function development() constant returns(bool)

func (*RootChainStorageCallerSession) EROIdToFinalize 

func (_RootChainStorage *RootChainStorageCallerSession) EROIdToFinalize() (*big.Int, error)

EROIdToFinalize is a free data retrieval call binding the contract method 0x2dc6bb7b.

Solidity: function EROIdToFinalize() constant returns(uint256)

func (*RootChainStorageCallerSession) EROs 

func (_RootChainStorage *RootChainStorageCallerSession) EROs(arg0 *big.Int) (struct {
	Timestamp  uint64
	IsExit     bool
	IsTransfer bool
	Finalized  bool
	Challenged bool
	Value      *big.Int
	Requestor  common.Address
	To         common.Address
	TrieKey    [32]byte
	Hash       [32]byte
	TrieValue  []byte
}, error)

EROs is a free data retrieval call binding the contract method 0xb443f3cc.

Solidity: function EROs(uint256 ) constant returns(uint64 timestamp, bool isExit, bool isTransfer, bool finalized, bool challenged, uint128 value, address requestor, address to, bytes32 trieKey, bytes32 hash, bytes trieValue)

func (*RootChainStorageCallerSession) ERUIdToFinalize 

func (_RootChainStorage *RootChainStorageCallerSession) ERUIdToFinalize() (*big.Int, error)

ERUIdToFinalize is a free data retrieval call binding the contract method 0xc54626cc.

Solidity: function ERUIdToFinalize() constant returns(uint256)

func (*RootChainStorageCallerSession) ERUs 

func (_RootChainStorage *RootChainStorageCallerSession) ERUs(arg0 *big.Int) (struct {
	Timestamp  uint64
	IsExit     bool
	IsTransfer bool
	Finalized  bool
	Challenged bool
	Value      *big.Int
	Requestor  common.Address
	To         common.Address
	TrieKey    [32]byte
	Hash       [32]byte
	TrieValue  []byte
}, error)

ERUs is a free data retrieval call binding the contract method 0xf4f31de4.

Solidity: function ERUs(uint256 ) constant returns(uint64 timestamp, bool isExit, bool isTransfer, bool finalized, bool challenged, uint128 value, address requestor, address to, bytes32 trieKey, bytes32 hash, bytes trieValue)

func (*RootChainStorageCallerSession) EpochHandler 

func (_RootChainStorage *RootChainStorageCallerSession) EpochHandler() (common.Address, error)

EpochHandler is a free data retrieval call binding the contract method 0xe7b88b80.

Solidity: function epochHandler() constant returns(address)

func (*RootChainStorageCallerSession) EtherToken 

func (_RootChainStorage *RootChainStorageCallerSession) EtherToken() (common.Address, error)

EtherToken is a free data retrieval call binding the contract method 0xb8066bcb.

Solidity: function etherToken() constant returns(address)

func (*RootChainStorageCallerSession) FirstFilledORENumber 

func (_RootChainStorage *RootChainStorageCallerSession) FirstFilledORENumber(arg0 *big.Int) (*big.Int, error)

FirstFilledORENumber is a free data retrieval call binding the contract method 0x72ecb9a8.

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

func (*RootChainStorageCallerSession) FirstNonEmptyRequestEpoch 

func (_RootChainStorage *RootChainStorageCallerSession) FirstNonEmptyRequestEpoch(arg0 *big.Int) (*big.Int, error)

FirstNonEmptyRequestEpoch is a free data retrieval call binding the contract method 0xca6f6380.

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

func (*RootChainStorageCallerSession) Forks 

func (_RootChainStorage *RootChainStorageCallerSession) Forks(arg0 *big.Int) (struct {
	ForkedBlock        uint64
	FirstEpoch         uint64
	LastEpoch          uint64
	FirstBlock         uint64
	LastBlock          uint64
	LastFinalizedEpoch uint64
	LastFinalizedBlock uint64
	Timestamp          uint64
	FirstEnterEpoch    uint64
	LastEnterEpoch     uint64
	NextBlockToRebase  uint64
	Rebased            bool
}, error)

Forks is a free data retrieval call binding the contract method 0x4ba3a126.

Solidity: function forks(uint256 ) constant returns(uint64 forkedBlock, uint64 firstEpoch, uint64 lastEpoch, uint64 firstBlock, uint64 lastBlock, uint64 lastFinalizedEpoch, uint64 lastFinalizedBlock, uint64 timestamp, uint64 firstEnterEpoch, uint64 lastEnterEpoch, uint64 nextBlockToRebase, bool rebased)

func (*RootChainStorageCallerSession) IsRootChain 

func (_RootChainStorage *RootChainStorageCallerSession) IsRootChain() (bool, error)

IsRootChain is a free data retrieval call binding the contract method 0x420bb4b8.

Solidity: function isRootChain() constant returns(bool)

func (*RootChainStorageCallerSession) LastAppliedBlockNumber 

func (_RootChainStorage *RootChainStorageCallerSession) LastAppliedBlockNumber() (*big.Int, error)

LastAppliedBlockNumber is a free data retrieval call binding the contract method 0xfb788a27.

Solidity: function lastAppliedBlockNumber() constant returns(uint256)

func (*RootChainStorageCallerSession) LastAppliedEpochNumber 

func (_RootChainStorage *RootChainStorageCallerSession) LastAppliedEpochNumber() (*big.Int, error)

LastAppliedEpochNumber is a free data retrieval call binding the contract method 0xc8ad329f.

Solidity: function lastAppliedEpochNumber() constant returns(uint256)

func (*RootChainStorageCallerSession) LastAppliedForkNumber 

func (_RootChainStorage *RootChainStorageCallerSession) LastAppliedForkNumber() (*big.Int, error)

LastAppliedForkNumber is a free data retrieval call binding the contract method 0x164bc2ae.

Solidity: function lastAppliedForkNumber() constant returns(uint256)

func (*RootChainStorageCallerSession) LastNonEmptyRequestEpoch 

func (_RootChainStorage *RootChainStorageCallerSession) LastNonEmptyRequestEpoch(arg0 *big.Int) (*big.Int, error)

LastNonEmptyRequestEpoch is a free data retrieval call binding the contract method 0xb6715647.

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

func (*RootChainStorageCallerSession) NRELength 

func (_RootChainStorage *RootChainStorageCallerSession) NRELength() (*big.Int, error)

NRELength is a free data retrieval call binding the contract method 0xab96da2d.

Solidity: function NRELength() constant returns(uint256)

func (*RootChainStorageCallerSession) NULLADDRESS 

func (_RootChainStorage *RootChainStorageCallerSession) NULLADDRESS() (common.Address, error)

NULLADDRESS is a free data retrieval call binding the contract method 0xde0ce17d.

Solidity: function NULL_ADDRESS() constant returns(address)

func (*RootChainStorageCallerSession) NumEnterForORB 

func (_RootChainStorage *RootChainStorageCallerSession) NumEnterForORB() (*big.Int, error)

NumEnterForORB is a free data retrieval call binding the contract method 0x23691566.

Solidity: function numEnterForORB() constant returns(uint256)

func (*RootChainStorageCallerSession) ORBs 

func (_RootChainStorage *RootChainStorageCallerSession) ORBs(arg0 *big.Int) (struct {
	Submitted    bool
	NumEnter     uint64
	EpochNumber  uint64
	RequestStart uint64
	RequestEnd   uint64
	Trie         common.Address
}, error)

ORBs is a free data retrieval call binding the contract method 0xea7f22a8.

Solidity: function ORBs(uint256 ) constant returns(bool submitted, uint64 numEnter, uint64 epochNumber, uint64 requestStart, uint64 requestEnd, address trie)

func (*RootChainStorageCallerSession) Operator 

func (_RootChainStorage *RootChainStorageCallerSession) Operator() (common.Address, error)

Operator is a free data retrieval call binding the contract method 0x570ca735.

Solidity: function operator() constant returns(address)

func (*RootChainStorageCallerSession) PREPARETIMEOUT 

func (_RootChainStorage *RootChainStorageCallerSession) PREPARETIMEOUT() (*big.Int, error)

PREPARETIMEOUT is a free data retrieval call binding the contract method 0xc2bc88fa.

Solidity: function PREPARE_TIMEOUT() constant returns(uint256)

func (*RootChainStorageCallerSession) REQUESTGAS 

func (_RootChainStorage *RootChainStorageCallerSession) REQUESTGAS() (*big.Int, error)

REQUESTGAS is a free data retrieval call binding the contract method 0x8eb288ca.

Solidity: function REQUEST_GAS() constant returns(uint256)

func (*RootChainStorageCallerSession) RequestableContracts 

func (_RootChainStorage *RootChainStorageCallerSession) RequestableContracts(arg0 common.Address) (common.Address, error)

RequestableContracts is a free data retrieval call binding the contract method 0xda0185f8.

Solidity: function requestableContracts(address ) constant returns(address)

func (*RootChainStorageCallerSession) SeigManager 

func (_RootChainStorage *RootChainStorageCallerSession) SeigManager() (common.Address, error)

SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.

Solidity: function seigManager() constant returns(address)

func (*RootChainStorageCallerSession) SubmitHandler 

func (_RootChainStorage *RootChainStorageCallerSession) SubmitHandler() (common.Address, error)

SubmitHandler is a free data retrieval call binding the contract method 0xe259faf7.

Solidity: function submitHandler() constant returns(address)

func (*RootChainStorageCallerSession) URBs 

func (_RootChainStorage *RootChainStorageCallerSession) URBs(arg0 *big.Int) (struct {
	Submitted    bool
	NumEnter     uint64
	EpochNumber  uint64
	RequestStart uint64
	RequestEnd   uint64
	Trie         common.Address
}, error)

URBs is a free data retrieval call binding the contract method 0xc0e86064.

Solidity: function URBs(uint256 ) constant returns(bool submitted, uint64 numEnter, uint64 epochNumber, uint64 requestStart, uint64 requestEnd, address trie)

type RootChainStorageFilterer 

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

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

func NewRootChainStorageFilterer 

func NewRootChainStorageFilterer(address common.Address, filterer bind.ContractFilterer) (*RootChainStorageFilterer, error)

NewRootChainStorageFilterer creates a new log filterer instance of RootChainStorage, bound to a specific deployed contract.

type RootChainStorageRaw 

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

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

func (*RootChainStorageRaw) Call 

func (_RootChainStorage *RootChainStorageRaw) 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 (*RootChainStorageRaw) Transact 

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

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

func (*RootChainStorageRaw) Transfer 

func (_RootChainStorage *RootChainStorageRaw) 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 RootChainStorageSession 

type RootChainStorageSession struct {
	Contract     *RootChainStorage // 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
}

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

func (*RootChainStorageSession) COSTERO 

func (_RootChainStorage *RootChainStorageSession) COSTERO() (*big.Int, error)

COSTERO is a free data retrieval call binding the contract method 0xd691acd8.

Solidity: function COST_ERO() constant returns(uint256)

func (*RootChainStorageSession) COSTERU 

func (_RootChainStorage *RootChainStorageSession) COSTERU() (*big.Int, error)

COSTERU is a free data retrieval call binding the contract method 0x8b5172d0.

Solidity: function COST_ERU() constant returns(uint256)

func (*RootChainStorageSession) COSTNRB 

func (_RootChainStorage *RootChainStorageSession) COSTNRB() (*big.Int, error)

COSTNRB is a free data retrieval call binding the contract method 0x94be3aa5.

Solidity: function COST_NRB() constant returns(uint256)

func (*RootChainStorageSession) COSTORB 

func (_RootChainStorage *RootChainStorageSession) COSTORB() (*big.Int, error)

COSTORB is a free data retrieval call binding the contract method 0xb2ae9ba8.

Solidity: function COST_ORB() constant returns(uint256)

func (*RootChainStorageSession) COSTURB 

func (_RootChainStorage *RootChainStorageSession) COSTURB() (*big.Int, error)

COSTURB is a free data retrieval call binding the contract method 0x192adc5b.

Solidity: function COST_URB() constant returns(uint256)

func (*RootChainStorageSession) COSTURBPREPARE 

func (_RootChainStorage *RootChainStorageSession) COSTURBPREPARE() (*big.Int, error)

COSTURBPREPARE is a free data retrieval call binding the contract method 0x033cfbed.

Solidity: function COST_URB_PREPARE() constant returns(uint256)

func (*RootChainStorageSession) CPCOMPUTATION 

func (_RootChainStorage *RootChainStorageSession) CPCOMPUTATION() (*big.Int, error)

CPCOMPUTATION is a free data retrieval call binding the contract method 0x08c4fff0.

Solidity: function CP_COMPUTATION() constant returns(uint256)

func (*RootChainStorageSession) CPEXIT 

func (_RootChainStorage *RootChainStorageSession) CPEXIT() (*big.Int, error)

CPEXIT is a free data retrieval call binding the contract method 0x8155717d.

Solidity: function CP_EXIT() constant returns(uint256)

func (*RootChainStorageSession) CPWITHHOLDING 

func (_RootChainStorage *RootChainStorageSession) CPWITHHOLDING() (*big.Int, error)

CPWITHHOLDING is a free data retrieval call binding the contract method 0xb17fa6e9.

Solidity: function CP_WITHHOLDING() constant returns(uint256)

func (*RootChainStorageSession) CurrentFork 

func (_RootChainStorage *RootChainStorageSession) CurrentFork() (*big.Int, error)

CurrentFork is a free data retrieval call binding the contract method 0x183d2d1c.

Solidity: function currentFork() constant returns(uint256)

func (*RootChainStorageSession) Development 

func (_RootChainStorage *RootChainStorageSession) Development() (bool, error)

Development is a free data retrieval call binding the contract method 0x7b929c27.

Solidity: function development() constant returns(bool)

func (*RootChainStorageSession) EROIdToFinalize 

func (_RootChainStorage *RootChainStorageSession) EROIdToFinalize() (*big.Int, error)

EROIdToFinalize is a free data retrieval call binding the contract method 0x2dc6bb7b.

Solidity: function EROIdToFinalize() constant returns(uint256)

func (*RootChainStorageSession) EROs 

func (_RootChainStorage *RootChainStorageSession) EROs(arg0 *big.Int) (struct {
	Timestamp  uint64
	IsExit     bool
	IsTransfer bool
	Finalized  bool
	Challenged bool
	Value      *big.Int
	Requestor  common.Address
	To         common.Address
	TrieKey    [32]byte
	Hash       [32]byte
	TrieValue  []byte
}, error)

EROs is a free data retrieval call binding the contract method 0xb443f3cc.

Solidity: function EROs(uint256 ) constant returns(uint64 timestamp, bool isExit, bool isTransfer, bool finalized, bool challenged, uint128 value, address requestor, address to, bytes32 trieKey, bytes32 hash, bytes trieValue)

func (*RootChainStorageSession) ERUIdToFinalize 

func (_RootChainStorage *RootChainStorageSession) ERUIdToFinalize() (*big.Int, error)

ERUIdToFinalize is a free data retrieval call binding the contract method 0xc54626cc.

Solidity: function ERUIdToFinalize() constant returns(uint256)

func (*RootChainStorageSession) ERUs 

func (_RootChainStorage *RootChainStorageSession) ERUs(arg0 *big.Int) (struct {
	Timestamp  uint64
	IsExit     bool
	IsTransfer bool
	Finalized  bool
	Challenged bool
	Value      *big.Int
	Requestor  common.Address
	To         common.Address
	TrieKey    [32]byte
	Hash       [32]byte
	TrieValue  []byte
}, error)

ERUs is a free data retrieval call binding the contract method 0xf4f31de4.

Solidity: function ERUs(uint256 ) constant returns(uint64 timestamp, bool isExit, bool isTransfer, bool finalized, bool challenged, uint128 value, address requestor, address to, bytes32 trieKey, bytes32 hash, bytes trieValue)

func (*RootChainStorageSession) EpochHandler 

func (_RootChainStorage *RootChainStorageSession) EpochHandler() (common.Address, error)

EpochHandler is a free data retrieval call binding the contract method 0xe7b88b80.

Solidity: function epochHandler() constant returns(address)

func (*RootChainStorageSession) EtherToken 

func (_RootChainStorage *RootChainStorageSession) EtherToken() (common.Address, error)

EtherToken is a free data retrieval call binding the contract method 0xb8066bcb.

Solidity: function etherToken() constant returns(address)

func (*RootChainStorageSession) FirstFilledORENumber 

func (_RootChainStorage *RootChainStorageSession) FirstFilledORENumber(arg0 *big.Int) (*big.Int, error)

FirstFilledORENumber is a free data retrieval call binding the contract method 0x72ecb9a8.

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

func (*RootChainStorageSession) FirstNonEmptyRequestEpoch 

func (_RootChainStorage *RootChainStorageSession) FirstNonEmptyRequestEpoch(arg0 *big.Int) (*big.Int, error)

FirstNonEmptyRequestEpoch is a free data retrieval call binding the contract method 0xca6f6380.

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

func (*RootChainStorageSession) Forks 

func (_RootChainStorage *RootChainStorageSession) Forks(arg0 *big.Int) (struct {
	ForkedBlock        uint64
	FirstEpoch         uint64
	LastEpoch          uint64
	FirstBlock         uint64
	LastBlock          uint64
	LastFinalizedEpoch uint64
	LastFinalizedBlock uint64
	Timestamp          uint64
	FirstEnterEpoch    uint64
	LastEnterEpoch     uint64
	NextBlockToRebase  uint64
	Rebased            bool
}, error)

Forks is a free data retrieval call binding the contract method 0x4ba3a126.

Solidity: function forks(uint256 ) constant returns(uint64 forkedBlock, uint64 firstEpoch, uint64 lastEpoch, uint64 firstBlock, uint64 lastBlock, uint64 lastFinalizedEpoch, uint64 lastFinalizedBlock, uint64 timestamp, uint64 firstEnterEpoch, uint64 lastEnterEpoch, uint64 nextBlockToRebase, bool rebased)

func (*RootChainStorageSession) IsRootChain 

func (_RootChainStorage *RootChainStorageSession) IsRootChain() (bool, error)

IsRootChain is a free data retrieval call binding the contract method 0x420bb4b8.

Solidity: function isRootChain() constant returns(bool)

func (*RootChainStorageSession) LastAppliedBlockNumber 

func (_RootChainStorage *RootChainStorageSession) LastAppliedBlockNumber() (*big.Int, error)

LastAppliedBlockNumber is a free data retrieval call binding the contract method 0xfb788a27.

Solidity: function lastAppliedBlockNumber() constant returns(uint256)

func (*RootChainStorageSession) LastAppliedEpochNumber 

func (_RootChainStorage *RootChainStorageSession) LastAppliedEpochNumber() (*big.Int, error)

LastAppliedEpochNumber is a free data retrieval call binding the contract method 0xc8ad329f.

Solidity: function lastAppliedEpochNumber() constant returns(uint256)

func (*RootChainStorageSession) LastAppliedForkNumber 

func (_RootChainStorage *RootChainStorageSession) LastAppliedForkNumber() (*big.Int, error)

LastAppliedForkNumber is a free data retrieval call binding the contract method 0x164bc2ae.

Solidity: function lastAppliedForkNumber() constant returns(uint256)

func (*RootChainStorageSession) LastNonEmptyRequestEpoch 

func (_RootChainStorage *RootChainStorageSession) LastNonEmptyRequestEpoch(arg0 *big.Int) (*big.Int, error)

LastNonEmptyRequestEpoch is a free data retrieval call binding the contract method 0xb6715647.

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

func (*RootChainStorageSession) NRELength 

func (_RootChainStorage *RootChainStorageSession) NRELength() (*big.Int, error)

NRELength is a free data retrieval call binding the contract method 0xab96da2d.

Solidity: function NRELength() constant returns(uint256)

func (*RootChainStorageSession) NULLADDRESS 

func (_RootChainStorage *RootChainStorageSession) NULLADDRESS() (common.Address, error)

NULLADDRESS is a free data retrieval call binding the contract method 0xde0ce17d.

Solidity: function NULL_ADDRESS() constant returns(address)

func (*RootChainStorageSession) NumEnterForORB 

func (_RootChainStorage *RootChainStorageSession) NumEnterForORB() (*big.Int, error)

NumEnterForORB is a free data retrieval call binding the contract method 0x23691566.

Solidity: function numEnterForORB() constant returns(uint256)

func (*RootChainStorageSession) ORBs 

func (_RootChainStorage *RootChainStorageSession) ORBs(arg0 *big.Int) (struct {
	Submitted    bool
	NumEnter     uint64
	EpochNumber  uint64
	RequestStart uint64
	RequestEnd   uint64
	Trie         common.Address
}, error)

ORBs is a free data retrieval call binding the contract method 0xea7f22a8.

Solidity: function ORBs(uint256 ) constant returns(bool submitted, uint64 numEnter, uint64 epochNumber, uint64 requestStart, uint64 requestEnd, address trie)

func (*RootChainStorageSession) Operator 

func (_RootChainStorage *RootChainStorageSession) Operator() (common.Address, error)

Operator is a free data retrieval call binding the contract method 0x570ca735.

Solidity: function operator() constant returns(address)

func (*RootChainStorageSession) PREPARETIMEOUT 

func (_RootChainStorage *RootChainStorageSession) PREPARETIMEOUT() (*big.Int, error)

PREPARETIMEOUT is a free data retrieval call binding the contract method 0xc2bc88fa.

Solidity: function PREPARE_TIMEOUT() constant returns(uint256)

func (*RootChainStorageSession) REQUESTGAS 

func (_RootChainStorage *RootChainStorageSession) REQUESTGAS() (*big.Int, error)

REQUESTGAS is a free data retrieval call binding the contract method 0x8eb288ca.

Solidity: function REQUEST_GAS() constant returns(uint256)

func (*RootChainStorageSession) RequestableContracts 

func (_RootChainStorage *RootChainStorageSession) RequestableContracts(arg0 common.Address) (common.Address, error)

RequestableContracts is a free data retrieval call binding the contract method 0xda0185f8.

Solidity: function requestableContracts(address ) constant returns(address)

func (*RootChainStorageSession) SeigManager 

func (_RootChainStorage *RootChainStorageSession) SeigManager() (common.Address, error)

SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.

Solidity: function seigManager() constant returns(address)

func (*RootChainStorageSession) SubmitHandler 

func (_RootChainStorage *RootChainStorageSession) SubmitHandler() (common.Address, error)

SubmitHandler is a free data retrieval call binding the contract method 0xe259faf7.

Solidity: function submitHandler() constant returns(address)

func (*RootChainStorageSession) URBs 

func (_RootChainStorage *RootChainStorageSession) URBs(arg0 *big.Int) (struct {
	Submitted    bool
	NumEnter     uint64
	EpochNumber  uint64
	RequestStart uint64
	RequestEnd   uint64
	Trie         common.Address
}, error)

URBs is a free data retrieval call binding the contract method 0xc0e86064.

Solidity: function URBs(uint256 ) constant returns(bool submitted, uint64 numEnter, uint64 epochNumber, uint64 requestStart, uint64 requestEnd, address trie)

type RootChainStorageTransactor 

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

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

func NewRootChainStorageTransactor 

func NewRootChainStorageTransactor(address common.Address, transactor bind.ContractTransactor) (*RootChainStorageTransactor, error)

NewRootChainStorageTransactor creates a new write-only instance of RootChainStorage, bound to a specific deployed contract.

type RootChainStorageTransactorRaw 

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

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

func (*RootChainStorageTransactorRaw) Transact 

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

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

func (*RootChainStorageTransactorRaw) Transfer 

func (_RootChainStorage *RootChainStorageTransactorRaw) 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 RootChainStorageTransactorSession 

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

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

type SafeMath 

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

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

func DeploySafeMath 

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

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

func NewSafeMath 

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

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

type SafeMathCaller 

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

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

func NewSafeMathCaller 

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

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

type SafeMathCallerRaw 

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

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

func (*SafeMathCallerRaw) Call 

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

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

type SafeMathCallerSession 

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

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

type SafeMathFilterer 

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

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

func NewSafeMathFilterer 

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

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

type SafeMathRaw 

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

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

func (*SafeMathRaw) Call 

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

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

func (*SafeMathRaw) Transact 

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

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

func (*SafeMathRaw) Transfer 

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

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

type SafeMathSession 

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

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

type SafeMathTransactor 

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

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

func NewSafeMathTransactor 

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

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

type SafeMathTransactorRaw 

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

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

func (*SafeMathTransactorRaw) Transact 

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

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

func (*SafeMathTransactorRaw) Transfer 

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

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

type SafeMathTransactorSession 

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

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

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