rootchain

package
v0.0.0-rc7.7 Latest Latest
Warning

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

 Go to latest Published: May 13, 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 MapperRoleABI = "" /* 1079-byte string literal not displayed */

MapperRoleABI 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 RolesABI = "[]"

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

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

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

View Source 
const RootChainBaseABI = "" /* 18027-byte string literal not displayed */

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

View Source 
const SubmitterRoleABI = "" /* 1094-byte string literal not displayed */

SubmitterRoleABI 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 MapperRoleFuncSigs = map[string]string{
	"80e3e81d": "addMapper(address)",
	"c0c49c2a": "isMapper(address)",
	"3565fb0d": "renounceMapper()",
}

MapperRoleFuncSigs 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 RolesBin = "" /* 242-byte string literal not displayed */

RolesBin is the compiled bytecode used for deploying new contracts.

View Source 
var RootChainBaseBin = "" /* 4752-byte string literal not displayed */

RootChainBaseBin is the compiled bytecode used for deploying new contracts.

View Source 
var RootChainBaseFuncSigs = 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()",
}

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

View Source 
var RootChainBin = "" /* 48938-byte string literal not displayed */

RootChainBin is the compiled bytecode used for deploying new contracts.

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

RootChainEventBin is the compiled bytecode used for deploying new contracts.

View Source 
var RootChainFuncSigs = 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)",
	"93521222": "MAX_REQUESTS()",
	"ab96da2d": "NRELength()",
	"de0ce17d": "NULL_ADDRESS()",
	"ea7f22a8": "ORBs(uint256)",
	"c2bc88fa": "PREPARE_TIMEOUT()",
	"8eb288ca": "REQUEST_GAS()",
	"c0e86064": "URBs(uint256)",
	"80e3e81d": "addMapper(address)",
	"072900f9": "addSubmitter(address)",
	"404f7d66": "challengeExit(uint256,uint256,uint256,bytes,bytes)",
	"6299fb24": "challengeNullAddress(uint256,bytes,bytes,uint256,bytes32[])",
	"06394c9b": "changeOperator(address)",
	"183d2d1c": "currentFork()",
	"7b929c27": "development()",
	"e7b88b80": "epochHandler()",
	"b8066bcb": "etherToken()",
	"75395a58": "finalizeBlock()",
	"99bd3600": "finalizeRequest()",
	"54768571": "finalizeRequests(uint256)",
	"72ecb9a8": "firstFilledORENumber(uint256)",
	"ca6f6380": "firstNonEmptyRequestEpoch(uint256)",
	"ce8a2bc2": "forked(uint256)",
	"4ba3a126": "forks(uint256)",
	"4a44bdb8": "getBlock(uint256,uint256)",
	"5b884682": "getBlockFinalizedAt(uint256,uint256)",
	"d1723a96": "getEROBytes(uint256)",
	"2b25a38b": "getEpoch(uint256,uint256)",
	"398bac63": "getLastEpoch()",
	"d636857e": "getLastFinalizedBlock(uint256)",
	"019dc099": "getLastFinalizedEpoch(uint256)",
	"b540adba": "getNumEROs()",
	"ea0c73f6": "getNumORBs()",
	"f28a7afa": "getRequestFinalized(uint256,bool)",
	"c0c49c2a": "isMapper(address)",
	"420bb4b8": "isRootChain()",
	"a926fdbc": "isSubmitter(address)",
	"fb788a27": "lastAppliedBlockNumber()",
	"c8ad329f": "lastAppliedEpochNumber()",
	"164bc2ae": "lastAppliedForkNumber()",
	"1ec2042b": "lastBlock(uint256)",
	"11e4c914": "lastEpoch(uint256)",
	"b6715647": "lastNonEmptyRequestEpoch(uint256)",
	"78fe705f": "makeERU(address,bytes32,bytes)",
	"cb5d742f": "mapRequestableContractByOperator(address,address)",
	"23691566": "numEnterForORB()",
	"570ca735": "operator()",
	"e6925d08": "prepareToSubmitURB()",
	"3565fb0d": "renounceMapper()",
	"5e0ca71b": "renounceSubmitter()",
	"da0185f8": "requestableContracts(address)",
	"6fb7f558": "seigManager()",
	"7657f20a": "setSeigManager(address)",
	"2aa196c8": "startEnter(address,bytes32,bytes)",
	"e7f96505": "startExit(address,bytes32,bytes)",
	"e259faf7": "submitHandler()",
	"0eaf45a8": "submitNRE(uint256,uint256,bytes32,bytes32,bytes32)",
	"a820c067": "submitORB(uint256,bytes32,bytes32,bytes32)",
	"6f3e4b90": "submitURB(uint256,bytes32,bytes32,bytes32)",
}

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

View Source 
var RootChainStorageBin = "" /* 4752-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.

View Source 
var SubmitterRoleFuncSigs = map[string]string{
	"072900f9": "addSubmitter(address)",
	"a926fdbc": "isSubmitter(address)",
	"5e0ca71b": "renounceSubmitter()",
}

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

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 DataEpoch 

type DataEpoch struct {
	StartBlockNumber uint64
	EndBlockNumber   uint64
	Timestamp        uint64
	IsEmpty          bool
	Initialized      bool
	IsRequest        bool
	UserActivated    bool
	Rebase           bool
	RE               DataRequestEpochMeta
	NRE              DataNonRequestEpochMeta
}

DataEpoch is an auto generated low-level Go binding around an user-defined struct.

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 DataNonRequestEpochMeta 

type DataNonRequestEpochMeta struct {
	EpochStateRoot        [32]byte
	EpochTransactionsRoot [32]byte
	EpochReceiptsRoot     [32]byte
	SubmittedAt           uint64
	FinalizedAt           uint64
	Finalized             bool
	Challenging           bool
	Challenged            bool
}

DataNonRequestEpochMeta is an auto generated low-level Go binding around an user-defined struct.

type DataPlasmaBlock 

type DataPlasmaBlock struct {
	EpochNumber      uint64
	RequestBlockId   uint64
	Timestamp        uint64
	FinalizedAt      uint64
	ReferenceBlock   uint64
	StatesRoot       [32]byte
	TransactionsRoot [32]byte
	ReceiptsRoot     [32]byte
	IsRequest        bool
	UserActivated    bool
	Challenged       bool
	Challenging      bool
	Finalized        bool
}

DataPlasmaBlock is an auto generated low-level Go binding around an user-defined struct.

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 DataRequestEpochMeta 

type DataRequestEpochMeta struct {
	RequestStart        uint64
	RequestEnd          uint64
	FirstRequestBlockId uint64
	NumEnter            uint64
	NextEnterEpoch      uint64
	NextEpoch           uint64
}

DataRequestEpochMeta is an auto generated low-level Go binding around an user-defined struct.

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 MapperRole 

type MapperRole struct {
	MapperRoleCaller     // Read-only binding to the contract
	MapperRoleTransactor // Write-only binding to the contract
	MapperRoleFilterer   // Log filterer for contract events
}

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

func NewMapperRole 

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

NewMapperRole creates a new instance of MapperRole, bound to a specific deployed contract.

type MapperRoleCaller 

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

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

func NewMapperRoleCaller 

func NewMapperRoleCaller(address common.Address, caller bind.ContractCaller) (*MapperRoleCaller, error)

NewMapperRoleCaller creates a new read-only instance of MapperRole, bound to a specific deployed contract.

func (*MapperRoleCaller) IsMapper 

func (_MapperRole *MapperRoleCaller) IsMapper(opts *bind.CallOpts, account common.Address) (bool, error)

IsMapper is a free data retrieval call binding the contract method 0xc0c49c2a.

Solidity: function isMapper(address account) constant returns(bool)

type MapperRoleCallerRaw 

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

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

func (*MapperRoleCallerRaw) Call 

func (_MapperRole *MapperRoleCallerRaw) 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 MapperRoleCallerSession 

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

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

func (*MapperRoleCallerSession) IsMapper 

func (_MapperRole *MapperRoleCallerSession) IsMapper(account common.Address) (bool, error)

IsMapper is a free data retrieval call binding the contract method 0xc0c49c2a.

Solidity: function isMapper(address account) constant returns(bool)

type MapperRoleFilterer 

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

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

func NewMapperRoleFilterer 

func NewMapperRoleFilterer(address common.Address, filterer bind.ContractFilterer) (*MapperRoleFilterer, error)

NewMapperRoleFilterer creates a new log filterer instance of MapperRole, bound to a specific deployed contract.

func (*MapperRoleFilterer) FilterMapperAdded 

func (_MapperRole *MapperRoleFilterer) FilterMapperAdded(opts *bind.FilterOpts, account []common.Address) (*MapperRoleMapperAddedIterator, error)

FilterMapperAdded is a free log retrieval operation binding the contract event 0xa199526a01dbcba68aa3ab9d7d06c6692c83fb1a8bcf2184e6d94ad34f5aaf95.

Solidity: event MapperAdded(address indexed account)

func (*MapperRoleFilterer) FilterMapperRemoved 

func (_MapperRole *MapperRoleFilterer) FilterMapperRemoved(opts *bind.FilterOpts, account []common.Address) (*MapperRoleMapperRemovedIterator, error)

FilterMapperRemoved is a free log retrieval operation binding the contract event 0xf012269e1b6bb33c7800e7e54167ddd74f0ae7244108030b6876821d3779822f.

Solidity: event MapperRemoved(address indexed account)

func (*MapperRoleFilterer) ParseMapperAdded 

func (_MapperRole *MapperRoleFilterer) ParseMapperAdded(log types.Log) (*MapperRoleMapperAdded, error)

ParseMapperAdded is a log parse operation binding the contract event 0xa199526a01dbcba68aa3ab9d7d06c6692c83fb1a8bcf2184e6d94ad34f5aaf95.

Solidity: event MapperAdded(address indexed account)

func (*MapperRoleFilterer) ParseMapperRemoved 

func (_MapperRole *MapperRoleFilterer) ParseMapperRemoved(log types.Log) (*MapperRoleMapperRemoved, error)

ParseMapperRemoved is a log parse operation binding the contract event 0xf012269e1b6bb33c7800e7e54167ddd74f0ae7244108030b6876821d3779822f.

Solidity: event MapperRemoved(address indexed account)

func (*MapperRoleFilterer) WatchMapperAdded 

func (_MapperRole *MapperRoleFilterer) WatchMapperAdded(opts *bind.WatchOpts, sink chan<- *MapperRoleMapperAdded, account []common.Address) (event.Subscription, error)

WatchMapperAdded is a free log subscription operation binding the contract event 0xa199526a01dbcba68aa3ab9d7d06c6692c83fb1a8bcf2184e6d94ad34f5aaf95.

Solidity: event MapperAdded(address indexed account)

func (*MapperRoleFilterer) WatchMapperRemoved 

func (_MapperRole *MapperRoleFilterer) WatchMapperRemoved(opts *bind.WatchOpts, sink chan<- *MapperRoleMapperRemoved, account []common.Address) (event.Subscription, error)

WatchMapperRemoved is a free log subscription operation binding the contract event 0xf012269e1b6bb33c7800e7e54167ddd74f0ae7244108030b6876821d3779822f.

Solidity: event MapperRemoved(address indexed account)

type MapperRoleMapperAdded 

type MapperRoleMapperAdded struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

MapperRoleMapperAdded represents a MapperAdded event raised by the MapperRole contract.

type MapperRoleMapperAddedIterator 

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

MapperRoleMapperAddedIterator is returned from FilterMapperAdded and is used to iterate over the raw logs and unpacked data for MapperAdded events raised by the MapperRole contract.

func (*MapperRoleMapperAddedIterator) Close 

func (it *MapperRoleMapperAddedIterator) Close() error

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

func (*MapperRoleMapperAddedIterator) Error 

func (it *MapperRoleMapperAddedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*MapperRoleMapperAddedIterator) Next 

func (it *MapperRoleMapperAddedIterator) 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 MapperRoleMapperRemoved 

type MapperRoleMapperRemoved struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

MapperRoleMapperRemoved represents a MapperRemoved event raised by the MapperRole contract.

type MapperRoleMapperRemovedIterator 

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

MapperRoleMapperRemovedIterator is returned from FilterMapperRemoved and is used to iterate over the raw logs and unpacked data for MapperRemoved events raised by the MapperRole contract.

func (*MapperRoleMapperRemovedIterator) Close 

func (it *MapperRoleMapperRemovedIterator) Close() error

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

func (*MapperRoleMapperRemovedIterator) Error 

func (it *MapperRoleMapperRemovedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*MapperRoleMapperRemovedIterator) Next 

func (it *MapperRoleMapperRemovedIterator) 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 MapperRoleRaw 

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

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

func (*MapperRoleRaw) Call 

func (_MapperRole *MapperRoleRaw) 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 (*MapperRoleRaw) Transact 

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

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

func (*MapperRoleRaw) Transfer 

func (_MapperRole *MapperRoleRaw) 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 MapperRoleSession 

type MapperRoleSession struct {
	Contract     *MapperRole       // 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
}

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

func (*MapperRoleSession) AddMapper 

func (_MapperRole *MapperRoleSession) AddMapper(account common.Address) (*types.Transaction, error)

AddMapper is a paid mutator transaction binding the contract method 0x80e3e81d.

Solidity: function addMapper(address account) returns()

func (*MapperRoleSession) IsMapper 

func (_MapperRole *MapperRoleSession) IsMapper(account common.Address) (bool, error)

IsMapper is a free data retrieval call binding the contract method 0xc0c49c2a.

Solidity: function isMapper(address account) constant returns(bool)

func (*MapperRoleSession) RenounceMapper 

func (_MapperRole *MapperRoleSession) RenounceMapper() (*types.Transaction, error)

RenounceMapper is a paid mutator transaction binding the contract method 0x3565fb0d.

Solidity: function renounceMapper() returns()

type MapperRoleTransactor 

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

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

func NewMapperRoleTransactor 

func NewMapperRoleTransactor(address common.Address, transactor bind.ContractTransactor) (*MapperRoleTransactor, error)

NewMapperRoleTransactor creates a new write-only instance of MapperRole, bound to a specific deployed contract.

func (*MapperRoleTransactor) AddMapper 

func (_MapperRole *MapperRoleTransactor) AddMapper(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error)

AddMapper is a paid mutator transaction binding the contract method 0x80e3e81d.

Solidity: function addMapper(address account) returns()

func (*MapperRoleTransactor) RenounceMapper 

func (_MapperRole *MapperRoleTransactor) RenounceMapper(opts *bind.TransactOpts) (*types.Transaction, error)

RenounceMapper is a paid mutator transaction binding the contract method 0x3565fb0d.

Solidity: function renounceMapper() returns()

type MapperRoleTransactorRaw 

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

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

func (*MapperRoleTransactorRaw) Transact 

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

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

func (*MapperRoleTransactorRaw) Transfer 

func (_MapperRole *MapperRoleTransactorRaw) 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 MapperRoleTransactorSession 

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

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

func (*MapperRoleTransactorSession) AddMapper 

func (_MapperRole *MapperRoleTransactorSession) AddMapper(account common.Address) (*types.Transaction, error)

AddMapper is a paid mutator transaction binding the contract method 0x80e3e81d.

Solidity: function addMapper(address account) returns()

func (*MapperRoleTransactorSession) RenounceMapper 

func (_MapperRole *MapperRoleTransactorSession) RenounceMapper() (*types.Transaction, error)

RenounceMapper is a paid mutator transaction binding the contract method 0x3565fb0d.

Solidity: function renounceMapper() 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 Roles 

type Roles struct {
	RolesCaller     // Read-only binding to the contract
	RolesTransactor // Write-only binding to the contract
	RolesFilterer   // Log filterer for contract events
}

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

func DeployRoles 

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

DeployRoles deploys a new Ethereum contract, binding an instance of Roles to it.

func NewRoles 

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

NewRoles creates a new instance of Roles, bound to a specific deployed contract.

type RolesCaller 

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

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

func NewRolesCaller 

func NewRolesCaller(address common.Address, caller bind.ContractCaller) (*RolesCaller, error)

NewRolesCaller creates a new read-only instance of Roles, bound to a specific deployed contract.

type RolesCallerRaw 

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

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

func (*RolesCallerRaw) Call 

func (_Roles *RolesCallerRaw) 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 RolesCallerSession 

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

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

type RolesFilterer 

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

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

func NewRolesFilterer 

func NewRolesFilterer(address common.Address, filterer bind.ContractFilterer) (*RolesFilterer, error)

NewRolesFilterer creates a new log filterer instance of Roles, bound to a specific deployed contract.

type RolesRaw 

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

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

func (*RolesRaw) Call 

func (_Roles *RolesRaw) 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 (*RolesRaw) Transact 

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

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

func (*RolesRaw) Transfer 

func (_Roles *RolesRaw) 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 RolesSession 

type RolesSession struct {
	Contract     *Roles            // 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
}

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

type RolesTransactor 

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

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

func NewRolesTransactor 

func NewRolesTransactor(address common.Address, transactor bind.ContractTransactor) (*RolesTransactor, error)

NewRolesTransactor creates a new write-only instance of Roles, bound to a specific deployed contract.

type RolesTransactorRaw 

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

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

func (*RolesTransactorRaw) Transact 

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

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

func (*RolesTransactorRaw) Transfer 

func (_Roles *RolesTransactorRaw) 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 RolesTransactorSession 

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

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

type RootChain 

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

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

func DeployRootChain 

func DeployRootChain(auth *bind.TransactOpts, backend bind.ContractBackend, _epochHandler common.Address, _submitHandler common.Address, _etherToken common.Address, _development bool, _NRELength *big.Int, _statesRoot [32]byte, _transactionsRoot [32]byte, _receiptsRoot [32]byte) (common.Address, *types.Transaction, *RootChain, error)

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

func NewRootChain 

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

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

type RootChainBase 

type RootChainBase struct {
	RootChainBaseCaller     // Read-only binding to the contract
	RootChainBaseTransactor // Write-only binding to the contract
	RootChainBaseFilterer   // Log filterer for contract events
}

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

func DeployRootChainBase 

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

DeployRootChainBase deploys a new Ethereum contract, binding an instance of RootChainBase to it.

func NewRootChainBase 

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

NewRootChainBase creates a new instance of RootChainBase, bound to a specific deployed contract.

type RootChainBaseBlockFinalized 

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

RootChainBaseBlockFinalized represents a BlockFinalized event raised by the RootChainBase contract.

type RootChainBaseBlockFinalizedIterator 

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

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

func (*RootChainBaseBlockFinalizedIterator) Close 

func (it *RootChainBaseBlockFinalizedIterator) Close() error

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

func (*RootChainBaseBlockFinalizedIterator) Error 

func (it *RootChainBaseBlockFinalizedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainBaseBlockFinalizedIterator) Next 

func (it *RootChainBaseBlockFinalizedIterator) 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 RootChainBaseBlockSubmitted 

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

RootChainBaseBlockSubmitted represents a BlockSubmitted event raised by the RootChainBase contract.

type RootChainBaseBlockSubmittedIterator 

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

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

func (*RootChainBaseBlockSubmittedIterator) Close 

func (it *RootChainBaseBlockSubmittedIterator) Close() error

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

func (*RootChainBaseBlockSubmittedIterator) Error 

func (it *RootChainBaseBlockSubmittedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainBaseBlockSubmittedIterator) Next 

func (it *RootChainBaseBlockSubmittedIterator) 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 RootChainBaseCaller 

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

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

func NewRootChainBaseCaller 

func NewRootChainBaseCaller(address common.Address, caller bind.ContractCaller) (*RootChainBaseCaller, error)

NewRootChainBaseCaller creates a new read-only instance of RootChainBase, bound to a specific deployed contract.

func (*RootChainBaseCaller) COSTERO 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) COSTERU 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) COSTNRB 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) COSTORB 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) COSTURB 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) COSTURBPREPARE 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) CPCOMPUTATION 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) CPEXIT 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) CPWITHHOLDING 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) CurrentFork 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) Development 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) EROIdToFinalize 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) EROs 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) ERUIdToFinalize 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) ERUs 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) EpochHandler 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) EtherToken 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) FirstFilledORENumber 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) FirstNonEmptyRequestEpoch 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) Forks 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) IsRootChain 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) LastAppliedBlockNumber 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) LastAppliedEpochNumber 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) LastAppliedForkNumber 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) LastNonEmptyRequestEpoch 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) NRELength 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) NULLADDRESS 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) NumEnterForORB 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) ORBs 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) Operator 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) PREPARETIMEOUT 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) REQUESTGAS 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) RequestableContracts 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) SeigManager 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) SubmitHandler 

func (_RootChainBase *RootChainBaseCaller) 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 (*RootChainBaseCaller) URBs 

func (_RootChainBase *RootChainBaseCaller) 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 RootChainBaseCallerRaw 

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

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

func (*RootChainBaseCallerRaw) Call 

func (_RootChainBase *RootChainBaseCallerRaw) 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 RootChainBaseCallerSession 

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

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

func (*RootChainBaseCallerSession) COSTERO 

func (_RootChainBase *RootChainBaseCallerSession) COSTERO() (*big.Int, error)

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

Solidity: function COST_ERO() constant returns(uint256)

func (*RootChainBaseCallerSession) COSTERU 

func (_RootChainBase *RootChainBaseCallerSession) COSTERU() (*big.Int, error)

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

Solidity: function COST_ERU() constant returns(uint256)

func (*RootChainBaseCallerSession) COSTNRB 

func (_RootChainBase *RootChainBaseCallerSession) COSTNRB() (*big.Int, error)

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

Solidity: function COST_NRB() constant returns(uint256)

func (*RootChainBaseCallerSession) COSTORB 

func (_RootChainBase *RootChainBaseCallerSession) COSTORB() (*big.Int, error)

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

Solidity: function COST_ORB() constant returns(uint256)

func (*RootChainBaseCallerSession) COSTURB 

func (_RootChainBase *RootChainBaseCallerSession) COSTURB() (*big.Int, error)

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

Solidity: function COST_URB() constant returns(uint256)

func (*RootChainBaseCallerSession) COSTURBPREPARE 

func (_RootChainBase *RootChainBaseCallerSession) 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 (*RootChainBaseCallerSession) CPCOMPUTATION 

func (_RootChainBase *RootChainBaseCallerSession) CPCOMPUTATION() (*big.Int, error)

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

Solidity: function CP_COMPUTATION() constant returns(uint256)

func (*RootChainBaseCallerSession) CPEXIT 

func (_RootChainBase *RootChainBaseCallerSession) CPEXIT() (*big.Int, error)

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

Solidity: function CP_EXIT() constant returns(uint256)

func (*RootChainBaseCallerSession) CPWITHHOLDING 

func (_RootChainBase *RootChainBaseCallerSession) CPWITHHOLDING() (*big.Int, error)

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

Solidity: function CP_WITHHOLDING() constant returns(uint256)

func (*RootChainBaseCallerSession) CurrentFork 

func (_RootChainBase *RootChainBaseCallerSession) CurrentFork() (*big.Int, error)

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

Solidity: function currentFork() constant returns(uint256)

func (*RootChainBaseCallerSession) Development 

func (_RootChainBase *RootChainBaseCallerSession) Development() (bool, error)

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

Solidity: function development() constant returns(bool)

func (*RootChainBaseCallerSession) EROIdToFinalize 

func (_RootChainBase *RootChainBaseCallerSession) EROIdToFinalize() (*big.Int, error)

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

Solidity: function EROIdToFinalize() constant returns(uint256)

func (*RootChainBaseCallerSession) EROs 

func (_RootChainBase *RootChainBaseCallerSession) 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 (*RootChainBaseCallerSession) ERUIdToFinalize 

func (_RootChainBase *RootChainBaseCallerSession) ERUIdToFinalize() (*big.Int, error)

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

Solidity: function ERUIdToFinalize() constant returns(uint256)

func (*RootChainBaseCallerSession) ERUs 

func (_RootChainBase *RootChainBaseCallerSession) 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 (*RootChainBaseCallerSession) EpochHandler 

func (_RootChainBase *RootChainBaseCallerSession) EpochHandler() (common.Address, error)

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

Solidity: function epochHandler() constant returns(address)

func (*RootChainBaseCallerSession) EtherToken 

func (_RootChainBase *RootChainBaseCallerSession) EtherToken() (common.Address, error)

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

Solidity: function etherToken() constant returns(address)

func (*RootChainBaseCallerSession) FirstFilledORENumber 

func (_RootChainBase *RootChainBaseCallerSession) 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 (*RootChainBaseCallerSession) FirstNonEmptyRequestEpoch 

func (_RootChainBase *RootChainBaseCallerSession) 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 (*RootChainBaseCallerSession) Forks 

func (_RootChainBase *RootChainBaseCallerSession) 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 (*RootChainBaseCallerSession) IsRootChain 

func (_RootChainBase *RootChainBaseCallerSession) IsRootChain() (bool, error)

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

Solidity: function isRootChain() constant returns(bool)

func (*RootChainBaseCallerSession) LastAppliedBlockNumber 

func (_RootChainBase *RootChainBaseCallerSession) LastAppliedBlockNumber() (*big.Int, error)

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

Solidity: function lastAppliedBlockNumber() constant returns(uint256)

func (*RootChainBaseCallerSession) LastAppliedEpochNumber 

func (_RootChainBase *RootChainBaseCallerSession) LastAppliedEpochNumber() (*big.Int, error)

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

Solidity: function lastAppliedEpochNumber() constant returns(uint256)

func (*RootChainBaseCallerSession) LastAppliedForkNumber 

func (_RootChainBase *RootChainBaseCallerSession) LastAppliedForkNumber() (*big.Int, error)

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

Solidity: function lastAppliedForkNumber() constant returns(uint256)

func (*RootChainBaseCallerSession) LastNonEmptyRequestEpoch 

func (_RootChainBase *RootChainBaseCallerSession) 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 (*RootChainBaseCallerSession) NRELength 

func (_RootChainBase *RootChainBaseCallerSession) NRELength() (*big.Int, error)

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

Solidity: function NRELength() constant returns(uint256)

func (*RootChainBaseCallerSession) NULLADDRESS 

func (_RootChainBase *RootChainBaseCallerSession) NULLADDRESS() (common.Address, error)

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

Solidity: function NULL_ADDRESS() constant returns(address)

func (*RootChainBaseCallerSession) NumEnterForORB 

func (_RootChainBase *RootChainBaseCallerSession) NumEnterForORB() (*big.Int, error)

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

Solidity: function numEnterForORB() constant returns(uint256)

func (*RootChainBaseCallerSession) ORBs 

func (_RootChainBase *RootChainBaseCallerSession) 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 (*RootChainBaseCallerSession) Operator 

func (_RootChainBase *RootChainBaseCallerSession) Operator() (common.Address, error)

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

Solidity: function operator() constant returns(address)

func (*RootChainBaseCallerSession) PREPARETIMEOUT 

func (_RootChainBase *RootChainBaseCallerSession) PREPARETIMEOUT() (*big.Int, error)

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

Solidity: function PREPARE_TIMEOUT() constant returns(uint256)

func (*RootChainBaseCallerSession) REQUESTGAS 

func (_RootChainBase *RootChainBaseCallerSession) REQUESTGAS() (*big.Int, error)

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

Solidity: function REQUEST_GAS() constant returns(uint256)

func (*RootChainBaseCallerSession) RequestableContracts 

func (_RootChainBase *RootChainBaseCallerSession) 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 (*RootChainBaseCallerSession) SeigManager 

func (_RootChainBase *RootChainBaseCallerSession) SeigManager() (common.Address, error)

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

Solidity: function seigManager() constant returns(address)

func (*RootChainBaseCallerSession) SubmitHandler 

func (_RootChainBase *RootChainBaseCallerSession) SubmitHandler() (common.Address, error)

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

Solidity: function submitHandler() constant returns(address)

func (*RootChainBaseCallerSession) URBs 

func (_RootChainBase *RootChainBaseCallerSession) 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 RootChainBaseERUCreated 

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

RootChainBaseERUCreated represents a ERUCreated event raised by the RootChainBase contract.

type RootChainBaseERUCreatedIterator 

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

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

func (*RootChainBaseERUCreatedIterator) Close 

func (it *RootChainBaseERUCreatedIterator) Close() error

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

func (*RootChainBaseERUCreatedIterator) Error 

func (it *RootChainBaseERUCreatedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainBaseERUCreatedIterator) Next 

func (it *RootChainBaseERUCreatedIterator) 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 RootChainBaseEpochFilled 

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

RootChainBaseEpochFilled represents a EpochFilled event raised by the RootChainBase contract.

type RootChainBaseEpochFilledIterator 

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

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

func (*RootChainBaseEpochFilledIterator) Close 

func (it *RootChainBaseEpochFilledIterator) Close() error

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

func (*RootChainBaseEpochFilledIterator) Error 

func (it *RootChainBaseEpochFilledIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainBaseEpochFilledIterator) Next 

func (it *RootChainBaseEpochFilledIterator) 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 RootChainBaseEpochFilling 

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

RootChainBaseEpochFilling represents a EpochFilling event raised by the RootChainBase contract.

type RootChainBaseEpochFillingIterator 

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

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

func (*RootChainBaseEpochFillingIterator) Close 

func (it *RootChainBaseEpochFillingIterator) Close() error

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

func (*RootChainBaseEpochFillingIterator) Error 

func (it *RootChainBaseEpochFillingIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainBaseEpochFillingIterator) Next 

func (it *RootChainBaseEpochFillingIterator) 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 RootChainBaseEpochFinalized 

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

RootChainBaseEpochFinalized represents a EpochFinalized event raised by the RootChainBase contract.

type RootChainBaseEpochFinalizedIterator 

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

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

func (*RootChainBaseEpochFinalizedIterator) Close 

func (it *RootChainBaseEpochFinalizedIterator) Close() error

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

func (*RootChainBaseEpochFinalizedIterator) Error 

func (it *RootChainBaseEpochFinalizedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainBaseEpochFinalizedIterator) Next 

func (it *RootChainBaseEpochFinalizedIterator) 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 RootChainBaseEpochPrepared 

type RootChainBaseEpochPrepared 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
}

RootChainBaseEpochPrepared represents a EpochPrepared event raised by the RootChainBase contract.

type RootChainBaseEpochPreparedIterator 

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

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

func (*RootChainBaseEpochPreparedIterator) Close 

func (it *RootChainBaseEpochPreparedIterator) Close() error

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

func (*RootChainBaseEpochPreparedIterator) Error 

func (it *RootChainBaseEpochPreparedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainBaseEpochPreparedIterator) Next 

func (it *RootChainBaseEpochPreparedIterator) 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 RootChainBaseEpochRebased 

type RootChainBaseEpochRebased 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
}

RootChainBaseEpochRebased represents a EpochRebased event raised by the RootChainBase contract.

type RootChainBaseEpochRebasedIterator 

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

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

func (*RootChainBaseEpochRebasedIterator) Close 

func (it *RootChainBaseEpochRebasedIterator) Close() error

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

func (*RootChainBaseEpochRebasedIterator) Error 

func (it *RootChainBaseEpochRebasedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainBaseEpochRebasedIterator) Next 

func (it *RootChainBaseEpochRebasedIterator) 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 RootChainBaseFilterer 

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

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

func NewRootChainBaseFilterer 

func NewRootChainBaseFilterer(address common.Address, filterer bind.ContractFilterer) (*RootChainBaseFilterer, error)

NewRootChainBaseFilterer creates a new log filterer instance of RootChainBase, bound to a specific deployed contract.

func (*RootChainBaseFilterer) FilterBlockFinalized 

func (_RootChainBase *RootChainBaseFilterer) FilterBlockFinalized(opts *bind.FilterOpts) (*RootChainBaseBlockFinalizedIterator, error)

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

Solidity: event BlockFinalized(uint256 forkNumber, uint256 blockNumber)

func (*RootChainBaseFilterer) FilterBlockSubmitted 

func (_RootChainBase *RootChainBaseFilterer) FilterBlockSubmitted(opts *bind.FilterOpts) (*RootChainBaseBlockSubmittedIterator, 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 (*RootChainBaseFilterer) FilterERUCreated 

func (_RootChainBase *RootChainBaseFilterer) FilterERUCreated(opts *bind.FilterOpts) (*RootChainBaseERUCreatedIterator, 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 (*RootChainBaseFilterer) FilterEpochFilled 

func (_RootChainBase *RootChainBaseFilterer) FilterEpochFilled(opts *bind.FilterOpts) (*RootChainBaseEpochFilledIterator, error)

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

Solidity: event EpochFilled(uint256 forkNumber, uint256 epochNumber)

func (*RootChainBaseFilterer) FilterEpochFilling 

func (_RootChainBase *RootChainBaseFilterer) FilterEpochFilling(opts *bind.FilterOpts) (*RootChainBaseEpochFillingIterator, error)

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

Solidity: event EpochFilling(uint256 forkNumber, uint256 epochNumber)

func (*RootChainBaseFilterer) FilterEpochFinalized 

func (_RootChainBase *RootChainBaseFilterer) FilterEpochFinalized(opts *bind.FilterOpts) (*RootChainBaseEpochFinalizedIterator, 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 (*RootChainBaseFilterer) FilterEpochPrepared 

func (_RootChainBase *RootChainBaseFilterer) FilterEpochPrepared(opts *bind.FilterOpts) (*RootChainBaseEpochPreparedIterator, 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 (*RootChainBaseFilterer) FilterEpochRebased 

func (_RootChainBase *RootChainBaseFilterer) FilterEpochRebased(opts *bind.FilterOpts) (*RootChainBaseEpochRebasedIterator, 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 (*RootChainBaseFilterer) FilterForked 

func (_RootChainBase *RootChainBaseFilterer) FilterForked(opts *bind.FilterOpts) (*RootChainBaseForkedIterator, error)

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

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

func (*RootChainBaseFilterer) FilterOperatorChanged 

func (_RootChainBase *RootChainBaseFilterer) FilterOperatorChanged(opts *bind.FilterOpts) (*RootChainBaseOperatorChangedIterator, error)

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

Solidity: event OperatorChanged(address _newOperator)

func (*RootChainBaseFilterer) FilterRequestApplied 

func (_RootChainBase *RootChainBaseFilterer) FilterRequestApplied(opts *bind.FilterOpts) (*RootChainBaseRequestAppliedIterator, error)

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

Solidity: event RequestApplied(uint256 requestId, bool userActivated)

func (*RootChainBaseFilterer) FilterRequestChallenged 

func (_RootChainBase *RootChainBaseFilterer) FilterRequestChallenged(opts *bind.FilterOpts) (*RootChainBaseRequestChallengedIterator, error)

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

Solidity: event RequestChallenged(uint256 requestId, bool userActivated)

func (*RootChainBaseFilterer) FilterRequestCreated 

func (_RootChainBase *RootChainBaseFilterer) FilterRequestCreated(opts *bind.FilterOpts) (*RootChainBaseRequestCreatedIterator, 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 (*RootChainBaseFilterer) FilterRequestFinalized 

func (_RootChainBase *RootChainBaseFilterer) FilterRequestFinalized(opts *bind.FilterOpts) (*RootChainBaseRequestFinalizedIterator, error)

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

Solidity: event RequestFinalized(uint256 requestId, bool userActivated)

func (*RootChainBaseFilterer) FilterRequestableContractMapped 

func (_RootChainBase *RootChainBaseFilterer) FilterRequestableContractMapped(opts *bind.FilterOpts) (*RootChainBaseRequestableContractMappedIterator, error)

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

Solidity: event RequestableContractMapped(address contractInRootchain, address contractInChildchain)

func (*RootChainBaseFilterer) FilterSessionTimeout 

func (_RootChainBase *RootChainBaseFilterer) FilterSessionTimeout(opts *bind.FilterOpts) (*RootChainBaseSessionTimeoutIterator, error)

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

Solidity: event SessionTimeout(bool userActivated)

func (*RootChainBaseFilterer) ParseBlockFinalized 

func (_RootChainBase *RootChainBaseFilterer) ParseBlockFinalized(log types.Log) (*RootChainBaseBlockFinalized, error)

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

Solidity: event BlockFinalized(uint256 forkNumber, uint256 blockNumber)

func (*RootChainBaseFilterer) ParseBlockSubmitted 

func (_RootChainBase *RootChainBaseFilterer) ParseBlockSubmitted(log types.Log) (*RootChainBaseBlockSubmitted, 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 (*RootChainBaseFilterer) ParseERUCreated 

func (_RootChainBase *RootChainBaseFilterer) ParseERUCreated(log types.Log) (*RootChainBaseERUCreated, 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 (*RootChainBaseFilterer) ParseEpochFilled 

func (_RootChainBase *RootChainBaseFilterer) ParseEpochFilled(log types.Log) (*RootChainBaseEpochFilled, error)

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

Solidity: event EpochFilled(uint256 forkNumber, uint256 epochNumber)

func (*RootChainBaseFilterer) ParseEpochFilling 

func (_RootChainBase *RootChainBaseFilterer) ParseEpochFilling(log types.Log) (*RootChainBaseEpochFilling, error)

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

Solidity: event EpochFilling(uint256 forkNumber, uint256 epochNumber)

func (*RootChainBaseFilterer) ParseEpochFinalized 

func (_RootChainBase *RootChainBaseFilterer) ParseEpochFinalized(log types.Log) (*RootChainBaseEpochFinalized, error)

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

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

func (*RootChainBaseFilterer) ParseEpochPrepared 

func (_RootChainBase *RootChainBaseFilterer) ParseEpochPrepared(log types.Log) (*RootChainBaseEpochPrepared, 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 (*RootChainBaseFilterer) ParseEpochRebased 

func (_RootChainBase *RootChainBaseFilterer) ParseEpochRebased(log types.Log) (*RootChainBaseEpochRebased, 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 (*RootChainBaseFilterer) ParseForked 

func (_RootChainBase *RootChainBaseFilterer) ParseForked(log types.Log) (*RootChainBaseForked, error)

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

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

func (*RootChainBaseFilterer) ParseOperatorChanged 

func (_RootChainBase *RootChainBaseFilterer) ParseOperatorChanged(log types.Log) (*RootChainBaseOperatorChanged, error)

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

Solidity: event OperatorChanged(address _newOperator)

func (*RootChainBaseFilterer) ParseRequestApplied 

func (_RootChainBase *RootChainBaseFilterer) ParseRequestApplied(log types.Log) (*RootChainBaseRequestApplied, error)

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

Solidity: event RequestApplied(uint256 requestId, bool userActivated)

func (*RootChainBaseFilterer) ParseRequestChallenged 

func (_RootChainBase *RootChainBaseFilterer) ParseRequestChallenged(log types.Log) (*RootChainBaseRequestChallenged, error)

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

Solidity: event RequestChallenged(uint256 requestId, bool userActivated)

func (*RootChainBaseFilterer) ParseRequestCreated 

func (_RootChainBase *RootChainBaseFilterer) ParseRequestCreated(log types.Log) (*RootChainBaseRequestCreated, 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 (*RootChainBaseFilterer) ParseRequestFinalized 

func (_RootChainBase *RootChainBaseFilterer) ParseRequestFinalized(log types.Log) (*RootChainBaseRequestFinalized, error)

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

Solidity: event RequestFinalized(uint256 requestId, bool userActivated)

func (*RootChainBaseFilterer) ParseRequestableContractMapped 

func (_RootChainBase *RootChainBaseFilterer) ParseRequestableContractMapped(log types.Log) (*RootChainBaseRequestableContractMapped, error)

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

Solidity: event RequestableContractMapped(address contractInRootchain, address contractInChildchain)

func (*RootChainBaseFilterer) ParseSessionTimeout 

func (_RootChainBase *RootChainBaseFilterer) ParseSessionTimeout(log types.Log) (*RootChainBaseSessionTimeout, error)

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

Solidity: event SessionTimeout(bool userActivated)

func (*RootChainBaseFilterer) WatchBlockFinalized 

func (_RootChainBase *RootChainBaseFilterer) WatchBlockFinalized(opts *bind.WatchOpts, sink chan<- *RootChainBaseBlockFinalized) (event.Subscription, error)

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

Solidity: event BlockFinalized(uint256 forkNumber, uint256 blockNumber)

func (*RootChainBaseFilterer) WatchBlockSubmitted 

func (_RootChainBase *RootChainBaseFilterer) WatchBlockSubmitted(opts *bind.WatchOpts, sink chan<- *RootChainBaseBlockSubmitted) (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 (*RootChainBaseFilterer) WatchERUCreated 

func (_RootChainBase *RootChainBaseFilterer) WatchERUCreated(opts *bind.WatchOpts, sink chan<- *RootChainBaseERUCreated) (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 (*RootChainBaseFilterer) WatchEpochFilled 

func (_RootChainBase *RootChainBaseFilterer) WatchEpochFilled(opts *bind.WatchOpts, sink chan<- *RootChainBaseEpochFilled) (event.Subscription, error)

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

Solidity: event EpochFilled(uint256 forkNumber, uint256 epochNumber)

func (*RootChainBaseFilterer) WatchEpochFilling 

func (_RootChainBase *RootChainBaseFilterer) WatchEpochFilling(opts *bind.WatchOpts, sink chan<- *RootChainBaseEpochFilling) (event.Subscription, error)

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

Solidity: event EpochFilling(uint256 forkNumber, uint256 epochNumber)

func (*RootChainBaseFilterer) WatchEpochFinalized 

func (_RootChainBase *RootChainBaseFilterer) WatchEpochFinalized(opts *bind.WatchOpts, sink chan<- *RootChainBaseEpochFinalized) (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 (*RootChainBaseFilterer) WatchEpochPrepared 

func (_RootChainBase *RootChainBaseFilterer) WatchEpochPrepared(opts *bind.WatchOpts, sink chan<- *RootChainBaseEpochPrepared) (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 (*RootChainBaseFilterer) WatchEpochRebased 

func (_RootChainBase *RootChainBaseFilterer) WatchEpochRebased(opts *bind.WatchOpts, sink chan<- *RootChainBaseEpochRebased) (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 (*RootChainBaseFilterer) WatchForked 

func (_RootChainBase *RootChainBaseFilterer) WatchForked(opts *bind.WatchOpts, sink chan<- *RootChainBaseForked) (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 (*RootChainBaseFilterer) WatchOperatorChanged 

func (_RootChainBase *RootChainBaseFilterer) WatchOperatorChanged(opts *bind.WatchOpts, sink chan<- *RootChainBaseOperatorChanged) (event.Subscription, error)

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

Solidity: event OperatorChanged(address _newOperator)

func (*RootChainBaseFilterer) WatchRequestApplied 

func (_RootChainBase *RootChainBaseFilterer) WatchRequestApplied(opts *bind.WatchOpts, sink chan<- *RootChainBaseRequestApplied) (event.Subscription, error)

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

Solidity: event RequestApplied(uint256 requestId, bool userActivated)

func (*RootChainBaseFilterer) WatchRequestChallenged 

func (_RootChainBase *RootChainBaseFilterer) WatchRequestChallenged(opts *bind.WatchOpts, sink chan<- *RootChainBaseRequestChallenged) (event.Subscription, error)

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

Solidity: event RequestChallenged(uint256 requestId, bool userActivated)

func (*RootChainBaseFilterer) WatchRequestCreated 

func (_RootChainBase *RootChainBaseFilterer) WatchRequestCreated(opts *bind.WatchOpts, sink chan<- *RootChainBaseRequestCreated) (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 (*RootChainBaseFilterer) WatchRequestFinalized 

func (_RootChainBase *RootChainBaseFilterer) WatchRequestFinalized(opts *bind.WatchOpts, sink chan<- *RootChainBaseRequestFinalized) (event.Subscription, error)

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

Solidity: event RequestFinalized(uint256 requestId, bool userActivated)

func (*RootChainBaseFilterer) WatchRequestableContractMapped 

func (_RootChainBase *RootChainBaseFilterer) WatchRequestableContractMapped(opts *bind.WatchOpts, sink chan<- *RootChainBaseRequestableContractMapped) (event.Subscription, error)

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

Solidity: event RequestableContractMapped(address contractInRootchain, address contractInChildchain)

func (*RootChainBaseFilterer) WatchSessionTimeout 

func (_RootChainBase *RootChainBaseFilterer) WatchSessionTimeout(opts *bind.WatchOpts, sink chan<- *RootChainBaseSessionTimeout) (event.Subscription, error)

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

Solidity: event SessionTimeout(bool userActivated)

type RootChainBaseForked 

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

RootChainBaseForked represents a Forked event raised by the RootChainBase contract.

type RootChainBaseForkedIterator 

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

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

func (*RootChainBaseForkedIterator) Close 

func (it *RootChainBaseForkedIterator) Close() error

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

func (*RootChainBaseForkedIterator) Error 

func (it *RootChainBaseForkedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainBaseForkedIterator) Next 

func (it *RootChainBaseForkedIterator) 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 RootChainBaseOperatorChanged 

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

RootChainBaseOperatorChanged represents a OperatorChanged event raised by the RootChainBase contract.

type RootChainBaseOperatorChangedIterator 

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

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

func (*RootChainBaseOperatorChangedIterator) Close 

func (it *RootChainBaseOperatorChangedIterator) Close() error

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

func (*RootChainBaseOperatorChangedIterator) Error 

func (it *RootChainBaseOperatorChangedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainBaseOperatorChangedIterator) Next 

func (it *RootChainBaseOperatorChangedIterator) 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 RootChainBaseRaw 

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

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

func (*RootChainBaseRaw) Call 

func (_RootChainBase *RootChainBaseRaw) 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 (*RootChainBaseRaw) Transact 

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

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

func (*RootChainBaseRaw) Transfer 

func (_RootChainBase *RootChainBaseRaw) 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 RootChainBaseRequestApplied 

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

RootChainBaseRequestApplied represents a RequestApplied event raised by the RootChainBase contract.

type RootChainBaseRequestAppliedIterator 

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

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

func (*RootChainBaseRequestAppliedIterator) Close 

func (it *RootChainBaseRequestAppliedIterator) Close() error

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

func (*RootChainBaseRequestAppliedIterator) Error 

func (it *RootChainBaseRequestAppliedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainBaseRequestAppliedIterator) Next 

func (it *RootChainBaseRequestAppliedIterator) 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 RootChainBaseRequestChallenged 

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

RootChainBaseRequestChallenged represents a RequestChallenged event raised by the RootChainBase contract.

type RootChainBaseRequestChallengedIterator 

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

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

func (*RootChainBaseRequestChallengedIterator) Close 

func (it *RootChainBaseRequestChallengedIterator) Close() error

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

func (*RootChainBaseRequestChallengedIterator) Error 

func (it *RootChainBaseRequestChallengedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainBaseRequestChallengedIterator) Next 

func (it *RootChainBaseRequestChallengedIterator) 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 RootChainBaseRequestCreated 

type RootChainBaseRequestCreated 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
}

RootChainBaseRequestCreated represents a RequestCreated event raised by the RootChainBase contract.

type RootChainBaseRequestCreatedIterator 

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

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

func (*RootChainBaseRequestCreatedIterator) Close 

func (it *RootChainBaseRequestCreatedIterator) Close() error

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

func (*RootChainBaseRequestCreatedIterator) Error 

func (it *RootChainBaseRequestCreatedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainBaseRequestCreatedIterator) Next 

func (it *RootChainBaseRequestCreatedIterator) 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 RootChainBaseRequestFinalized 

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

RootChainBaseRequestFinalized represents a RequestFinalized event raised by the RootChainBase contract.

type RootChainBaseRequestFinalizedIterator 

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

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

func (*RootChainBaseRequestFinalizedIterator) Close 

func (it *RootChainBaseRequestFinalizedIterator) Close() error

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

func (*RootChainBaseRequestFinalizedIterator) Error 

func (it *RootChainBaseRequestFinalizedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainBaseRequestFinalizedIterator) Next 

func (it *RootChainBaseRequestFinalizedIterator) 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 RootChainBaseRequestableContractMapped 

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

RootChainBaseRequestableContractMapped represents a RequestableContractMapped event raised by the RootChainBase contract.

type RootChainBaseRequestableContractMappedIterator 

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

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

func (*RootChainBaseRequestableContractMappedIterator) Close 

func (it *RootChainBaseRequestableContractMappedIterator) Close() error

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

func (*RootChainBaseRequestableContractMappedIterator) Error 

func (it *RootChainBaseRequestableContractMappedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainBaseRequestableContractMappedIterator) Next 

func (it *RootChainBaseRequestableContractMappedIterator) 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 RootChainBaseSession 

type RootChainBaseSession struct {
	Contract     *RootChainBase    // 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
}

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

func (*RootChainBaseSession) COSTERO 

func (_RootChainBase *RootChainBaseSession) COSTERO() (*big.Int, error)

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

Solidity: function COST_ERO() constant returns(uint256)

func (*RootChainBaseSession) COSTERU 

func (_RootChainBase *RootChainBaseSession) COSTERU() (*big.Int, error)

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

Solidity: function COST_ERU() constant returns(uint256)

func (*RootChainBaseSession) COSTNRB 

func (_RootChainBase *RootChainBaseSession) COSTNRB() (*big.Int, error)

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

Solidity: function COST_NRB() constant returns(uint256)

func (*RootChainBaseSession) COSTORB 

func (_RootChainBase *RootChainBaseSession) COSTORB() (*big.Int, error)

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

Solidity: function COST_ORB() constant returns(uint256)

func (*RootChainBaseSession) COSTURB 

func (_RootChainBase *RootChainBaseSession) COSTURB() (*big.Int, error)

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

Solidity: function COST_URB() constant returns(uint256)

func (*RootChainBaseSession) COSTURBPREPARE 

func (_RootChainBase *RootChainBaseSession) 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 (*RootChainBaseSession) CPCOMPUTATION 

func (_RootChainBase *RootChainBaseSession) CPCOMPUTATION() (*big.Int, error)

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

Solidity: function CP_COMPUTATION() constant returns(uint256)

func (*RootChainBaseSession) CPEXIT 

func (_RootChainBase *RootChainBaseSession) CPEXIT() (*big.Int, error)

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

Solidity: function CP_EXIT() constant returns(uint256)

func (*RootChainBaseSession) CPWITHHOLDING 

func (_RootChainBase *RootChainBaseSession) CPWITHHOLDING() (*big.Int, error)

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

Solidity: function CP_WITHHOLDING() constant returns(uint256)

func (*RootChainBaseSession) CurrentFork 

func (_RootChainBase *RootChainBaseSession) CurrentFork() (*big.Int, error)

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

Solidity: function currentFork() constant returns(uint256)

func (*RootChainBaseSession) Development 

func (_RootChainBase *RootChainBaseSession) Development() (bool, error)

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

Solidity: function development() constant returns(bool)

func (*RootChainBaseSession) EROIdToFinalize 

func (_RootChainBase *RootChainBaseSession) EROIdToFinalize() (*big.Int, error)

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

Solidity: function EROIdToFinalize() constant returns(uint256)

func (*RootChainBaseSession) EROs 

func (_RootChainBase *RootChainBaseSession) 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 (*RootChainBaseSession) ERUIdToFinalize 

func (_RootChainBase *RootChainBaseSession) ERUIdToFinalize() (*big.Int, error)

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

Solidity: function ERUIdToFinalize() constant returns(uint256)

func (*RootChainBaseSession) ERUs 

func (_RootChainBase *RootChainBaseSession) 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 (*RootChainBaseSession) EpochHandler 

func (_RootChainBase *RootChainBaseSession) EpochHandler() (common.Address, error)

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

Solidity: function epochHandler() constant returns(address)

func (*RootChainBaseSession) EtherToken 

func (_RootChainBase *RootChainBaseSession) EtherToken() (common.Address, error)

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

Solidity: function etherToken() constant returns(address)

func (*RootChainBaseSession) FirstFilledORENumber 

func (_RootChainBase *RootChainBaseSession) 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 (*RootChainBaseSession) FirstNonEmptyRequestEpoch 

func (_RootChainBase *RootChainBaseSession) 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 (*RootChainBaseSession) Forks 

func (_RootChainBase *RootChainBaseSession) 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 (*RootChainBaseSession) IsRootChain 

func (_RootChainBase *RootChainBaseSession) IsRootChain() (bool, error)

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

Solidity: function isRootChain() constant returns(bool)

func (*RootChainBaseSession) LastAppliedBlockNumber 

func (_RootChainBase *RootChainBaseSession) LastAppliedBlockNumber() (*big.Int, error)

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

Solidity: function lastAppliedBlockNumber() constant returns(uint256)

func (*RootChainBaseSession) LastAppliedEpochNumber 

func (_RootChainBase *RootChainBaseSession) LastAppliedEpochNumber() (*big.Int, error)

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

Solidity: function lastAppliedEpochNumber() constant returns(uint256)

func (*RootChainBaseSession) LastAppliedForkNumber 

func (_RootChainBase *RootChainBaseSession) LastAppliedForkNumber() (*big.Int, error)

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

Solidity: function lastAppliedForkNumber() constant returns(uint256)

func (*RootChainBaseSession) LastNonEmptyRequestEpoch 

func (_RootChainBase *RootChainBaseSession) 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 (*RootChainBaseSession) NRELength 

func (_RootChainBase *RootChainBaseSession) NRELength() (*big.Int, error)

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

Solidity: function NRELength() constant returns(uint256)

func (*RootChainBaseSession) NULLADDRESS 

func (_RootChainBase *RootChainBaseSession) NULLADDRESS() (common.Address, error)

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

Solidity: function NULL_ADDRESS() constant returns(address)

func (*RootChainBaseSession) NumEnterForORB 

func (_RootChainBase *RootChainBaseSession) NumEnterForORB() (*big.Int, error)

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

Solidity: function numEnterForORB() constant returns(uint256)

func (*RootChainBaseSession) ORBs 

func (_RootChainBase *RootChainBaseSession) 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 (*RootChainBaseSession) Operator 

func (_RootChainBase *RootChainBaseSession) Operator() (common.Address, error)

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

Solidity: function operator() constant returns(address)

func (*RootChainBaseSession) PREPARETIMEOUT 

func (_RootChainBase *RootChainBaseSession) PREPARETIMEOUT() (*big.Int, error)

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

Solidity: function PREPARE_TIMEOUT() constant returns(uint256)

func (*RootChainBaseSession) REQUESTGAS 

func (_RootChainBase *RootChainBaseSession) REQUESTGAS() (*big.Int, error)

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

Solidity: function REQUEST_GAS() constant returns(uint256)

func (*RootChainBaseSession) RequestableContracts 

func (_RootChainBase *RootChainBaseSession) 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 (*RootChainBaseSession) SeigManager 

func (_RootChainBase *RootChainBaseSession) SeigManager() (common.Address, error)

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

Solidity: function seigManager() constant returns(address)

func (*RootChainBaseSession) SubmitHandler 

func (_RootChainBase *RootChainBaseSession) SubmitHandler() (common.Address, error)

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

Solidity: function submitHandler() constant returns(address)

func (*RootChainBaseSession) URBs 

func (_RootChainBase *RootChainBaseSession) 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 RootChainBaseSessionTimeout 

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

RootChainBaseSessionTimeout represents a SessionTimeout event raised by the RootChainBase contract.

type RootChainBaseSessionTimeoutIterator 

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

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

func (*RootChainBaseSessionTimeoutIterator) Close 

func (it *RootChainBaseSessionTimeoutIterator) Close() error

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

func (*RootChainBaseSessionTimeoutIterator) Error 

func (it *RootChainBaseSessionTimeoutIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainBaseSessionTimeoutIterator) Next 

func (it *RootChainBaseSessionTimeoutIterator) 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 RootChainBaseTransactor 

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

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

func NewRootChainBaseTransactor 

func NewRootChainBaseTransactor(address common.Address, transactor bind.ContractTransactor) (*RootChainBaseTransactor, error)

NewRootChainBaseTransactor creates a new write-only instance of RootChainBase, bound to a specific deployed contract.

type RootChainBaseTransactorRaw 

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

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

func (*RootChainBaseTransactorRaw) Transact 

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

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

func (*RootChainBaseTransactorRaw) Transfer 

func (_RootChainBase *RootChainBaseTransactorRaw) 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 RootChainBaseTransactorSession 

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

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

type RootChainBlockFinalized 

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

RootChainBlockFinalized represents a BlockFinalized event raised by the RootChain contract.

type RootChainBlockFinalizedIterator 

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

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

func (*RootChainBlockFinalizedIterator) Close 

func (it *RootChainBlockFinalizedIterator) Close() error

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

func (*RootChainBlockFinalizedIterator) Error 

func (it *RootChainBlockFinalizedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainBlockFinalizedIterator) Next 

func (it *RootChainBlockFinalizedIterator) 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 RootChainBlockSubmitted 

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

RootChainBlockSubmitted represents a BlockSubmitted event raised by the RootChain contract.

type RootChainBlockSubmittedIterator 

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

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

func (*RootChainBlockSubmittedIterator) Close 

func (it *RootChainBlockSubmittedIterator) Close() error

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

func (*RootChainBlockSubmittedIterator) Error 

func (it *RootChainBlockSubmittedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainBlockSubmittedIterator) Next 

func (it *RootChainBlockSubmittedIterator) 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 RootChainCaller 

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

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

func NewRootChainCaller 

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

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

func (*RootChainCaller) COSTERO 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) COSTERU 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) COSTNRB 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) COSTORB 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) COSTURB 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) COSTURBPREPARE 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) CPCOMPUTATION 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) CPEXIT 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) CPWITHHOLDING 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) CurrentFork 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) Development 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) EROIdToFinalize 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) EROs 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) ERUIdToFinalize 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) ERUs 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) EpochHandler 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) EtherToken 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) FirstFilledORENumber 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) FirstNonEmptyRequestEpoch 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) Forked 

func (_RootChain *RootChainCaller) Forked(opts *bind.CallOpts, _forkNumber *big.Int) (bool, error)

Forked is a free data retrieval call binding the contract method 0xce8a2bc2.

Solidity: function forked(uint256 _forkNumber) constant returns(bool result)

func (*RootChainCaller) Forks 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) GetBlock 

func (_RootChain *RootChainCaller) GetBlock(opts *bind.CallOpts, forkNumber *big.Int, blockNumber *big.Int) (DataPlasmaBlock, error)

GetBlock is a free data retrieval call binding the contract method 0x4a44bdb8.

Solidity: function getBlock(uint256 forkNumber, uint256 blockNumber) constant returns(DataPlasmaBlock)

func (*RootChainCaller) GetBlockFinalizedAt 

func (_RootChain *RootChainCaller) GetBlockFinalizedAt(opts *bind.CallOpts, forkNumber *big.Int, blockNumber *big.Int) (*big.Int, error)

GetBlockFinalizedAt is a free data retrieval call binding the contract method 0x5b884682.

Solidity: function getBlockFinalizedAt(uint256 forkNumber, uint256 blockNumber) constant returns(uint256)

func (*RootChainCaller) GetEROBytes 

func (_RootChain *RootChainCaller) GetEROBytes(opts *bind.CallOpts, _requestId *big.Int) ([]byte, error)

GetEROBytes is a free data retrieval call binding the contract method 0xd1723a96.

Solidity: function getEROBytes(uint256 _requestId) constant returns(bytes out)

func (*RootChainCaller) GetEpoch 

func (_RootChain *RootChainCaller) GetEpoch(opts *bind.CallOpts, forkNumber *big.Int, epochNumber *big.Int) (DataEpoch, error)

GetEpoch is a free data retrieval call binding the contract method 0x2b25a38b.

Solidity: function getEpoch(uint256 forkNumber, uint256 epochNumber) constant returns(DataEpoch epoch)

func (*RootChainCaller) GetLastEpoch 

func (_RootChain *RootChainCaller) GetLastEpoch(opts *bind.CallOpts) (DataEpoch, error)

GetLastEpoch is a free data retrieval call binding the contract method 0x398bac63.

Solidity: function getLastEpoch() constant returns(DataEpoch)

func (*RootChainCaller) GetLastFinalizedBlock 

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

GetLastFinalizedBlock is a free data retrieval call binding the contract method 0xd636857e.

Solidity: function getLastFinalizedBlock(uint256 forkNumber) constant returns(uint256)

func (*RootChainCaller) GetLastFinalizedEpoch 

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

GetLastFinalizedEpoch is a free data retrieval call binding the contract method 0x019dc099.

Solidity: function getLastFinalizedEpoch(uint256 forkNumber) constant returns(uint256)

func (*RootChainCaller) GetNumEROs 

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

GetNumEROs is a free data retrieval call binding the contract method 0xb540adba.

Solidity: function getNumEROs() constant returns(uint256)

func (*RootChainCaller) GetNumORBs 

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

GetNumORBs is a free data retrieval call binding the contract method 0xea0c73f6.

Solidity: function getNumORBs() constant returns(uint256)

func (*RootChainCaller) GetRequestFinalized 

func (_RootChain *RootChainCaller) GetRequestFinalized(opts *bind.CallOpts, _requestId *big.Int, _userActivated bool) (bool, error)

GetRequestFinalized is a free data retrieval call binding the contract method 0xf28a7afa.

Solidity: function getRequestFinalized(uint256 _requestId, bool _userActivated) constant returns(bool finalized)

func (*RootChainCaller) IsMapper 

func (_RootChain *RootChainCaller) IsMapper(opts *bind.CallOpts, account common.Address) (bool, error)

IsMapper is a free data retrieval call binding the contract method 0xc0c49c2a.

Solidity: function isMapper(address account) constant returns(bool)

func (*RootChainCaller) IsRootChain 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) IsSubmitter 

func (_RootChain *RootChainCaller) IsSubmitter(opts *bind.CallOpts, account common.Address) (bool, error)

IsSubmitter is a free data retrieval call binding the contract method 0xa926fdbc.

Solidity: function isSubmitter(address account) constant returns(bool)

func (*RootChainCaller) LastAppliedBlockNumber 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) LastAppliedEpochNumber 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) LastAppliedForkNumber 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) LastBlock 

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

LastBlock is a free data retrieval call binding the contract method 0x1ec2042b.

Solidity: function lastBlock(uint256 forkNumber) constant returns(uint256 lastBlock)

func (*RootChainCaller) LastEpoch 

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

LastEpoch is a free data retrieval call binding the contract method 0x11e4c914.

Solidity: function lastEpoch(uint256 forkNumber) constant returns(uint256 lastBlock)

func (*RootChainCaller) LastNonEmptyRequestEpoch 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) MAXREQUESTS 

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

MAXREQUESTS is a free data retrieval call binding the contract method 0x93521222.

Solidity: function MAX_REQUESTS() constant returns(uint256 maxRequests)

func (*RootChainCaller) NRELength 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) NULLADDRESS 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) NumEnterForORB 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) ORBs 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) Operator 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) PREPARETIMEOUT 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) REQUESTGAS 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) RequestableContracts 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) SeigManager 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) SubmitHandler 

func (_RootChain *RootChainCaller) 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 (*RootChainCaller) URBs 

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

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

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

func (*RootChainCallerRaw) Call 

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

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

type RootChainCallerSession 

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

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

func (*RootChainCallerSession) COSTERO 

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

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

Solidity: function COST_ERO() constant returns(uint256)

func (*RootChainCallerSession) COSTERU 

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

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

Solidity: function COST_ERU() constant returns(uint256)

func (*RootChainCallerSession) COSTNRB 

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

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

Solidity: function COST_NRB() constant returns(uint256)

func (*RootChainCallerSession) COSTORB 

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

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

Solidity: function COST_ORB() constant returns(uint256)

func (*RootChainCallerSession) COSTURB 

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

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

Solidity: function COST_URB() constant returns(uint256)

func (*RootChainCallerSession) COSTURBPREPARE 

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

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

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

Solidity: function CP_COMPUTATION() constant returns(uint256)

func (*RootChainCallerSession) CPEXIT 

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

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

Solidity: function CP_EXIT() constant returns(uint256)

func (*RootChainCallerSession) CPWITHHOLDING 

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

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

Solidity: function CP_WITHHOLDING() constant returns(uint256)

func (*RootChainCallerSession) CurrentFork 

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

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

Solidity: function currentFork() constant returns(uint256)

func (*RootChainCallerSession) Development 

func (_RootChain *RootChainCallerSession) Development() (bool, error)

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

Solidity: function development() constant returns(bool)

func (*RootChainCallerSession) EROIdToFinalize 

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

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

Solidity: function EROIdToFinalize() constant returns(uint256)

func (*RootChainCallerSession) EROs 

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

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

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

Solidity: function ERUIdToFinalize() constant returns(uint256)

func (*RootChainCallerSession) ERUs 

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

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

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

Solidity: function epochHandler() constant returns(address)

func (*RootChainCallerSession) EtherToken 

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

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

Solidity: function etherToken() constant returns(address)

func (*RootChainCallerSession) FirstFilledORENumber 

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

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

func (_RootChain *RootChainCallerSession) Forked(_forkNumber *big.Int) (bool, error)

Forked is a free data retrieval call binding the contract method 0xce8a2bc2.

Solidity: function forked(uint256 _forkNumber) constant returns(bool result)

func (*RootChainCallerSession) Forks 

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

func (_RootChain *RootChainCallerSession) GetBlock(forkNumber *big.Int, blockNumber *big.Int) (DataPlasmaBlock, error)

GetBlock is a free data retrieval call binding the contract method 0x4a44bdb8.

Solidity: function getBlock(uint256 forkNumber, uint256 blockNumber) constant returns(DataPlasmaBlock)

func (*RootChainCallerSession) GetBlockFinalizedAt 

func (_RootChain *RootChainCallerSession) GetBlockFinalizedAt(forkNumber *big.Int, blockNumber *big.Int) (*big.Int, error)

GetBlockFinalizedAt is a free data retrieval call binding the contract method 0x5b884682.

Solidity: function getBlockFinalizedAt(uint256 forkNumber, uint256 blockNumber) constant returns(uint256)

func (*RootChainCallerSession) GetEROBytes 

func (_RootChain *RootChainCallerSession) GetEROBytes(_requestId *big.Int) ([]byte, error)

GetEROBytes is a free data retrieval call binding the contract method 0xd1723a96.

Solidity: function getEROBytes(uint256 _requestId) constant returns(bytes out)

func (*RootChainCallerSession) GetEpoch 

func (_RootChain *RootChainCallerSession) GetEpoch(forkNumber *big.Int, epochNumber *big.Int) (DataEpoch, error)

GetEpoch is a free data retrieval call binding the contract method 0x2b25a38b.

Solidity: function getEpoch(uint256 forkNumber, uint256 epochNumber) constant returns(DataEpoch epoch)

func (*RootChainCallerSession) GetLastEpoch 

func (_RootChain *RootChainCallerSession) GetLastEpoch() (DataEpoch, error)

GetLastEpoch is a free data retrieval call binding the contract method 0x398bac63.

Solidity: function getLastEpoch() constant returns(DataEpoch)

func (*RootChainCallerSession) GetLastFinalizedBlock 

func (_RootChain *RootChainCallerSession) GetLastFinalizedBlock(forkNumber *big.Int) (*big.Int, error)

GetLastFinalizedBlock is a free data retrieval call binding the contract method 0xd636857e.

Solidity: function getLastFinalizedBlock(uint256 forkNumber) constant returns(uint256)

func (*RootChainCallerSession) GetLastFinalizedEpoch 

func (_RootChain *RootChainCallerSession) GetLastFinalizedEpoch(forkNumber *big.Int) (*big.Int, error)

GetLastFinalizedEpoch is a free data retrieval call binding the contract method 0x019dc099.

Solidity: function getLastFinalizedEpoch(uint256 forkNumber) constant returns(uint256)

func (*RootChainCallerSession) GetNumEROs 

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

GetNumEROs is a free data retrieval call binding the contract method 0xb540adba.

Solidity: function getNumEROs() constant returns(uint256)

func (*RootChainCallerSession) GetNumORBs 

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

GetNumORBs is a free data retrieval call binding the contract method 0xea0c73f6.

Solidity: function getNumORBs() constant returns(uint256)

func (*RootChainCallerSession) GetRequestFinalized 

func (_RootChain *RootChainCallerSession) GetRequestFinalized(_requestId *big.Int, _userActivated bool) (bool, error)

GetRequestFinalized is a free data retrieval call binding the contract method 0xf28a7afa.

Solidity: function getRequestFinalized(uint256 _requestId, bool _userActivated) constant returns(bool finalized)

func (*RootChainCallerSession) IsMapper 

func (_RootChain *RootChainCallerSession) IsMapper(account common.Address) (bool, error)

IsMapper is a free data retrieval call binding the contract method 0xc0c49c2a.

Solidity: function isMapper(address account) constant returns(bool)

func (*RootChainCallerSession) IsRootChain 

func (_RootChain *RootChainCallerSession) IsRootChain() (bool, error)

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

Solidity: function isRootChain() constant returns(bool)

func (*RootChainCallerSession) IsSubmitter 

func (_RootChain *RootChainCallerSession) IsSubmitter(account common.Address) (bool, error)

IsSubmitter is a free data retrieval call binding the contract method 0xa926fdbc.

Solidity: function isSubmitter(address account) constant returns(bool)

func (*RootChainCallerSession) LastAppliedBlockNumber 

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

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

Solidity: function lastAppliedBlockNumber() constant returns(uint256)

func (*RootChainCallerSession) LastAppliedEpochNumber 

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

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

Solidity: function lastAppliedEpochNumber() constant returns(uint256)

func (*RootChainCallerSession) LastAppliedForkNumber 

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

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

Solidity: function lastAppliedForkNumber() constant returns(uint256)

func (*RootChainCallerSession) LastBlock 

func (_RootChain *RootChainCallerSession) LastBlock(forkNumber *big.Int) (*big.Int, error)

LastBlock is a free data retrieval call binding the contract method 0x1ec2042b.

Solidity: function lastBlock(uint256 forkNumber) constant returns(uint256 lastBlock)

func (*RootChainCallerSession) LastEpoch 

func (_RootChain *RootChainCallerSession) LastEpoch(forkNumber *big.Int) (*big.Int, error)

LastEpoch is a free data retrieval call binding the contract method 0x11e4c914.

Solidity: function lastEpoch(uint256 forkNumber) constant returns(uint256 lastBlock)

func (*RootChainCallerSession) LastNonEmptyRequestEpoch 

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

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

MAXREQUESTS is a free data retrieval call binding the contract method 0x93521222.

Solidity: function MAX_REQUESTS() constant returns(uint256 maxRequests)

func (*RootChainCallerSession) NRELength 

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

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

Solidity: function NRELength() constant returns(uint256)

func (*RootChainCallerSession) NULLADDRESS 

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

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

Solidity: function NULL_ADDRESS() constant returns(address)

func (*RootChainCallerSession) NumEnterForORB 

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

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

Solidity: function numEnterForORB() constant returns(uint256)

func (*RootChainCallerSession) ORBs 

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

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

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

Solidity: function operator() constant returns(address)

func (*RootChainCallerSession) PREPARETIMEOUT 

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

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

Solidity: function PREPARE_TIMEOUT() constant returns(uint256)

func (*RootChainCallerSession) REQUESTGAS 

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

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

Solidity: function REQUEST_GAS() constant returns(uint256)

func (*RootChainCallerSession) RequestableContracts 

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

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

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

Solidity: function seigManager() constant returns(address)

func (*RootChainCallerSession) SubmitHandler 

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

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

Solidity: function submitHandler() constant returns(address)

func (*RootChainCallerSession) URBs 

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

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

RootChainERUCreated represents a ERUCreated event raised by the RootChain contract.

type RootChainERUCreatedIterator 

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

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

func (*RootChainERUCreatedIterator) Close 

func (it *RootChainERUCreatedIterator) Close() error

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

func (*RootChainERUCreatedIterator) Error 

func (it *RootChainERUCreatedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainERUCreatedIterator) Next 

func (it *RootChainERUCreatedIterator) 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 RootChainEpochFilled 

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

RootChainEpochFilled represents a EpochFilled event raised by the RootChain contract.

type RootChainEpochFilledIterator 

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

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

func (*RootChainEpochFilledIterator) Close 

func (it *RootChainEpochFilledIterator) Close() error

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

func (*RootChainEpochFilledIterator) Error 

func (it *RootChainEpochFilledIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainEpochFilledIterator) Next 

func (it *RootChainEpochFilledIterator) 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 RootChainEpochFilling 

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

RootChainEpochFilling represents a EpochFilling event raised by the RootChain contract.

type RootChainEpochFillingIterator 

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

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

func (*RootChainEpochFillingIterator) Close 

func (it *RootChainEpochFillingIterator) Close() error

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

func (*RootChainEpochFillingIterator) Error 

func (it *RootChainEpochFillingIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainEpochFillingIterator) Next 

func (it *RootChainEpochFillingIterator) 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 RootChainEpochFinalized 

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

RootChainEpochFinalized represents a EpochFinalized event raised by the RootChain contract.

type RootChainEpochFinalizedIterator 

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

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

func (*RootChainEpochFinalizedIterator) Close 

func (it *RootChainEpochFinalizedIterator) Close() error

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

func (*RootChainEpochFinalizedIterator) Error 

func (it *RootChainEpochFinalizedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainEpochFinalizedIterator) Next 

func (it *RootChainEpochFinalizedIterator) 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 RootChainEpochPrepared 

type RootChainEpochPrepared 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
}

RootChainEpochPrepared represents a EpochPrepared event raised by the RootChain contract.

type RootChainEpochPreparedIterator 

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

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

func (*RootChainEpochPreparedIterator) Close 

func (it *RootChainEpochPreparedIterator) Close() error

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

func (*RootChainEpochPreparedIterator) Error 

func (it *RootChainEpochPreparedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainEpochPreparedIterator) Next 

func (it *RootChainEpochPreparedIterator) 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 RootChainEpochRebased 

type RootChainEpochRebased 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
}

RootChainEpochRebased represents a EpochRebased event raised by the RootChain contract.

type RootChainEpochRebasedIterator 

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

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

func (*RootChainEpochRebasedIterator) Close 

func (it *RootChainEpochRebasedIterator) Close() error

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

func (*RootChainEpochRebasedIterator) Error 

func (it *RootChainEpochRebasedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainEpochRebasedIterator) Next 

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

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

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

func NewRootChainFilterer 

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

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

func (*RootChainFilterer) FilterBlockFinalized 

func (_RootChain *RootChainFilterer) FilterBlockFinalized(opts *bind.FilterOpts) (*RootChainBlockFinalizedIterator, error)

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

Solidity: event BlockFinalized(uint256 forkNumber, uint256 blockNumber)

func (*RootChainFilterer) FilterBlockSubmitted 

func (_RootChain *RootChainFilterer) FilterBlockSubmitted(opts *bind.FilterOpts) (*RootChainBlockSubmittedIterator, 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 (*RootChainFilterer) FilterERUCreated 

func (_RootChain *RootChainFilterer) FilterERUCreated(opts *bind.FilterOpts) (*RootChainERUCreatedIterator, 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 (*RootChainFilterer) FilterEpochFilled 

func (_RootChain *RootChainFilterer) FilterEpochFilled(opts *bind.FilterOpts) (*RootChainEpochFilledIterator, error)

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

Solidity: event EpochFilled(uint256 forkNumber, uint256 epochNumber)

func (*RootChainFilterer) FilterEpochFilling 

func (_RootChain *RootChainFilterer) FilterEpochFilling(opts *bind.FilterOpts) (*RootChainEpochFillingIterator, error)

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

Solidity: event EpochFilling(uint256 forkNumber, uint256 epochNumber)

func (*RootChainFilterer) FilterEpochFinalized 

func (_RootChain *RootChainFilterer) FilterEpochFinalized(opts *bind.FilterOpts) (*RootChainEpochFinalizedIterator, 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 (*RootChainFilterer) FilterEpochPrepared 

func (_RootChain *RootChainFilterer) FilterEpochPrepared(opts *bind.FilterOpts) (*RootChainEpochPreparedIterator, 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 (*RootChainFilterer) FilterEpochRebased 

func (_RootChain *RootChainFilterer) FilterEpochRebased(opts *bind.FilterOpts) (*RootChainEpochRebasedIterator, 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 (*RootChainFilterer) FilterForked 

func (_RootChain *RootChainFilterer) FilterForked(opts *bind.FilterOpts) (*RootChainForkedIterator, error)

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

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

func (*RootChainFilterer) FilterMapperAdded 

func (_RootChain *RootChainFilterer) FilterMapperAdded(opts *bind.FilterOpts, account []common.Address) (*RootChainMapperAddedIterator, error)

FilterMapperAdded is a free log retrieval operation binding the contract event 0xa199526a01dbcba68aa3ab9d7d06c6692c83fb1a8bcf2184e6d94ad34f5aaf95.

Solidity: event MapperAdded(address indexed account)

func (*RootChainFilterer) FilterMapperRemoved 

func (_RootChain *RootChainFilterer) FilterMapperRemoved(opts *bind.FilterOpts, account []common.Address) (*RootChainMapperRemovedIterator, error)

FilterMapperRemoved is a free log retrieval operation binding the contract event 0xf012269e1b6bb33c7800e7e54167ddd74f0ae7244108030b6876821d3779822f.

Solidity: event MapperRemoved(address indexed account)

func (*RootChainFilterer) FilterOperatorChanged 

func (_RootChain *RootChainFilterer) FilterOperatorChanged(opts *bind.FilterOpts) (*RootChainOperatorChangedIterator, error)

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

Solidity: event OperatorChanged(address _newOperator)

func (*RootChainFilterer) FilterRequestApplied 

func (_RootChain *RootChainFilterer) FilterRequestApplied(opts *bind.FilterOpts) (*RootChainRequestAppliedIterator, error)

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

Solidity: event RequestApplied(uint256 requestId, bool userActivated)

func (*RootChainFilterer) FilterRequestChallenged 

func (_RootChain *RootChainFilterer) FilterRequestChallenged(opts *bind.FilterOpts) (*RootChainRequestChallengedIterator, error)

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

Solidity: event RequestChallenged(uint256 requestId, bool userActivated)

func (*RootChainFilterer) FilterRequestCreated 

func (_RootChain *RootChainFilterer) FilterRequestCreated(opts *bind.FilterOpts) (*RootChainRequestCreatedIterator, 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 (*RootChainFilterer) FilterRequestFinalized 

func (_RootChain *RootChainFilterer) FilterRequestFinalized(opts *bind.FilterOpts) (*RootChainRequestFinalizedIterator, error)

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

Solidity: event RequestFinalized(uint256 requestId, bool userActivated)

func (*RootChainFilterer) FilterRequestableContractMapped 

func (_RootChain *RootChainFilterer) FilterRequestableContractMapped(opts *bind.FilterOpts) (*RootChainRequestableContractMappedIterator, error)

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

Solidity: event RequestableContractMapped(address contractInRootchain, address contractInChildchain)

func (*RootChainFilterer) FilterSessionTimeout 

func (_RootChain *RootChainFilterer) FilterSessionTimeout(opts *bind.FilterOpts) (*RootChainSessionTimeoutIterator, error)

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

Solidity: event SessionTimeout(bool userActivated)

func (*RootChainFilterer) FilterSubmitterAdded 

func (_RootChain *RootChainFilterer) FilterSubmitterAdded(opts *bind.FilterOpts, account []common.Address) (*RootChainSubmitterAddedIterator, error)

FilterSubmitterAdded is a free log retrieval operation binding the contract event 0xb079bc2cbde1f186e0b351d4a87c4597e3ed098f571548617449e73506428d8b.

Solidity: event SubmitterAdded(address indexed account)

func (*RootChainFilterer) FilterSubmitterRemoved 

func (_RootChain *RootChainFilterer) FilterSubmitterRemoved(opts *bind.FilterOpts, account []common.Address) (*RootChainSubmitterRemovedIterator, error)

FilterSubmitterRemoved is a free log retrieval operation binding the contract event 0xf84a004e1673d2f349a7c93c72b3794b8eba6d2f9338044d8c8cd260e51a57a1.

Solidity: event SubmitterRemoved(address indexed account)

func (*RootChainFilterer) ParseBlockFinalized 

func (_RootChain *RootChainFilterer) ParseBlockFinalized(log types.Log) (*RootChainBlockFinalized, error)

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

Solidity: event BlockFinalized(uint256 forkNumber, uint256 blockNumber)

func (*RootChainFilterer) ParseBlockSubmitted 

func (_RootChain *RootChainFilterer) ParseBlockSubmitted(log types.Log) (*RootChainBlockSubmitted, 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 (*RootChainFilterer) ParseERUCreated 

func (_RootChain *RootChainFilterer) ParseERUCreated(log types.Log) (*RootChainERUCreated, 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 (*RootChainFilterer) ParseEpochFilled 

func (_RootChain *RootChainFilterer) ParseEpochFilled(log types.Log) (*RootChainEpochFilled, error)

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

Solidity: event EpochFilled(uint256 forkNumber, uint256 epochNumber)

func (*RootChainFilterer) ParseEpochFilling 

func (_RootChain *RootChainFilterer) ParseEpochFilling(log types.Log) (*RootChainEpochFilling, error)

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

Solidity: event EpochFilling(uint256 forkNumber, uint256 epochNumber)

func (*RootChainFilterer) ParseEpochFinalized 

func (_RootChain *RootChainFilterer) ParseEpochFinalized(log types.Log) (*RootChainEpochFinalized, error)

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

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

func (*RootChainFilterer) ParseEpochPrepared 

func (_RootChain *RootChainFilterer) ParseEpochPrepared(log types.Log) (*RootChainEpochPrepared, 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 (*RootChainFilterer) ParseEpochRebased 

func (_RootChain *RootChainFilterer) ParseEpochRebased(log types.Log) (*RootChainEpochRebased, 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 (*RootChainFilterer) ParseForked 

func (_RootChain *RootChainFilterer) ParseForked(log types.Log) (*RootChainForked, error)

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

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

func (*RootChainFilterer) ParseMapperAdded 

func (_RootChain *RootChainFilterer) ParseMapperAdded(log types.Log) (*RootChainMapperAdded, error)

ParseMapperAdded is a log parse operation binding the contract event 0xa199526a01dbcba68aa3ab9d7d06c6692c83fb1a8bcf2184e6d94ad34f5aaf95.

Solidity: event MapperAdded(address indexed account)

func (*RootChainFilterer) ParseMapperRemoved 

func (_RootChain *RootChainFilterer) ParseMapperRemoved(log types.Log) (*RootChainMapperRemoved, error)

ParseMapperRemoved is a log parse operation binding the contract event 0xf012269e1b6bb33c7800e7e54167ddd74f0ae7244108030b6876821d3779822f.

Solidity: event MapperRemoved(address indexed account)

func (*RootChainFilterer) ParseOperatorChanged 

func (_RootChain *RootChainFilterer) ParseOperatorChanged(log types.Log) (*RootChainOperatorChanged, error)

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

Solidity: event OperatorChanged(address _newOperator)

func (*RootChainFilterer) ParseRequestApplied 

func (_RootChain *RootChainFilterer) ParseRequestApplied(log types.Log) (*RootChainRequestApplied, error)

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

Solidity: event RequestApplied(uint256 requestId, bool userActivated)

func (*RootChainFilterer) ParseRequestChallenged 

func (_RootChain *RootChainFilterer) ParseRequestChallenged(log types.Log) (*RootChainRequestChallenged, error)

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

Solidity: event RequestChallenged(uint256 requestId, bool userActivated)

func (*RootChainFilterer) ParseRequestCreated 

func (_RootChain *RootChainFilterer) ParseRequestCreated(log types.Log) (*RootChainRequestCreated, 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 (*RootChainFilterer) ParseRequestFinalized 

func (_RootChain *RootChainFilterer) ParseRequestFinalized(log types.Log) (*RootChainRequestFinalized, error)

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

Solidity: event RequestFinalized(uint256 requestId, bool userActivated)

func (*RootChainFilterer) ParseRequestableContractMapped 

func (_RootChain *RootChainFilterer) ParseRequestableContractMapped(log types.Log) (*RootChainRequestableContractMapped, error)

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

Solidity: event RequestableContractMapped(address contractInRootchain, address contractInChildchain)

func (*RootChainFilterer) ParseSessionTimeout 

func (_RootChain *RootChainFilterer) ParseSessionTimeout(log types.Log) (*RootChainSessionTimeout, error)

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

Solidity: event SessionTimeout(bool userActivated)

func (*RootChainFilterer) ParseSubmitterAdded 

func (_RootChain *RootChainFilterer) ParseSubmitterAdded(log types.Log) (*RootChainSubmitterAdded, error)

ParseSubmitterAdded is a log parse operation binding the contract event 0xb079bc2cbde1f186e0b351d4a87c4597e3ed098f571548617449e73506428d8b.

Solidity: event SubmitterAdded(address indexed account)

func (*RootChainFilterer) ParseSubmitterRemoved 

func (_RootChain *RootChainFilterer) ParseSubmitterRemoved(log types.Log) (*RootChainSubmitterRemoved, error)

ParseSubmitterRemoved is a log parse operation binding the contract event 0xf84a004e1673d2f349a7c93c72b3794b8eba6d2f9338044d8c8cd260e51a57a1.

Solidity: event SubmitterRemoved(address indexed account)

func (*RootChainFilterer) WatchBlockFinalized 

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

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

Solidity: event BlockFinalized(uint256 forkNumber, uint256 blockNumber)

func (*RootChainFilterer) WatchBlockSubmitted 

func (_RootChain *RootChainFilterer) WatchBlockSubmitted(opts *bind.WatchOpts, sink chan<- *RootChainBlockSubmitted) (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 (*RootChainFilterer) WatchERUCreated 

func (_RootChain *RootChainFilterer) WatchERUCreated(opts *bind.WatchOpts, sink chan<- *RootChainERUCreated) (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 (*RootChainFilterer) WatchEpochFilled 

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

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

Solidity: event EpochFilled(uint256 forkNumber, uint256 epochNumber)

func (*RootChainFilterer) WatchEpochFilling 

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

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

Solidity: event EpochFilling(uint256 forkNumber, uint256 epochNumber)

func (*RootChainFilterer) WatchEpochFinalized 

func (_RootChain *RootChainFilterer) WatchEpochFinalized(opts *bind.WatchOpts, sink chan<- *RootChainEpochFinalized) (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 (*RootChainFilterer) WatchEpochPrepared 

func (_RootChain *RootChainFilterer) WatchEpochPrepared(opts *bind.WatchOpts, sink chan<- *RootChainEpochPrepared) (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 (*RootChainFilterer) WatchEpochRebased 

func (_RootChain *RootChainFilterer) WatchEpochRebased(opts *bind.WatchOpts, sink chan<- *RootChainEpochRebased) (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 (*RootChainFilterer) WatchForked 

func (_RootChain *RootChainFilterer) WatchForked(opts *bind.WatchOpts, sink chan<- *RootChainForked) (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 (*RootChainFilterer) WatchMapperAdded 

func (_RootChain *RootChainFilterer) WatchMapperAdded(opts *bind.WatchOpts, sink chan<- *RootChainMapperAdded, account []common.Address) (event.Subscription, error)

WatchMapperAdded is a free log subscription operation binding the contract event 0xa199526a01dbcba68aa3ab9d7d06c6692c83fb1a8bcf2184e6d94ad34f5aaf95.

Solidity: event MapperAdded(address indexed account)

func (*RootChainFilterer) WatchMapperRemoved 

func (_RootChain *RootChainFilterer) WatchMapperRemoved(opts *bind.WatchOpts, sink chan<- *RootChainMapperRemoved, account []common.Address) (event.Subscription, error)

WatchMapperRemoved is a free log subscription operation binding the contract event 0xf012269e1b6bb33c7800e7e54167ddd74f0ae7244108030b6876821d3779822f.

Solidity: event MapperRemoved(address indexed account)

func (*RootChainFilterer) WatchOperatorChanged 

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

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

Solidity: event OperatorChanged(address _newOperator)

func (*RootChainFilterer) WatchRequestApplied 

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

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

Solidity: event RequestApplied(uint256 requestId, bool userActivated)

func (*RootChainFilterer) WatchRequestChallenged 

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

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

Solidity: event RequestChallenged(uint256 requestId, bool userActivated)

func (*RootChainFilterer) WatchRequestCreated 

func (_RootChain *RootChainFilterer) WatchRequestCreated(opts *bind.WatchOpts, sink chan<- *RootChainRequestCreated) (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 (*RootChainFilterer) WatchRequestFinalized 

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

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

Solidity: event RequestFinalized(uint256 requestId, bool userActivated)

func (*RootChainFilterer) WatchRequestableContractMapped 

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

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

Solidity: event RequestableContractMapped(address contractInRootchain, address contractInChildchain)

func (*RootChainFilterer) WatchSessionTimeout 

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

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

Solidity: event SessionTimeout(bool userActivated)

func (*RootChainFilterer) WatchSubmitterAdded 

func (_RootChain *RootChainFilterer) WatchSubmitterAdded(opts *bind.WatchOpts, sink chan<- *RootChainSubmitterAdded, account []common.Address) (event.Subscription, error)

WatchSubmitterAdded is a free log subscription operation binding the contract event 0xb079bc2cbde1f186e0b351d4a87c4597e3ed098f571548617449e73506428d8b.

Solidity: event SubmitterAdded(address indexed account)

func (*RootChainFilterer) WatchSubmitterRemoved 

func (_RootChain *RootChainFilterer) WatchSubmitterRemoved(opts *bind.WatchOpts, sink chan<- *RootChainSubmitterRemoved, account []common.Address) (event.Subscription, error)

WatchSubmitterRemoved is a free log subscription operation binding the contract event 0xf84a004e1673d2f349a7c93c72b3794b8eba6d2f9338044d8c8cd260e51a57a1.

Solidity: event SubmitterRemoved(address indexed account)

type RootChainForked 

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

RootChainForked represents a Forked event raised by the RootChain contract.

type RootChainForkedIterator 

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

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

func (*RootChainForkedIterator) Close 

func (it *RootChainForkedIterator) Close() error

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

func (*RootChainForkedIterator) Error 

func (it *RootChainForkedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainForkedIterator) Next 

func (it *RootChainForkedIterator) 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 RootChainMapperAdded 

type RootChainMapperAdded struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

RootChainMapperAdded represents a MapperAdded event raised by the RootChain contract.

type RootChainMapperAddedIterator 

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

RootChainMapperAddedIterator is returned from FilterMapperAdded and is used to iterate over the raw logs and unpacked data for MapperAdded events raised by the RootChain contract.

func (*RootChainMapperAddedIterator) Close 

func (it *RootChainMapperAddedIterator) Close() error

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

func (*RootChainMapperAddedIterator) Error 

func (it *RootChainMapperAddedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainMapperAddedIterator) Next 

func (it *RootChainMapperAddedIterator) 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 RootChainMapperRemoved 

type RootChainMapperRemoved struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

RootChainMapperRemoved represents a MapperRemoved event raised by the RootChain contract.

type RootChainMapperRemovedIterator 

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

RootChainMapperRemovedIterator is returned from FilterMapperRemoved and is used to iterate over the raw logs and unpacked data for MapperRemoved events raised by the RootChain contract.

func (*RootChainMapperRemovedIterator) Close 

func (it *RootChainMapperRemovedIterator) Close() error

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

func (*RootChainMapperRemovedIterator) Error 

func (it *RootChainMapperRemovedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainMapperRemovedIterator) Next 

func (it *RootChainMapperRemovedIterator) 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 RootChainOperatorChanged 

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

RootChainOperatorChanged represents a OperatorChanged event raised by the RootChain contract.

type RootChainOperatorChangedIterator 

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

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

func (*RootChainOperatorChangedIterator) Close 

func (it *RootChainOperatorChangedIterator) Close() error

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

func (*RootChainOperatorChangedIterator) Error 

func (it *RootChainOperatorChangedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainOperatorChangedIterator) Next 

func (it *RootChainOperatorChangedIterator) 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 RootChainRaw 

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

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

func (*RootChainRaw) Call 

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

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

func (*RootChainRaw) Transact 

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

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

func (*RootChainRaw) Transfer 

func (_RootChain *RootChainRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

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

type RootChainRequestApplied 

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

RootChainRequestApplied represents a RequestApplied event raised by the RootChain contract.

type RootChainRequestAppliedIterator 

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

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

func (*RootChainRequestAppliedIterator) Close 

func (it *RootChainRequestAppliedIterator) Close() error

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

func (*RootChainRequestAppliedIterator) Error 

func (it *RootChainRequestAppliedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainRequestAppliedIterator) Next 

func (it *RootChainRequestAppliedIterator) 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 RootChainRequestChallenged 

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

RootChainRequestChallenged represents a RequestChallenged event raised by the RootChain contract.

type RootChainRequestChallengedIterator 

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

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

func (*RootChainRequestChallengedIterator) Close 

func (it *RootChainRequestChallengedIterator) Close() error

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

func (*RootChainRequestChallengedIterator) Error 

func (it *RootChainRequestChallengedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainRequestChallengedIterator) Next 

func (it *RootChainRequestChallengedIterator) 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 RootChainRequestCreated 

type RootChainRequestCreated 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
}

RootChainRequestCreated represents a RequestCreated event raised by the RootChain contract.

type RootChainRequestCreatedIterator 

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

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

func (*RootChainRequestCreatedIterator) Close 

func (it *RootChainRequestCreatedIterator) Close() error

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

func (*RootChainRequestCreatedIterator) Error 

func (it *RootChainRequestCreatedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainRequestCreatedIterator) Next 

func (it *RootChainRequestCreatedIterator) 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 RootChainRequestFinalized 

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

RootChainRequestFinalized represents a RequestFinalized event raised by the RootChain contract.

type RootChainRequestFinalizedIterator 

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

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

func (*RootChainRequestFinalizedIterator) Close 

func (it *RootChainRequestFinalizedIterator) Close() error

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

func (*RootChainRequestFinalizedIterator) Error 

func (it *RootChainRequestFinalizedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainRequestFinalizedIterator) Next 

func (it *RootChainRequestFinalizedIterator) 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 RootChainRequestableContractMapped 

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

RootChainRequestableContractMapped represents a RequestableContractMapped event raised by the RootChain contract.

type RootChainRequestableContractMappedIterator 

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

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

func (*RootChainRequestableContractMappedIterator) Close 

func (it *RootChainRequestableContractMappedIterator) Close() error

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

func (*RootChainRequestableContractMappedIterator) Error 

func (it *RootChainRequestableContractMappedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainRequestableContractMappedIterator) Next 

func (it *RootChainRequestableContractMappedIterator) 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 RootChainSession 

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

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

func (*RootChainSession) AddMapper 

func (_RootChain *RootChainSession) AddMapper(account common.Address) (*types.Transaction, error)

AddMapper is a paid mutator transaction binding the contract method 0x80e3e81d.

Solidity: function addMapper(address account) returns()

func (*RootChainSession) AddSubmitter 

func (_RootChain *RootChainSession) AddSubmitter(account common.Address) (*types.Transaction, error)

AddSubmitter is a paid mutator transaction binding the contract method 0x072900f9.

Solidity: function addSubmitter(address account) returns()

func (*RootChainSession) COSTERO 

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

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

Solidity: function COST_ERO() constant returns(uint256)

func (*RootChainSession) COSTERU 

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

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

Solidity: function COST_ERU() constant returns(uint256)

func (*RootChainSession) COSTNRB 

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

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

Solidity: function COST_NRB() constant returns(uint256)

func (*RootChainSession) COSTORB 

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

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

Solidity: function COST_ORB() constant returns(uint256)

func (*RootChainSession) COSTURB 

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

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

Solidity: function COST_URB() constant returns(uint256)

func (*RootChainSession) COSTURBPREPARE 

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

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

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

Solidity: function CP_COMPUTATION() constant returns(uint256)

func (*RootChainSession) CPEXIT 

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

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

Solidity: function CP_EXIT() constant returns(uint256)

func (*RootChainSession) CPWITHHOLDING 

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

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

Solidity: function CP_WITHHOLDING() constant returns(uint256)

func (*RootChainSession) ChallengeExit 

func (_RootChain *RootChainSession) ChallengeExit(_forkNumber *big.Int, _blockNumber *big.Int, _index *big.Int, _receiptData []byte, _proof []byte) (*types.Transaction, error)

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

Solidity: function challengeExit(uint256 _forkNumber, uint256 _blockNumber, uint256 _index, bytes _receiptData, bytes _proof) returns()

func (*RootChainSession) ChallengeNullAddress 

func (_RootChain *RootChainSession) ChallengeNullAddress(_blockNumber *big.Int, _key []byte, _txByte []byte, _branchMask *big.Int, _siblings [][32]byte) (*types.Transaction, error)

ChallengeNullAddress is a paid mutator transaction binding the contract method 0x6299fb24.

Solidity: function challengeNullAddress(uint256 _blockNumber, bytes _key, bytes _txByte, uint256 _branchMask, bytes32[] _siblings) returns()

func (*RootChainSession) ChangeOperator 

func (_RootChain *RootChainSession) ChangeOperator(_operator common.Address) (*types.Transaction, error)

ChangeOperator is a paid mutator transaction binding the contract method 0x06394c9b.

Solidity: function changeOperator(address _operator) returns()

func (*RootChainSession) CurrentFork 

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

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

Solidity: function currentFork() constant returns(uint256)

func (*RootChainSession) Development 

func (_RootChain *RootChainSession) Development() (bool, error)

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

Solidity: function development() constant returns(bool)

func (*RootChainSession) EROIdToFinalize 

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

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

Solidity: function EROIdToFinalize() constant returns(uint256)

func (*RootChainSession) EROs 

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

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

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

Solidity: function ERUIdToFinalize() constant returns(uint256)

func (*RootChainSession) ERUs 

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

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

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

Solidity: function epochHandler() constant returns(address)

func (*RootChainSession) EtherToken 

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

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

Solidity: function etherToken() constant returns(address)

func (*RootChainSession) FinalizeBlock 

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

FinalizeBlock is a paid mutator transaction binding the contract method 0x75395a58.

Solidity: function finalizeBlock() returns(bool success)

func (*RootChainSession) FinalizeRequest 

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

FinalizeRequest is a paid mutator transaction binding the contract method 0x99bd3600.

Solidity: function finalizeRequest() returns(bool success)

func (*RootChainSession) FinalizeRequests 

func (_RootChain *RootChainSession) FinalizeRequests(n *big.Int) (*types.Transaction, error)

FinalizeRequests is a paid mutator transaction binding the contract method 0x54768571.

Solidity: function finalizeRequests(uint256 n) returns(bool success)

func (*RootChainSession) FirstFilledORENumber 

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

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

func (_RootChain *RootChainSession) Forked(_forkNumber *big.Int) (bool, error)

Forked is a free data retrieval call binding the contract method 0xce8a2bc2.

Solidity: function forked(uint256 _forkNumber) constant returns(bool result)

func (*RootChainSession) Forks 

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

func (_RootChain *RootChainSession) GetBlock(forkNumber *big.Int, blockNumber *big.Int) (DataPlasmaBlock, error)

GetBlock is a free data retrieval call binding the contract method 0x4a44bdb8.

Solidity: function getBlock(uint256 forkNumber, uint256 blockNumber) constant returns(DataPlasmaBlock)

func (*RootChainSession) GetBlockFinalizedAt 

func (_RootChain *RootChainSession) GetBlockFinalizedAt(forkNumber *big.Int, blockNumber *big.Int) (*big.Int, error)

GetBlockFinalizedAt is a free data retrieval call binding the contract method 0x5b884682.

Solidity: function getBlockFinalizedAt(uint256 forkNumber, uint256 blockNumber) constant returns(uint256)

func (*RootChainSession) GetEROBytes 

func (_RootChain *RootChainSession) GetEROBytes(_requestId *big.Int) ([]byte, error)

GetEROBytes is a free data retrieval call binding the contract method 0xd1723a96.

Solidity: function getEROBytes(uint256 _requestId) constant returns(bytes out)

func (*RootChainSession) GetEpoch 

func (_RootChain *RootChainSession) GetEpoch(forkNumber *big.Int, epochNumber *big.Int) (DataEpoch, error)

GetEpoch is a free data retrieval call binding the contract method 0x2b25a38b.

Solidity: function getEpoch(uint256 forkNumber, uint256 epochNumber) constant returns(DataEpoch epoch)

func (*RootChainSession) GetLastEpoch 

func (_RootChain *RootChainSession) GetLastEpoch() (DataEpoch, error)

GetLastEpoch is a free data retrieval call binding the contract method 0x398bac63.

Solidity: function getLastEpoch() constant returns(DataEpoch)

func (*RootChainSession) GetLastFinalizedBlock 

func (_RootChain *RootChainSession) GetLastFinalizedBlock(forkNumber *big.Int) (*big.Int, error)

GetLastFinalizedBlock is a free data retrieval call binding the contract method 0xd636857e.

Solidity: function getLastFinalizedBlock(uint256 forkNumber) constant returns(uint256)

func (*RootChainSession) GetLastFinalizedEpoch 

func (_RootChain *RootChainSession) GetLastFinalizedEpoch(forkNumber *big.Int) (*big.Int, error)

GetLastFinalizedEpoch is a free data retrieval call binding the contract method 0x019dc099.

Solidity: function getLastFinalizedEpoch(uint256 forkNumber) constant returns(uint256)

func (*RootChainSession) GetNumEROs 

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

GetNumEROs is a free data retrieval call binding the contract method 0xb540adba.

Solidity: function getNumEROs() constant returns(uint256)

func (*RootChainSession) GetNumORBs 

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

GetNumORBs is a free data retrieval call binding the contract method 0xea0c73f6.

Solidity: function getNumORBs() constant returns(uint256)

func (*RootChainSession) GetRequestFinalized 

func (_RootChain *RootChainSession) GetRequestFinalized(_requestId *big.Int, _userActivated bool) (bool, error)

GetRequestFinalized is a free data retrieval call binding the contract method 0xf28a7afa.

Solidity: function getRequestFinalized(uint256 _requestId, bool _userActivated) constant returns(bool finalized)

func (*RootChainSession) IsMapper 

func (_RootChain *RootChainSession) IsMapper(account common.Address) (bool, error)

IsMapper is a free data retrieval call binding the contract method 0xc0c49c2a.

Solidity: function isMapper(address account) constant returns(bool)

func (*RootChainSession) IsRootChain 

func (_RootChain *RootChainSession) IsRootChain() (bool, error)

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

Solidity: function isRootChain() constant returns(bool)

func (*RootChainSession) IsSubmitter 

func (_RootChain *RootChainSession) IsSubmitter(account common.Address) (bool, error)

IsSubmitter is a free data retrieval call binding the contract method 0xa926fdbc.

Solidity: function isSubmitter(address account) constant returns(bool)

func (*RootChainSession) LastAppliedBlockNumber 

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

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

Solidity: function lastAppliedBlockNumber() constant returns(uint256)

func (*RootChainSession) LastAppliedEpochNumber 

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

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

Solidity: function lastAppliedEpochNumber() constant returns(uint256)

func (*RootChainSession) LastAppliedForkNumber 

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

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

Solidity: function lastAppliedForkNumber() constant returns(uint256)

func (*RootChainSession) LastBlock 

func (_RootChain *RootChainSession) LastBlock(forkNumber *big.Int) (*big.Int, error)

LastBlock is a free data retrieval call binding the contract method 0x1ec2042b.

Solidity: function lastBlock(uint256 forkNumber) constant returns(uint256 lastBlock)

func (*RootChainSession) LastEpoch 

func (_RootChain *RootChainSession) LastEpoch(forkNumber *big.Int) (*big.Int, error)

LastEpoch is a free data retrieval call binding the contract method 0x11e4c914.

Solidity: function lastEpoch(uint256 forkNumber) constant returns(uint256 lastBlock)

func (*RootChainSession) LastNonEmptyRequestEpoch 

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

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

MAXREQUESTS is a free data retrieval call binding the contract method 0x93521222.

Solidity: function MAX_REQUESTS() constant returns(uint256 maxRequests)

func (*RootChainSession) MakeERU 

func (_RootChain *RootChainSession) MakeERU(_to common.Address, _trieKey [32]byte, _trieValue []byte) (*types.Transaction, error)

MakeERU is a paid mutator transaction binding the contract method 0x78fe705f.

Solidity: function makeERU(address _to, bytes32 _trieKey, bytes _trieValue) returns(bool success)

func (*RootChainSession) MapRequestableContractByOperator 

func (_RootChain *RootChainSession) MapRequestableContractByOperator(_rootchain common.Address, _childchain common.Address) (*types.Transaction, error)

MapRequestableContractByOperator is a paid mutator transaction binding the contract method 0xcb5d742f.

Solidity: function mapRequestableContractByOperator(address _rootchain, address _childchain) returns(bool success)

func (*RootChainSession) NRELength 

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

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

Solidity: function NRELength() constant returns(uint256)

func (*RootChainSession) NULLADDRESS 

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

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

Solidity: function NULL_ADDRESS() constant returns(address)

func (*RootChainSession) NumEnterForORB 

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

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

Solidity: function numEnterForORB() constant returns(uint256)

func (*RootChainSession) ORBs 

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

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

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

Solidity: function operator() constant returns(address)

func (*RootChainSession) PREPARETIMEOUT 

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

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

Solidity: function PREPARE_TIMEOUT() constant returns(uint256)

func (*RootChainSession) PrepareToSubmitURB 

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

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

Solidity: function prepareToSubmitURB() returns()

func (*RootChainSession) REQUESTGAS 

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

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

Solidity: function REQUEST_GAS() constant returns(uint256)

func (*RootChainSession) RenounceMapper 

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

RenounceMapper is a paid mutator transaction binding the contract method 0x3565fb0d.

Solidity: function renounceMapper() returns()

func (*RootChainSession) RenounceSubmitter 

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

RenounceSubmitter is a paid mutator transaction binding the contract method 0x5e0ca71b.

Solidity: function renounceSubmitter() returns()

func (*RootChainSession) RequestableContracts 

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

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

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

Solidity: function seigManager() constant returns(address)

func (*RootChainSession) SetSeigManager 

func (_RootChain *RootChainSession) SetSeigManager(account common.Address) (*types.Transaction, error)

SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.

Solidity: function setSeigManager(address account) returns()

func (*RootChainSession) StartEnter 

func (_RootChain *RootChainSession) StartEnter(_to common.Address, _trieKey [32]byte, _trieValue []byte) (*types.Transaction, error)

StartEnter is a paid mutator transaction binding the contract method 0x2aa196c8.

Solidity: function startEnter(address _to, bytes32 _trieKey, bytes _trieValue) returns(bool success)

func (*RootChainSession) StartExit 

func (_RootChain *RootChainSession) StartExit(_to common.Address, _trieKey [32]byte, _trieValue []byte) (*types.Transaction, error)

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

Solidity: function startExit(address _to, bytes32 _trieKey, bytes _trieValue) returns(bool success)

func (*RootChainSession) SubmitHandler 

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

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

Solidity: function submitHandler() constant returns(address)

func (*RootChainSession) SubmitNRE 

func (_RootChain *RootChainSession) SubmitNRE(_pos1 *big.Int, _pos2 *big.Int, _epochStateRoot [32]byte, _epochTransactionsRoot [32]byte, _epochReceiptsRoot [32]byte) (*types.Transaction, error)

SubmitNRE is a paid mutator transaction binding the contract method 0x0eaf45a8.

Solidity: function submitNRE(uint256 _pos1, uint256 _pos2, bytes32 _epochStateRoot, bytes32 _epochTransactionsRoot, bytes32 _epochReceiptsRoot) returns(bool success)

func (*RootChainSession) SubmitORB 

func (_RootChain *RootChainSession) SubmitORB(_pos *big.Int, _statesRoot [32]byte, _transactionsRoot [32]byte, _receiptsRoot [32]byte) (*types.Transaction, error)

SubmitORB is a paid mutator transaction binding the contract method 0xa820c067.

Solidity: function submitORB(uint256 _pos, bytes32 _statesRoot, bytes32 _transactionsRoot, bytes32 _receiptsRoot) returns(bool success)

func (*RootChainSession) SubmitURB 

func (_RootChain *RootChainSession) SubmitURB(_pos *big.Int, _statesRoot [32]byte, _transactionsRoot [32]byte, _receiptsRoot [32]byte) (*types.Transaction, error)

SubmitURB is a paid mutator transaction binding the contract method 0x6f3e4b90.

Solidity: function submitURB(uint256 _pos, bytes32 _statesRoot, bytes32 _transactionsRoot, bytes32 _receiptsRoot) returns(bool success)

func (*RootChainSession) URBs 

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

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

RootChainSessionTimeout represents a SessionTimeout event raised by the RootChain contract.

type RootChainSessionTimeoutIterator 

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

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

func (*RootChainSessionTimeoutIterator) Close 

func (it *RootChainSessionTimeoutIterator) Close() error

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

func (*RootChainSessionTimeoutIterator) Error 

func (it *RootChainSessionTimeoutIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainSessionTimeoutIterator) Next 

func (it *RootChainSessionTimeoutIterator) 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 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 RootChainSubmitterAdded 

type RootChainSubmitterAdded struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

RootChainSubmitterAdded represents a SubmitterAdded event raised by the RootChain contract.

type RootChainSubmitterAddedIterator 

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

RootChainSubmitterAddedIterator is returned from FilterSubmitterAdded and is used to iterate over the raw logs and unpacked data for SubmitterAdded events raised by the RootChain contract.

func (*RootChainSubmitterAddedIterator) Close 

func (it *RootChainSubmitterAddedIterator) Close() error

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

func (*RootChainSubmitterAddedIterator) Error 

func (it *RootChainSubmitterAddedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainSubmitterAddedIterator) Next 

func (it *RootChainSubmitterAddedIterator) 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 RootChainSubmitterRemoved 

type RootChainSubmitterRemoved struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

RootChainSubmitterRemoved represents a SubmitterRemoved event raised by the RootChain contract.

type RootChainSubmitterRemovedIterator 

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

RootChainSubmitterRemovedIterator is returned from FilterSubmitterRemoved and is used to iterate over the raw logs and unpacked data for SubmitterRemoved events raised by the RootChain contract.

func (*RootChainSubmitterRemovedIterator) Close 

func (it *RootChainSubmitterRemovedIterator) Close() error

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

func (*RootChainSubmitterRemovedIterator) Error 

func (it *RootChainSubmitterRemovedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootChainSubmitterRemovedIterator) Next 

func (it *RootChainSubmitterRemovedIterator) 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 RootChainTransactor 

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

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

func NewRootChainTransactor 

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

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

func (*RootChainTransactor) AddMapper 

func (_RootChain *RootChainTransactor) AddMapper(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error)

AddMapper is a paid mutator transaction binding the contract method 0x80e3e81d.

Solidity: function addMapper(address account) returns()

func (*RootChainTransactor) AddSubmitter 

func (_RootChain *RootChainTransactor) AddSubmitter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error)

AddSubmitter is a paid mutator transaction binding the contract method 0x072900f9.

Solidity: function addSubmitter(address account) returns()

func (*RootChainTransactor) ChallengeExit 

func (_RootChain *RootChainTransactor) ChallengeExit(opts *bind.TransactOpts, _forkNumber *big.Int, _blockNumber *big.Int, _index *big.Int, _receiptData []byte, _proof []byte) (*types.Transaction, error)

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

Solidity: function challengeExit(uint256 _forkNumber, uint256 _blockNumber, uint256 _index, bytes _receiptData, bytes _proof) returns()

func (*RootChainTransactor) ChallengeNullAddress 

func (_RootChain *RootChainTransactor) ChallengeNullAddress(opts *bind.TransactOpts, _blockNumber *big.Int, _key []byte, _txByte []byte, _branchMask *big.Int, _siblings [][32]byte) (*types.Transaction, error)

ChallengeNullAddress is a paid mutator transaction binding the contract method 0x6299fb24.

Solidity: function challengeNullAddress(uint256 _blockNumber, bytes _key, bytes _txByte, uint256 _branchMask, bytes32[] _siblings) returns()

func (*RootChainTransactor) ChangeOperator 

func (_RootChain *RootChainTransactor) ChangeOperator(opts *bind.TransactOpts, _operator common.Address) (*types.Transaction, error)

ChangeOperator is a paid mutator transaction binding the contract method 0x06394c9b.

Solidity: function changeOperator(address _operator) returns()

func (*RootChainTransactor) FinalizeBlock 

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

FinalizeBlock is a paid mutator transaction binding the contract method 0x75395a58.

Solidity: function finalizeBlock() returns(bool success)

func (*RootChainTransactor) FinalizeRequest 

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

FinalizeRequest is a paid mutator transaction binding the contract method 0x99bd3600.

Solidity: function finalizeRequest() returns(bool success)

func (*RootChainTransactor) FinalizeRequests 

func (_RootChain *RootChainTransactor) FinalizeRequests(opts *bind.TransactOpts, n *big.Int) (*types.Transaction, error)

FinalizeRequests is a paid mutator transaction binding the contract method 0x54768571.

Solidity: function finalizeRequests(uint256 n) returns(bool success)

func (*RootChainTransactor) MakeERU 

func (_RootChain *RootChainTransactor) MakeERU(opts *bind.TransactOpts, _to common.Address, _trieKey [32]byte, _trieValue []byte) (*types.Transaction, error)

MakeERU is a paid mutator transaction binding the contract method 0x78fe705f.

Solidity: function makeERU(address _to, bytes32 _trieKey, bytes _trieValue) returns(bool success)

func (*RootChainTransactor) MapRequestableContractByOperator 

func (_RootChain *RootChainTransactor) MapRequestableContractByOperator(opts *bind.TransactOpts, _rootchain common.Address, _childchain common.Address) (*types.Transaction, error)

MapRequestableContractByOperator is a paid mutator transaction binding the contract method 0xcb5d742f.

Solidity: function mapRequestableContractByOperator(address _rootchain, address _childchain) returns(bool success)

func (*RootChainTransactor) PrepareToSubmitURB 

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

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

Solidity: function prepareToSubmitURB() returns()

func (*RootChainTransactor) RenounceMapper 

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

RenounceMapper is a paid mutator transaction binding the contract method 0x3565fb0d.

Solidity: function renounceMapper() returns()

func (*RootChainTransactor) RenounceSubmitter 

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

RenounceSubmitter is a paid mutator transaction binding the contract method 0x5e0ca71b.

Solidity: function renounceSubmitter() returns()

func (*RootChainTransactor) SetSeigManager 

func (_RootChain *RootChainTransactor) SetSeigManager(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error)

SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.

Solidity: function setSeigManager(address account) returns()

func (*RootChainTransactor) StartEnter 

func (_RootChain *RootChainTransactor) StartEnter(opts *bind.TransactOpts, _to common.Address, _trieKey [32]byte, _trieValue []byte) (*types.Transaction, error)

StartEnter is a paid mutator transaction binding the contract method 0x2aa196c8.

Solidity: function startEnter(address _to, bytes32 _trieKey, bytes _trieValue) returns(bool success)

func (*RootChainTransactor) StartExit 

func (_RootChain *RootChainTransactor) StartExit(opts *bind.TransactOpts, _to common.Address, _trieKey [32]byte, _trieValue []byte) (*types.Transaction, error)

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

Solidity: function startExit(address _to, bytes32 _trieKey, bytes _trieValue) returns(bool success)

func (*RootChainTransactor) SubmitNRE 

func (_RootChain *RootChainTransactor) SubmitNRE(opts *bind.TransactOpts, _pos1 *big.Int, _pos2 *big.Int, _epochStateRoot [32]byte, _epochTransactionsRoot [32]byte, _epochReceiptsRoot [32]byte) (*types.Transaction, error)

SubmitNRE is a paid mutator transaction binding the contract method 0x0eaf45a8.

Solidity: function submitNRE(uint256 _pos1, uint256 _pos2, bytes32 _epochStateRoot, bytes32 _epochTransactionsRoot, bytes32 _epochReceiptsRoot) returns(bool success)

func (*RootChainTransactor) SubmitORB 

func (_RootChain *RootChainTransactor) SubmitORB(opts *bind.TransactOpts, _pos *big.Int, _statesRoot [32]byte, _transactionsRoot [32]byte, _receiptsRoot [32]byte) (*types.Transaction, error)

SubmitORB is a paid mutator transaction binding the contract method 0xa820c067.

Solidity: function submitORB(uint256 _pos, bytes32 _statesRoot, bytes32 _transactionsRoot, bytes32 _receiptsRoot) returns(bool success)

func (*RootChainTransactor) SubmitURB 

func (_RootChain *RootChainTransactor) SubmitURB(opts *bind.TransactOpts, _pos *big.Int, _statesRoot [32]byte, _transactionsRoot [32]byte, _receiptsRoot [32]byte) (*types.Transaction, error)

SubmitURB is a paid mutator transaction binding the contract method 0x6f3e4b90.

Solidity: function submitURB(uint256 _pos, bytes32 _statesRoot, bytes32 _transactionsRoot, bytes32 _receiptsRoot) returns(bool success)

type RootChainTransactorRaw 

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

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

func (*RootChainTransactorRaw) Transact 

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

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

func (*RootChainTransactorRaw) Transfer 

func (_RootChain *RootChainTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

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

type RootChainTransactorSession 

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

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

func (*RootChainTransactorSession) AddMapper 

func (_RootChain *RootChainTransactorSession) AddMapper(account common.Address) (*types.Transaction, error)

AddMapper is a paid mutator transaction binding the contract method 0x80e3e81d.

Solidity: function addMapper(address account) returns()

func (*RootChainTransactorSession) AddSubmitter 

func (_RootChain *RootChainTransactorSession) AddSubmitter(account common.Address) (*types.Transaction, error)

AddSubmitter is a paid mutator transaction binding the contract method 0x072900f9.

Solidity: function addSubmitter(address account) returns()

func (*RootChainTransactorSession) ChallengeExit 

func (_RootChain *RootChainTransactorSession) ChallengeExit(_forkNumber *big.Int, _blockNumber *big.Int, _index *big.Int, _receiptData []byte, _proof []byte) (*types.Transaction, error)

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

Solidity: function challengeExit(uint256 _forkNumber, uint256 _blockNumber, uint256 _index, bytes _receiptData, bytes _proof) returns()

func (*RootChainTransactorSession) ChallengeNullAddress 

func (_RootChain *RootChainTransactorSession) ChallengeNullAddress(_blockNumber *big.Int, _key []byte, _txByte []byte, _branchMask *big.Int, _siblings [][32]byte) (*types.Transaction, error)

ChallengeNullAddress is a paid mutator transaction binding the contract method 0x6299fb24.

Solidity: function challengeNullAddress(uint256 _blockNumber, bytes _key, bytes _txByte, uint256 _branchMask, bytes32[] _siblings) returns()

func (*RootChainTransactorSession) ChangeOperator 

func (_RootChain *RootChainTransactorSession) ChangeOperator(_operator common.Address) (*types.Transaction, error)

ChangeOperator is a paid mutator transaction binding the contract method 0x06394c9b.

Solidity: function changeOperator(address _operator) returns()

func (*RootChainTransactorSession) FinalizeBlock 

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

FinalizeBlock is a paid mutator transaction binding the contract method 0x75395a58.

Solidity: function finalizeBlock() returns(bool success)

func (*RootChainTransactorSession) FinalizeRequest 

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

FinalizeRequest is a paid mutator transaction binding the contract method 0x99bd3600.

Solidity: function finalizeRequest() returns(bool success)

func (*RootChainTransactorSession) FinalizeRequests 

func (_RootChain *RootChainTransactorSession) FinalizeRequests(n *big.Int) (*types.Transaction, error)

FinalizeRequests is a paid mutator transaction binding the contract method 0x54768571.

Solidity: function finalizeRequests(uint256 n) returns(bool success)

func (*RootChainTransactorSession) MakeERU 

func (_RootChain *RootChainTransactorSession) MakeERU(_to common.Address, _trieKey [32]byte, _trieValue []byte) (*types.Transaction, error)

MakeERU is a paid mutator transaction binding the contract method 0x78fe705f.

Solidity: function makeERU(address _to, bytes32 _trieKey, bytes _trieValue) returns(bool success)

func (*RootChainTransactorSession) MapRequestableContractByOperator 

func (_RootChain *RootChainTransactorSession) MapRequestableContractByOperator(_rootchain common.Address, _childchain common.Address) (*types.Transaction, error)

MapRequestableContractByOperator is a paid mutator transaction binding the contract method 0xcb5d742f.

Solidity: function mapRequestableContractByOperator(address _rootchain, address _childchain) returns(bool success)

func (*RootChainTransactorSession) PrepareToSubmitURB 

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

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

Solidity: function prepareToSubmitURB() returns()

func (*RootChainTransactorSession) RenounceMapper 

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

RenounceMapper is a paid mutator transaction binding the contract method 0x3565fb0d.

Solidity: function renounceMapper() returns()

func (*RootChainTransactorSession) RenounceSubmitter 

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

RenounceSubmitter is a paid mutator transaction binding the contract method 0x5e0ca71b.

Solidity: function renounceSubmitter() returns()

func (*RootChainTransactorSession) SetSeigManager 

func (_RootChain *RootChainTransactorSession) SetSeigManager(account common.Address) (*types.Transaction, error)

SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.

Solidity: function setSeigManager(address account) returns()

func (*RootChainTransactorSession) StartEnter 

func (_RootChain *RootChainTransactorSession) StartEnter(_to common.Address, _trieKey [32]byte, _trieValue []byte) (*types.Transaction, error)

StartEnter is a paid mutator transaction binding the contract method 0x2aa196c8.

Solidity: function startEnter(address _to, bytes32 _trieKey, bytes _trieValue) returns(bool success)

func (*RootChainTransactorSession) StartExit 

func (_RootChain *RootChainTransactorSession) StartExit(_to common.Address, _trieKey [32]byte, _trieValue []byte) (*types.Transaction, error)

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

Solidity: function startExit(address _to, bytes32 _trieKey, bytes _trieValue) returns(bool success)

func (*RootChainTransactorSession) SubmitNRE 

func (_RootChain *RootChainTransactorSession) SubmitNRE(_pos1 *big.Int, _pos2 *big.Int, _epochStateRoot [32]byte, _epochTransactionsRoot [32]byte, _epochReceiptsRoot [32]byte) (*types.Transaction, error)

SubmitNRE is a paid mutator transaction binding the contract method 0x0eaf45a8.

Solidity: function submitNRE(uint256 _pos1, uint256 _pos2, bytes32 _epochStateRoot, bytes32 _epochTransactionsRoot, bytes32 _epochReceiptsRoot) returns(bool success)

func (*RootChainTransactorSession) SubmitORB 

func (_RootChain *RootChainTransactorSession) SubmitORB(_pos *big.Int, _statesRoot [32]byte, _transactionsRoot [32]byte, _receiptsRoot [32]byte) (*types.Transaction, error)

SubmitORB is a paid mutator transaction binding the contract method 0xa820c067.

Solidity: function submitORB(uint256 _pos, bytes32 _statesRoot, bytes32 _transactionsRoot, bytes32 _receiptsRoot) returns(bool success)

func (*RootChainTransactorSession) SubmitURB 

func (_RootChain *RootChainTransactorSession) SubmitURB(_pos *big.Int, _statesRoot [32]byte, _transactionsRoot [32]byte, _receiptsRoot [32]byte) (*types.Transaction, error)

SubmitURB is a paid mutator transaction binding the contract method 0x6f3e4b90.

Solidity: function submitURB(uint256 _pos, bytes32 _statesRoot, bytes32 _transactionsRoot, bytes32 _receiptsRoot) returns(bool success)

type SafeMath 

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

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

func DeploySafeMath 

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

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

func NewSafeMath 

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

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

type SafeMathCaller 

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

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

func NewSafeMathCaller 

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

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

type SafeMathCallerRaw 

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

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

func (*SafeMathCallerRaw) Call 

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

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

type SafeMathCallerSession 

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

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

type SafeMathFilterer 

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

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

func NewSafeMathFilterer 

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

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

type SafeMathRaw 

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

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

func (*SafeMathRaw) Call 

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

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

func (*SafeMathRaw) Transact 

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

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

func (*SafeMathRaw) Transfer 

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

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

type SafeMathSession 

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

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

type SafeMathTransactor 

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

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

func NewSafeMathTransactor 

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

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

type SafeMathTransactorRaw 

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

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

func (*SafeMathTransactorRaw) Transact 

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

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

func (*SafeMathTransactorRaw) Transfer 

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

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

type SafeMathTransactorSession 

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

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

type SubmitterRole 

type SubmitterRole struct {
	SubmitterRoleCaller     // Read-only binding to the contract
	SubmitterRoleTransactor // Write-only binding to the contract
	SubmitterRoleFilterer   // Log filterer for contract events
}

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

func NewSubmitterRole 

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

NewSubmitterRole creates a new instance of SubmitterRole, bound to a specific deployed contract.

type SubmitterRoleCaller 

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

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

func NewSubmitterRoleCaller 

func NewSubmitterRoleCaller(address common.Address, caller bind.ContractCaller) (*SubmitterRoleCaller, error)

NewSubmitterRoleCaller creates a new read-only instance of SubmitterRole, bound to a specific deployed contract.

func (*SubmitterRoleCaller) IsSubmitter 

func (_SubmitterRole *SubmitterRoleCaller) IsSubmitter(opts *bind.CallOpts, account common.Address) (bool, error)

IsSubmitter is a free data retrieval call binding the contract method 0xa926fdbc.

Solidity: function isSubmitter(address account) constant returns(bool)

type SubmitterRoleCallerRaw 

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

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

func (*SubmitterRoleCallerRaw) Call 

func (_SubmitterRole *SubmitterRoleCallerRaw) 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 SubmitterRoleCallerSession 

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

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

func (*SubmitterRoleCallerSession) IsSubmitter 

func (_SubmitterRole *SubmitterRoleCallerSession) IsSubmitter(account common.Address) (bool, error)

IsSubmitter is a free data retrieval call binding the contract method 0xa926fdbc.

Solidity: function isSubmitter(address account) constant returns(bool)

type SubmitterRoleFilterer 

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

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

func NewSubmitterRoleFilterer 

func NewSubmitterRoleFilterer(address common.Address, filterer bind.ContractFilterer) (*SubmitterRoleFilterer, error)

NewSubmitterRoleFilterer creates a new log filterer instance of SubmitterRole, bound to a specific deployed contract.

func (*SubmitterRoleFilterer) FilterSubmitterAdded 

func (_SubmitterRole *SubmitterRoleFilterer) FilterSubmitterAdded(opts *bind.FilterOpts, account []common.Address) (*SubmitterRoleSubmitterAddedIterator, error)

FilterSubmitterAdded is a free log retrieval operation binding the contract event 0xb079bc2cbde1f186e0b351d4a87c4597e3ed098f571548617449e73506428d8b.

Solidity: event SubmitterAdded(address indexed account)

func (*SubmitterRoleFilterer) FilterSubmitterRemoved 

func (_SubmitterRole *SubmitterRoleFilterer) FilterSubmitterRemoved(opts *bind.FilterOpts, account []common.Address) (*SubmitterRoleSubmitterRemovedIterator, error)

FilterSubmitterRemoved is a free log retrieval operation binding the contract event 0xf84a004e1673d2f349a7c93c72b3794b8eba6d2f9338044d8c8cd260e51a57a1.

Solidity: event SubmitterRemoved(address indexed account)

func (*SubmitterRoleFilterer) ParseSubmitterAdded 

func (_SubmitterRole *SubmitterRoleFilterer) ParseSubmitterAdded(log types.Log) (*SubmitterRoleSubmitterAdded, error)

ParseSubmitterAdded is a log parse operation binding the contract event 0xb079bc2cbde1f186e0b351d4a87c4597e3ed098f571548617449e73506428d8b.

Solidity: event SubmitterAdded(address indexed account)

func (*SubmitterRoleFilterer) ParseSubmitterRemoved 

func (_SubmitterRole *SubmitterRoleFilterer) ParseSubmitterRemoved(log types.Log) (*SubmitterRoleSubmitterRemoved, error)

ParseSubmitterRemoved is a log parse operation binding the contract event 0xf84a004e1673d2f349a7c93c72b3794b8eba6d2f9338044d8c8cd260e51a57a1.

Solidity: event SubmitterRemoved(address indexed account)

func (*SubmitterRoleFilterer) WatchSubmitterAdded 

func (_SubmitterRole *SubmitterRoleFilterer) WatchSubmitterAdded(opts *bind.WatchOpts, sink chan<- *SubmitterRoleSubmitterAdded, account []common.Address) (event.Subscription, error)

WatchSubmitterAdded is a free log subscription operation binding the contract event 0xb079bc2cbde1f186e0b351d4a87c4597e3ed098f571548617449e73506428d8b.

Solidity: event SubmitterAdded(address indexed account)

func (*SubmitterRoleFilterer) WatchSubmitterRemoved 

func (_SubmitterRole *SubmitterRoleFilterer) WatchSubmitterRemoved(opts *bind.WatchOpts, sink chan<- *SubmitterRoleSubmitterRemoved, account []common.Address) (event.Subscription, error)

WatchSubmitterRemoved is a free log subscription operation binding the contract event 0xf84a004e1673d2f349a7c93c72b3794b8eba6d2f9338044d8c8cd260e51a57a1.

Solidity: event SubmitterRemoved(address indexed account)

type SubmitterRoleRaw 

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

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

func (*SubmitterRoleRaw) Call 

func (_SubmitterRole *SubmitterRoleRaw) 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 (*SubmitterRoleRaw) Transact 

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

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

func (*SubmitterRoleRaw) Transfer 

func (_SubmitterRole *SubmitterRoleRaw) 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 SubmitterRoleSession 

type SubmitterRoleSession struct {
	Contract     *SubmitterRole    // 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
}

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

func (*SubmitterRoleSession) AddSubmitter 

func (_SubmitterRole *SubmitterRoleSession) AddSubmitter(account common.Address) (*types.Transaction, error)

AddSubmitter is a paid mutator transaction binding the contract method 0x072900f9.

Solidity: function addSubmitter(address account) returns()

func (*SubmitterRoleSession) IsSubmitter 

func (_SubmitterRole *SubmitterRoleSession) IsSubmitter(account common.Address) (bool, error)

IsSubmitter is a free data retrieval call binding the contract method 0xa926fdbc.

Solidity: function isSubmitter(address account) constant returns(bool)

func (*SubmitterRoleSession) RenounceSubmitter 

func (_SubmitterRole *SubmitterRoleSession) RenounceSubmitter() (*types.Transaction, error)

RenounceSubmitter is a paid mutator transaction binding the contract method 0x5e0ca71b.

Solidity: function renounceSubmitter() returns()

type SubmitterRoleSubmitterAdded 

type SubmitterRoleSubmitterAdded struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

SubmitterRoleSubmitterAdded represents a SubmitterAdded event raised by the SubmitterRole contract.

type SubmitterRoleSubmitterAddedIterator 

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

SubmitterRoleSubmitterAddedIterator is returned from FilterSubmitterAdded and is used to iterate over the raw logs and unpacked data for SubmitterAdded events raised by the SubmitterRole contract.

func (*SubmitterRoleSubmitterAddedIterator) Close 

func (it *SubmitterRoleSubmitterAddedIterator) Close() error

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

func (*SubmitterRoleSubmitterAddedIterator) Error 

func (it *SubmitterRoleSubmitterAddedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*SubmitterRoleSubmitterAddedIterator) Next 

func (it *SubmitterRoleSubmitterAddedIterator) 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 SubmitterRoleSubmitterRemoved 

type SubmitterRoleSubmitterRemoved struct {
	Account common.Address
	Raw     types.Log // Blockchain specific contextual infos
}

SubmitterRoleSubmitterRemoved represents a SubmitterRemoved event raised by the SubmitterRole contract.

type SubmitterRoleSubmitterRemovedIterator 

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

SubmitterRoleSubmitterRemovedIterator is returned from FilterSubmitterRemoved and is used to iterate over the raw logs and unpacked data for SubmitterRemoved events raised by the SubmitterRole contract.

func (*SubmitterRoleSubmitterRemovedIterator) Close 

func (it *SubmitterRoleSubmitterRemovedIterator) Close() error

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

func (*SubmitterRoleSubmitterRemovedIterator) Error 

func (it *SubmitterRoleSubmitterRemovedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*SubmitterRoleSubmitterRemovedIterator) Next 

func (it *SubmitterRoleSubmitterRemovedIterator) 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 SubmitterRoleTransactor 

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

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

func NewSubmitterRoleTransactor 

func NewSubmitterRoleTransactor(address common.Address, transactor bind.ContractTransactor) (*SubmitterRoleTransactor, error)

NewSubmitterRoleTransactor creates a new write-only instance of SubmitterRole, bound to a specific deployed contract.

func (*SubmitterRoleTransactor) AddSubmitter 

func (_SubmitterRole *SubmitterRoleTransactor) AddSubmitter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error)

AddSubmitter is a paid mutator transaction binding the contract method 0x072900f9.

Solidity: function addSubmitter(address account) returns()

func (*SubmitterRoleTransactor) RenounceSubmitter 

func (_SubmitterRole *SubmitterRoleTransactor) RenounceSubmitter(opts *bind.TransactOpts) (*types.Transaction, error)

RenounceSubmitter is a paid mutator transaction binding the contract method 0x5e0ca71b.

Solidity: function renounceSubmitter() returns()

type SubmitterRoleTransactorRaw 

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

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

func (*SubmitterRoleTransactorRaw) Transact 

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

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

func (*SubmitterRoleTransactorRaw) Transfer 

func (_SubmitterRole *SubmitterRoleTransactorRaw) 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 SubmitterRoleTransactorSession 

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

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

func (*SubmitterRoleTransactorSession) AddSubmitter 

func (_SubmitterRole *SubmitterRoleTransactorSession) AddSubmitter(account common.Address) (*types.Transaction, error)

AddSubmitter is a paid mutator transaction binding the contract method 0x072900f9.

Solidity: function addSubmitter(address account) returns()

func (*SubmitterRoleTransactorSession) RenounceSubmitter 

func (_SubmitterRole *SubmitterRoleTransactorSession) RenounceSubmitter() (*types.Transaction, error)

RenounceSubmitter is a paid mutator transaction binding the contract method 0x5e0ca71b.

Solidity: function renounceSubmitter() returns()

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.