eccm_abi

package
v0.0.0-...-e558250 Latest Latest
Warning

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

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

Documentation

Index

Constants

View Source 
const ContextABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}]"

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

View Source 
const ECCUtilsABI = "[]"

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

View Source 
const EthCrossChainManagerABI = "" /* 4907-byte string literal not displayed */

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

View Source 
const IEthCrossChainDataABI = "" /* 3378-byte string literal not displayed */

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

View Source 
const IEthCrossChainManagerABI = "" /* 358-byte string literal not displayed */

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

View Source 
const IUpgradableECCMABI = "" /* 920-byte string literal not displayed */

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

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

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

View Source 
const PausableABI = "" /* 540-byte string literal not displayed */

PausableABI 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 UpgradableECCMABI = "" /* 2313-byte string literal not displayed */

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

View Source 
const UtilsABI = "[]"

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

View Source 
const ZeroCopySinkABI = "[]"

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

View Source 
const ZeroCopySourceABI = "[]"

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

Variables

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

ECCUtilsBin is the compiled bytecode used for deploying new contracts.

View Source 
var EthCrossChainManagerBin = "" /* 41984-byte string literal not displayed */

EthCrossChainManagerBin is the compiled bytecode used for deploying new contracts.

View Source 
var EthCrossChainManagerFuncSigs = map[string]string{
	"ed9a3dc3": "EthCrossChainDataAddress()",
	"9ad77567": "changeBookKeeper(bytes,bytes,bytes)",
	"1f5045a8": "crossChain(uint64,bytes,bytes,bytes)",
	"ed8873be": "initGenesisBlock(bytes,bytes)",
	"ede8e529": "isOwner()",
	"5089e2c8": "owner()",
	"f4fbb0c8": "pause()",
	"d4bc9601": "paused()",
	"d86e29e2": "renounceOwnership()",
	"16cad12a": "transferOwnership(address)",
	"63c37526": "unpause()",
	"f4e614d2": "upgradeToNew(address)",
	"cbd41b35": "verifyHeaderAndExecuteTx(bytes,bytes,bytes,bytes,bytes)",
}

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

View Source 
var IEthCrossChainDataFuncSigs = map[string]string{
	"e7eed3f3": "checkIfFromChainTxExist(uint64,bytes32)",
	"a87c3ab2": "getCurEpochConPubKeyBytes()",
	"a1043138": "getCurEpochStartHeight()",
	"d5b03fca": "getEthTxHash(uint256)",
	"ab907a6f": "getEthTxHashIndex()",
	"2707f9e0": "getExtraData(bytes32,bytes32)",
	"1ce20756": "markFromChainTxExist(uint64,bytes32)",
	"f4fbb0c8": "pause()",
	"d4bc9601": "paused()",
	"795c2da6": "putCurEpochConPubKeyBytes(bytes)",
	"9b9272ae": "putCurEpochStartHeight(uint32)",
	"93645d57": "putEthTxHash(bytes32)",
	"351f0ea0": "putExtraData(bytes32,bytes32,bytes)",
	"16cad12a": "transferOwnership(address)",
	"63c37526": "unpause()",
}

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

View Source 
var IEthCrossChainManagerFuncSigs = map[string]string{
	"1f5045a8": "crossChain(uint64,bytes,bytes,bytes)",
}

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

View Source 
var IUpgradableECCMFuncSigs = map[string]string{
	"ede8e529": "isOwner()",
	"f4fbb0c8": "pause()",
	"d4bc9601": "paused()",
	"63c37526": "unpause()",
	"f4e614d2": "upgradeToNew(address)",
}

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

View Source 
var OwnableFuncSigs = map[string]string{
	"ede8e529": "isOwner()",
	"5089e2c8": "owner()",
	"d86e29e2": "renounceOwnership()",
	"16cad12a": "transferOwnership(address)",
}

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

View Source 
var PausableFuncSigs = map[string]string{
	"d4bc9601": "paused()",
}

PausableFuncSigs 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 UpgradableECCMBin = "" /* 5806-byte string literal not displayed */

UpgradableECCMBin is the compiled bytecode used for deploying new contracts.

View Source 
var UpgradableECCMFuncSigs = map[string]string{
	"ed9a3dc3": "EthCrossChainDataAddress()",
	"ede8e529": "isOwner()",
	"5089e2c8": "owner()",
	"f4fbb0c8": "pause()",
	"d4bc9601": "paused()",
	"d86e29e2": "renounceOwnership()",
	"16cad12a": "transferOwnership(address)",
	"63c37526": "unpause()",
	"f4e614d2": "upgradeToNew(address)",
}

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

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

UtilsBin is the compiled bytecode used for deploying new contracts.

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

ZeroCopySinkBin is the compiled bytecode used for deploying new contracts.

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

ZeroCopySourceBin is the compiled bytecode used for deploying new contracts.

Functions

func AsyncDeployECCUtils 

func AsyncDeployECCUtils(auth *bind.TransactOpts, handler func(*types.Receipt, error), backend bind.ContractBackend) (*types.Transaction, error)

func AsyncDeployEthCrossChainManager 

func AsyncDeployEthCrossChainManager(auth *bind.TransactOpts, handler func(*types.Receipt, error), backend bind.ContractBackend, _eccd common.Address) (*types.Transaction, error)

func AsyncDeploySafeMath 

func AsyncDeploySafeMath(auth *bind.TransactOpts, handler func(*types.Receipt, error), backend bind.ContractBackend) (*types.Transaction, error)

func AsyncDeployUpgradableECCM 

func AsyncDeployUpgradableECCM(auth *bind.TransactOpts, handler func(*types.Receipt, error), backend bind.ContractBackend, ethCrossChainDataAddr common.Address) (*types.Transaction, error)

func AsyncDeployUtils 

func AsyncDeployUtils(auth *bind.TransactOpts, handler func(*types.Receipt, error), backend bind.ContractBackend) (*types.Transaction, error)

func AsyncDeployZeroCopySink 

func AsyncDeployZeroCopySink(auth *bind.TransactOpts, handler func(*types.Receipt, error), backend bind.ContractBackend) (*types.Transaction, error)

func AsyncDeployZeroCopySource 

func AsyncDeployZeroCopySource(auth *bind.TransactOpts, handler func(*types.Receipt, error), backend bind.ContractBackend) (*types.Transaction, error)

Types

type Context 

type Context struct {
	ContextCaller     // Read-only binding to the contract
	ContextTransactor // Write-only binding to the contract
	ContextFilterer   // Log filterer for contract events
}

Context is an auto generated Go binding around a Solidity contract.

func NewContext 

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

NewContext creates a new instance of Context, bound to a specific deployed contract.

type ContextCaller 

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

ContextCaller is an auto generated read-only Go binding around a Solidity contract.

func NewContextCaller 

func NewContextCaller(address common.Address, caller bind.ContractCaller) (*ContextCaller, error)

NewContextCaller creates a new read-only instance of Context, bound to a specific deployed contract.

type ContextCallerRaw 

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

ContextCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*ContextCallerRaw) Call 

func (_Context *ContextCallerRaw) 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 ContextCallerSession 

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

ContextCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

type ContextFilterer 

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

ContextFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewContextFilterer 

func NewContextFilterer(address common.Address, filterer bind.ContractFilterer) (*ContextFilterer, error)

NewContextFilterer creates a new log filterer instance of Context, bound to a specific deployed contract.

type ContextRaw 

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

ContextRaw is an auto generated low-level Go binding around a Solidity contract.

func (*ContextRaw) Call 

func (_Context *ContextRaw) 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 (*ContextRaw) Transact 

func (_Context *ContextRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*ContextRaw) Transfer 

func (_Context *ContextRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type ContextSession 

type ContextSession struct {
	Contract     *Context          // 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
}

ContextSession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

type ContextTransactor 

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

ContextTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewContextTransactor 

func NewContextTransactor(address common.Address, transactor bind.ContractTransactor) (*ContextTransactor, error)

NewContextTransactor creates a new write-only instance of Context, bound to a specific deployed contract.

type ContextTransactorRaw 

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

ContextTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*ContextTransactorRaw) Transact 

func (_Context *ContextTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*ContextTransactorRaw) Transfer 

func (_Context *ContextTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type ContextTransactorSession 

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

ContextTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

type ECCUtils 

type ECCUtils struct {
	ECCUtilsCaller     // Read-only binding to the contract
	ECCUtilsTransactor // Write-only binding to the contract
	ECCUtilsFilterer   // Log filterer for contract events
}

ECCUtils is an auto generated Go binding around a Solidity contract.

func DeployECCUtils 

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

DeployECCUtils deploys a new contract, binding an instance of ECCUtils to it.

func NewECCUtils 

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

NewECCUtils creates a new instance of ECCUtils, bound to a specific deployed contract.

type ECCUtilsCaller 

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

ECCUtilsCaller is an auto generated read-only Go binding around a Solidity contract.

func NewECCUtilsCaller 

func NewECCUtilsCaller(address common.Address, caller bind.ContractCaller) (*ECCUtilsCaller, error)

NewECCUtilsCaller creates a new read-only instance of ECCUtils, bound to a specific deployed contract.

type ECCUtilsCallerRaw 

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

ECCUtilsCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*ECCUtilsCallerRaw) Call 

func (_ECCUtils *ECCUtilsCallerRaw) 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 ECCUtilsCallerSession 

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

ECCUtilsCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

type ECCUtilsFilterer 

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

ECCUtilsFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewECCUtilsFilterer 

func NewECCUtilsFilterer(address common.Address, filterer bind.ContractFilterer) (*ECCUtilsFilterer, error)

NewECCUtilsFilterer creates a new log filterer instance of ECCUtils, bound to a specific deployed contract.

type ECCUtilsRaw 

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

ECCUtilsRaw is an auto generated low-level Go binding around a Solidity contract.

func (*ECCUtilsRaw) Call 

func (_ECCUtils *ECCUtilsRaw) 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 (*ECCUtilsRaw) Transact 

func (_ECCUtils *ECCUtilsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*ECCUtilsRaw) Transfer 

func (_ECCUtils *ECCUtilsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type ECCUtilsSession 

type ECCUtilsSession struct {
	Contract     *ECCUtils         // 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
}

ECCUtilsSession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

type ECCUtilsTransactor 

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

ECCUtilsTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewECCUtilsTransactor 

func NewECCUtilsTransactor(address common.Address, transactor bind.ContractTransactor) (*ECCUtilsTransactor, error)

NewECCUtilsTransactor creates a new write-only instance of ECCUtils, bound to a specific deployed contract.

type ECCUtilsTransactorRaw 

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

ECCUtilsTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*ECCUtilsTransactorRaw) Transact 

func (_ECCUtils *ECCUtilsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*ECCUtilsTransactorRaw) Transfer 

func (_ECCUtils *ECCUtilsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type ECCUtilsTransactorSession 

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

ECCUtilsTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

type EthCrossChainManager 

type EthCrossChainManager struct {
	EthCrossChainManagerCaller     // Read-only binding to the contract
	EthCrossChainManagerTransactor // Write-only binding to the contract
	EthCrossChainManagerFilterer   // Log filterer for contract events
}

EthCrossChainManager is an auto generated Go binding around a Solidity contract.

func DeployEthCrossChainManager 

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

DeployEthCrossChainManager deploys a new contract, binding an instance of EthCrossChainManager to it.

func NewEthCrossChainManager 

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

NewEthCrossChainManager creates a new instance of EthCrossChainManager, bound to a specific deployed contract.

type EthCrossChainManagerCaller 

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

EthCrossChainManagerCaller is an auto generated read-only Go binding around a Solidity contract.

func NewEthCrossChainManagerCaller 

func NewEthCrossChainManagerCaller(address common.Address, caller bind.ContractCaller) (*EthCrossChainManagerCaller, error)

NewEthCrossChainManagerCaller creates a new read-only instance of EthCrossChainManager, bound to a specific deployed contract.

func (*EthCrossChainManagerCaller) EthCrossChainDataAddress 

func (_EthCrossChainManager *EthCrossChainManagerCaller) EthCrossChainDataAddress(opts *bind.CallOpts) (common.Address, error)

EthCrossChainDataAddress is a free data retrieval call binding the contract method 0xed9a3dc3.

Solidity: function EthCrossChainDataAddress() constant returns(address)

func (*EthCrossChainManagerCaller) IsOwner 

func (_EthCrossChainManager *EthCrossChainManagerCaller) IsOwner(opts *bind.CallOpts) (bool, error)

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

Solidity: function isOwner() constant returns(bool)

func (*EthCrossChainManagerCaller) Owner 

func (_EthCrossChainManager *EthCrossChainManagerCaller) Owner(opts *bind.CallOpts) (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*EthCrossChainManagerCaller) Paused 

func (_EthCrossChainManager *EthCrossChainManagerCaller) Paused(opts *bind.CallOpts) (bool, error)

Paused is a free data retrieval call binding the contract method 0xd4bc9601.

Solidity: function paused() constant returns(bool)

type EthCrossChainManagerCallerRaw 

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

EthCrossChainManagerCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*EthCrossChainManagerCallerRaw) Call 

func (_EthCrossChainManager *EthCrossChainManagerCallerRaw) 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 EthCrossChainManagerCallerSession 

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

EthCrossChainManagerCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

func (*EthCrossChainManagerCallerSession) EthCrossChainDataAddress 

func (_EthCrossChainManager *EthCrossChainManagerCallerSession) EthCrossChainDataAddress() (common.Address, error)

EthCrossChainDataAddress is a free data retrieval call binding the contract method 0xed9a3dc3.

Solidity: function EthCrossChainDataAddress() constant returns(address)

func (*EthCrossChainManagerCallerSession) IsOwner 

func (_EthCrossChainManager *EthCrossChainManagerCallerSession) IsOwner() (bool, error)

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

Solidity: function isOwner() constant returns(bool)

func (*EthCrossChainManagerCallerSession) Owner 

func (_EthCrossChainManager *EthCrossChainManagerCallerSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*EthCrossChainManagerCallerSession) Paused 

func (_EthCrossChainManager *EthCrossChainManagerCallerSession) Paused() (bool, error)

Paused is a free data retrieval call binding the contract method 0xd4bc9601.

Solidity: function paused() constant returns(bool)

type EthCrossChainManagerChangeBookKeeperEvent 

type EthCrossChainManagerChangeBookKeeperEvent struct {
	Height    *big.Int
	RawHeader []byte
	Raw       types.Log // Blockchain specific contextual infos
}

EthCrossChainManagerChangeBookKeeperEvent represents a ChangeBookKeeperEvent event raised by the EthCrossChainManager contract.

type EthCrossChainManagerChangeBookKeeperEventIterator 

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

EthCrossChainManagerChangeBookKeeperEventIterator is returned from FilterChangeBookKeeperEvent and is used to iterate over the raw logs and unpacked data for ChangeBookKeeperEvent events raised by the EthCrossChainManager contract.

func (*EthCrossChainManagerChangeBookKeeperEventIterator) Close 

func (it *EthCrossChainManagerChangeBookKeeperEventIterator) Close() error

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

func (*EthCrossChainManagerChangeBookKeeperEventIterator) Error 

func (it *EthCrossChainManagerChangeBookKeeperEventIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EthCrossChainManagerChangeBookKeeperEventIterator) Next 

func (it *EthCrossChainManagerChangeBookKeeperEventIterator) 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 EthCrossChainManagerCrossChainEvent 

type EthCrossChainManagerCrossChainEvent struct {
	Sender               common.Address
	TxId                 []byte
	ProxyOrAssetContract common.Address
	ToChainId            uint64
	ToContract           []byte
	Rawdata              []byte
	Raw                  types.Log // Blockchain specific contextual infos
}

EthCrossChainManagerCrossChainEvent represents a CrossChainEvent event raised by the EthCrossChainManager contract.

type EthCrossChainManagerCrossChainEventIterator 

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

EthCrossChainManagerCrossChainEventIterator is returned from FilterCrossChainEvent and is used to iterate over the raw logs and unpacked data for CrossChainEvent events raised by the EthCrossChainManager contract.

func (*EthCrossChainManagerCrossChainEventIterator) Close 

func (it *EthCrossChainManagerCrossChainEventIterator) Close() error

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

func (*EthCrossChainManagerCrossChainEventIterator) Error 

func (it *EthCrossChainManagerCrossChainEventIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EthCrossChainManagerCrossChainEventIterator) Next 

func (it *EthCrossChainManagerCrossChainEventIterator) 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 EthCrossChainManagerFilterer 

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

EthCrossChainManagerFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewEthCrossChainManagerFilterer 

func NewEthCrossChainManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*EthCrossChainManagerFilterer, error)

NewEthCrossChainManagerFilterer creates a new log filterer instance of EthCrossChainManager, bound to a specific deployed contract.

func (*EthCrossChainManagerFilterer) FilterChangeBookKeeperEvent 

func (_EthCrossChainManager *EthCrossChainManagerFilterer) FilterChangeBookKeeperEvent(opts *bind.FilterOpts) (*EthCrossChainManagerChangeBookKeeperEventIterator, error)

FilterChangeBookKeeperEvent is a free log retrieval operation binding the contract event 0x00000000000000000000000000000000000000000000000000000000b6fce21d.

Solidity: event ChangeBookKeeperEvent(uint256 height, bytes rawHeader)

func (*EthCrossChainManagerFilterer) FilterCrossChainEvent 

func (_EthCrossChainManager *EthCrossChainManagerFilterer) FilterCrossChainEvent(opts *bind.FilterOpts, sender []common.Address) (*EthCrossChainManagerCrossChainEventIterator, error)

FilterCrossChainEvent is a free log retrieval operation binding the contract event 0x000000000000000000000000000000000000000000000000000000009d458f04.

Solidity: event CrossChainEvent(address indexed sender, bytes txId, address proxyOrAssetContract, uint64 toChainId, bytes toContract, bytes rawdata)

func (*EthCrossChainManagerFilterer) FilterInitGenesisBlockEvent 

func (_EthCrossChainManager *EthCrossChainManagerFilterer) FilterInitGenesisBlockEvent(opts *bind.FilterOpts) (*EthCrossChainManagerInitGenesisBlockEventIterator, error)

FilterInitGenesisBlockEvent is a free log retrieval operation binding the contract event 0x00000000000000000000000000000000000000000000000000000000d0d0850c.

Solidity: event InitGenesisBlockEvent(uint256 height, bytes rawHeader)

func (*EthCrossChainManagerFilterer) FilterOwnershipTransferred 

func (_EthCrossChainManager *EthCrossChainManagerFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*EthCrossChainManagerOwnershipTransferredIterator, error)

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

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

func (*EthCrossChainManagerFilterer) FilterPaused 

func (_EthCrossChainManager *EthCrossChainManagerFilterer) FilterPaused(opts *bind.FilterOpts) (*EthCrossChainManagerPausedIterator, error)

FilterPaused is a free log retrieval operation binding the contract event 0x000000000000000000000000000000000000000000000000000000003572985a.

Solidity: event Paused(address account)

func (*EthCrossChainManagerFilterer) FilterUnpaused 

func (_EthCrossChainManager *EthCrossChainManagerFilterer) FilterUnpaused(opts *bind.FilterOpts) (*EthCrossChainManagerUnpausedIterator, error)

FilterUnpaused is a free log retrieval operation binding the contract event 0x0000000000000000000000000000000000000000000000000000000044693cad.

Solidity: event Unpaused(address account)

func (*EthCrossChainManagerFilterer) FilterVerifyHeaderAndExecuteTxEvent 

func (_EthCrossChainManager *EthCrossChainManagerFilterer) FilterVerifyHeaderAndExecuteTxEvent(opts *bind.FilterOpts) (*EthCrossChainManagerVerifyHeaderAndExecuteTxEventIterator, error)

FilterVerifyHeaderAndExecuteTxEvent is a free log retrieval operation binding the contract event 0x00000000000000000000000000000000000000000000000000000000d55b5c06.

Solidity: event VerifyHeaderAndExecuteTxEvent(uint64 fromChainID, bytes toContract, bytes crossChainTxHash, bytes fromChainTxHash)

func (*EthCrossChainManagerFilterer) ParseChangeBookKeeperEvent 

func (_EthCrossChainManager *EthCrossChainManagerFilterer) ParseChangeBookKeeperEvent(log types.Log) (*EthCrossChainManagerChangeBookKeeperEvent, error)

ParseChangeBookKeeperEvent is a log parse operation binding the contract event 0x00000000000000000000000000000000000000000000000000000000b6fce21d.

Solidity: event ChangeBookKeeperEvent(uint256 height, bytes rawHeader)

func (*EthCrossChainManagerFilterer) ParseCrossChainEvent 

func (_EthCrossChainManager *EthCrossChainManagerFilterer) ParseCrossChainEvent(log types.Log) (*EthCrossChainManagerCrossChainEvent, error)

ParseCrossChainEvent is a log parse operation binding the contract event 0x000000000000000000000000000000000000000000000000000000009d458f04.

Solidity: event CrossChainEvent(address indexed sender, bytes txId, address proxyOrAssetContract, uint64 toChainId, bytes toContract, bytes rawdata)

func (*EthCrossChainManagerFilterer) ParseInitGenesisBlockEvent 

func (_EthCrossChainManager *EthCrossChainManagerFilterer) ParseInitGenesisBlockEvent(log types.Log) (*EthCrossChainManagerInitGenesisBlockEvent, error)

ParseInitGenesisBlockEvent is a log parse operation binding the contract event 0x00000000000000000000000000000000000000000000000000000000d0d0850c.

Solidity: event InitGenesisBlockEvent(uint256 height, bytes rawHeader)

func (*EthCrossChainManagerFilterer) ParseOwnershipTransferred 

func (_EthCrossChainManager *EthCrossChainManagerFilterer) ParseOwnershipTransferred(log types.Log) (*EthCrossChainManagerOwnershipTransferred, error)

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

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

func (*EthCrossChainManagerFilterer) ParsePaused 

func (_EthCrossChainManager *EthCrossChainManagerFilterer) ParsePaused(log types.Log) (*EthCrossChainManagerPaused, error)

ParsePaused is a log parse operation binding the contract event 0x000000000000000000000000000000000000000000000000000000003572985a.

Solidity: event Paused(address account)

func (*EthCrossChainManagerFilterer) ParseUnpaused 

func (_EthCrossChainManager *EthCrossChainManagerFilterer) ParseUnpaused(log types.Log) (*EthCrossChainManagerUnpaused, error)

ParseUnpaused is a log parse operation binding the contract event 0x0000000000000000000000000000000000000000000000000000000044693cad.

Solidity: event Unpaused(address account)

func (*EthCrossChainManagerFilterer) ParseVerifyHeaderAndExecuteTxEvent 

func (_EthCrossChainManager *EthCrossChainManagerFilterer) ParseVerifyHeaderAndExecuteTxEvent(log types.Log) (*EthCrossChainManagerVerifyHeaderAndExecuteTxEvent, error)

ParseVerifyHeaderAndExecuteTxEvent is a log parse operation binding the contract event 0x00000000000000000000000000000000000000000000000000000000d55b5c06.

Solidity: event VerifyHeaderAndExecuteTxEvent(uint64 fromChainID, bytes toContract, bytes crossChainTxHash, bytes fromChainTxHash)

func (*EthCrossChainManagerFilterer) WatchChangeBookKeeperEvent 

func (_EthCrossChainManager *EthCrossChainManagerFilterer) WatchChangeBookKeeperEvent(opts *bind.WatchOpts, sink chan<- *EthCrossChainManagerChangeBookKeeperEvent) (event.Subscription, error)

WatchChangeBookKeeperEvent is a free log subscription operation binding the contract event 0x00000000000000000000000000000000000000000000000000000000b6fce21d.

Solidity: event ChangeBookKeeperEvent(uint256 height, bytes rawHeader)

func (*EthCrossChainManagerFilterer) WatchCrossChainEvent 

func (_EthCrossChainManager *EthCrossChainManagerFilterer) WatchCrossChainEvent(opts *bind.WatchOpts, sink chan<- *EthCrossChainManagerCrossChainEvent, sender []common.Address) (event.Subscription, error)

WatchCrossChainEvent is a free log subscription operation binding the contract event 0x000000000000000000000000000000000000000000000000000000009d458f04.

Solidity: event CrossChainEvent(address indexed sender, bytes txId, address proxyOrAssetContract, uint64 toChainId, bytes toContract, bytes rawdata)

func (*EthCrossChainManagerFilterer) WatchInitGenesisBlockEvent 

func (_EthCrossChainManager *EthCrossChainManagerFilterer) WatchInitGenesisBlockEvent(opts *bind.WatchOpts, sink chan<- *EthCrossChainManagerInitGenesisBlockEvent) (event.Subscription, error)

WatchInitGenesisBlockEvent is a free log subscription operation binding the contract event 0x00000000000000000000000000000000000000000000000000000000d0d0850c.

Solidity: event InitGenesisBlockEvent(uint256 height, bytes rawHeader)

func (*EthCrossChainManagerFilterer) WatchOwnershipTransferred 

func (_EthCrossChainManager *EthCrossChainManagerFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *EthCrossChainManagerOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

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

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

func (*EthCrossChainManagerFilterer) WatchPaused 

func (_EthCrossChainManager *EthCrossChainManagerFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *EthCrossChainManagerPaused) (event.Subscription, error)

WatchPaused is a free log subscription operation binding the contract event 0x000000000000000000000000000000000000000000000000000000003572985a.

Solidity: event Paused(address account)

func (*EthCrossChainManagerFilterer) WatchUnpaused 

func (_EthCrossChainManager *EthCrossChainManagerFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *EthCrossChainManagerUnpaused) (event.Subscription, error)

WatchUnpaused is a free log subscription operation binding the contract event 0x0000000000000000000000000000000000000000000000000000000044693cad.

Solidity: event Unpaused(address account)

func (*EthCrossChainManagerFilterer) WatchVerifyHeaderAndExecuteTxEvent 

func (_EthCrossChainManager *EthCrossChainManagerFilterer) WatchVerifyHeaderAndExecuteTxEvent(opts *bind.WatchOpts, sink chan<- *EthCrossChainManagerVerifyHeaderAndExecuteTxEvent) (event.Subscription, error)

WatchVerifyHeaderAndExecuteTxEvent is a free log subscription operation binding the contract event 0x00000000000000000000000000000000000000000000000000000000d55b5c06.

Solidity: event VerifyHeaderAndExecuteTxEvent(uint64 fromChainID, bytes toContract, bytes crossChainTxHash, bytes fromChainTxHash)

type EthCrossChainManagerInitGenesisBlockEvent 

type EthCrossChainManagerInitGenesisBlockEvent struct {
	Height    *big.Int
	RawHeader []byte
	Raw       types.Log // Blockchain specific contextual infos
}

EthCrossChainManagerInitGenesisBlockEvent represents a InitGenesisBlockEvent event raised by the EthCrossChainManager contract.

type EthCrossChainManagerInitGenesisBlockEventIterator 

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

EthCrossChainManagerInitGenesisBlockEventIterator is returned from FilterInitGenesisBlockEvent and is used to iterate over the raw logs and unpacked data for InitGenesisBlockEvent events raised by the EthCrossChainManager contract.

func (*EthCrossChainManagerInitGenesisBlockEventIterator) Close 

func (it *EthCrossChainManagerInitGenesisBlockEventIterator) Close() error

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

func (*EthCrossChainManagerInitGenesisBlockEventIterator) Error 

func (it *EthCrossChainManagerInitGenesisBlockEventIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EthCrossChainManagerInitGenesisBlockEventIterator) Next 

func (it *EthCrossChainManagerInitGenesisBlockEventIterator) 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 EthCrossChainManagerOwnershipTransferred 

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

EthCrossChainManagerOwnershipTransferred represents a OwnershipTransferred event raised by the EthCrossChainManager contract.

type EthCrossChainManagerOwnershipTransferredIterator 

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

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

func (*EthCrossChainManagerOwnershipTransferredIterator) Close 

func (it *EthCrossChainManagerOwnershipTransferredIterator) Close() error

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

func (*EthCrossChainManagerOwnershipTransferredIterator) Error 

func (it *EthCrossChainManagerOwnershipTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EthCrossChainManagerOwnershipTransferredIterator) Next 

func (it *EthCrossChainManagerOwnershipTransferredIterator) 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 EthCrossChainManagerPaused 

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

EthCrossChainManagerPaused represents a Paused event raised by the EthCrossChainManager contract.

type EthCrossChainManagerPausedIterator 

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

EthCrossChainManagerPausedIterator is returned from FilterPaused and is used to iterate over the raw logs and unpacked data for Paused events raised by the EthCrossChainManager contract.

func (*EthCrossChainManagerPausedIterator) Close 

func (it *EthCrossChainManagerPausedIterator) Close() error

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

func (*EthCrossChainManagerPausedIterator) Error 

func (it *EthCrossChainManagerPausedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EthCrossChainManagerPausedIterator) Next 

func (it *EthCrossChainManagerPausedIterator) 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 EthCrossChainManagerRaw 

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

EthCrossChainManagerRaw is an auto generated low-level Go binding around a Solidity contract.

func (*EthCrossChainManagerRaw) Call 

func (_EthCrossChainManager *EthCrossChainManagerRaw) 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 (*EthCrossChainManagerRaw) Transact 

func (_EthCrossChainManager *EthCrossChainManagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*EthCrossChainManagerRaw) Transfer 

func (_EthCrossChainManager *EthCrossChainManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type EthCrossChainManagerSession 

type EthCrossChainManagerSession struct {
	Contract     *EthCrossChainManager // 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
}

EthCrossChainManagerSession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

func (*EthCrossChainManagerSession) AsyncChangeBookKeeper 

func (_EthCrossChainManager *EthCrossChainManagerSession) AsyncChangeBookKeeper(handler func(*types.Receipt, error), rawHeader []byte, pubKeyList []byte, sigList []byte) (*types.Transaction, error)

func (*EthCrossChainManagerSession) AsyncCrossChain 

func (_EthCrossChainManager *EthCrossChainManagerSession) AsyncCrossChain(handler func(*types.Receipt, error), toChainId uint64, toContract []byte, method []byte, txData []byte) (*types.Transaction, error)

func (*EthCrossChainManagerSession) AsyncInitGenesisBlock 

func (_EthCrossChainManager *EthCrossChainManagerSession) AsyncInitGenesisBlock(handler func(*types.Receipt, error), rawHeader []byte, pubKeyList []byte) (*types.Transaction, error)

func (*EthCrossChainManagerSession) AsyncPause 

func (_EthCrossChainManager *EthCrossChainManagerSession) AsyncPause(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*EthCrossChainManagerSession) AsyncRenounceOwnership 

func (_EthCrossChainManager *EthCrossChainManagerSession) AsyncRenounceOwnership(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*EthCrossChainManagerSession) AsyncTransferOwnership 

func (_EthCrossChainManager *EthCrossChainManagerSession) AsyncTransferOwnership(handler func(*types.Receipt, error), newOwner common.Address) (*types.Transaction, error)

func (*EthCrossChainManagerSession) AsyncUnpause 

func (_EthCrossChainManager *EthCrossChainManagerSession) AsyncUnpause(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*EthCrossChainManagerSession) AsyncUpgradeToNew 

func (_EthCrossChainManager *EthCrossChainManagerSession) AsyncUpgradeToNew(handler func(*types.Receipt, error), newEthCrossChainManagerAddress common.Address) (*types.Transaction, error)

func (*EthCrossChainManagerSession) AsyncVerifyHeaderAndExecuteTx 

func (_EthCrossChainManager *EthCrossChainManagerSession) AsyncVerifyHeaderAndExecuteTx(handler func(*types.Receipt, error), proof []byte, rawHeader []byte, headerProof []byte, curRawHeader []byte, headerSig []byte) (*types.Transaction, error)

func (*EthCrossChainManagerSession) ChangeBookKeeper 

func (_EthCrossChainManager *EthCrossChainManagerSession) ChangeBookKeeper(rawHeader []byte, pubKeyList []byte, sigList []byte) (*types.Transaction, *types.Receipt, error)

ChangeBookKeeper is a paid mutator transaction binding the contract method 0x9ad77567.

Solidity: function changeBookKeeper(bytes rawHeader, bytes pubKeyList, bytes sigList) returns(bool)

func (*EthCrossChainManagerSession) CrossChain 

func (_EthCrossChainManager *EthCrossChainManagerSession) CrossChain(toChainId uint64, toContract []byte, method []byte, txData []byte) (*types.Transaction, *types.Receipt, error)

CrossChain is a paid mutator transaction binding the contract method 0x1f5045a8.

Solidity: function crossChain(uint64 toChainId, bytes toContract, bytes method, bytes txData) returns(bool)

func (*EthCrossChainManagerSession) EthCrossChainDataAddress 

func (_EthCrossChainManager *EthCrossChainManagerSession) EthCrossChainDataAddress() (common.Address, error)

EthCrossChainDataAddress is a free data retrieval call binding the contract method 0xed9a3dc3.

Solidity: function EthCrossChainDataAddress() constant returns(address)

func (*EthCrossChainManagerSession) InitGenesisBlock 

func (_EthCrossChainManager *EthCrossChainManagerSession) InitGenesisBlock(rawHeader []byte, pubKeyList []byte) (*types.Transaction, *types.Receipt, error)

InitGenesisBlock is a paid mutator transaction binding the contract method 0xed8873be.

Solidity: function initGenesisBlock(bytes rawHeader, bytes pubKeyList) returns(bool)

func (*EthCrossChainManagerSession) IsOwner 

func (_EthCrossChainManager *EthCrossChainManagerSession) IsOwner() (bool, error)

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

Solidity: function isOwner() constant returns(bool)

func (*EthCrossChainManagerSession) Owner 

func (_EthCrossChainManager *EthCrossChainManagerSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*EthCrossChainManagerSession) Pause 

func (_EthCrossChainManager *EthCrossChainManagerSession) Pause() (*types.Transaction, *types.Receipt, error)

Pause is a paid mutator transaction binding the contract method 0xf4fbb0c8.

Solidity: function pause() returns(bool)

func (*EthCrossChainManagerSession) Paused 

func (_EthCrossChainManager *EthCrossChainManagerSession) Paused() (bool, error)

Paused is a free data retrieval call binding the contract method 0xd4bc9601.

Solidity: function paused() constant returns(bool)

func (*EthCrossChainManagerSession) RenounceOwnership 

func (_EthCrossChainManager *EthCrossChainManagerSession) RenounceOwnership() (*types.Transaction, *types.Receipt, error)

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

Solidity: function renounceOwnership() returns()

func (*EthCrossChainManagerSession) TransferOwnership 

func (_EthCrossChainManager *EthCrossChainManagerSession) TransferOwnership(newOwner common.Address) (*types.Transaction, *types.Receipt, error)

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

Solidity: function transferOwnership(address newOwner) returns()

func (*EthCrossChainManagerSession) Unpause 

func (_EthCrossChainManager *EthCrossChainManagerSession) Unpause() (*types.Transaction, *types.Receipt, error)

Unpause is a paid mutator transaction binding the contract method 0x63c37526.

Solidity: function unpause() returns(bool)

func (*EthCrossChainManagerSession) UpgradeToNew 

func (_EthCrossChainManager *EthCrossChainManagerSession) UpgradeToNew(newEthCrossChainManagerAddress common.Address) (*types.Transaction, *types.Receipt, error)

UpgradeToNew is a paid mutator transaction binding the contract method 0xf4e614d2.

Solidity: function upgradeToNew(address newEthCrossChainManagerAddress) returns(bool)

func (*EthCrossChainManagerSession) VerifyHeaderAndExecuteTx 

func (_EthCrossChainManager *EthCrossChainManagerSession) VerifyHeaderAndExecuteTx(proof []byte, rawHeader []byte, headerProof []byte, curRawHeader []byte, headerSig []byte) (*types.Transaction, *types.Receipt, error)

VerifyHeaderAndExecuteTx is a paid mutator transaction binding the contract method 0xcbd41b35.

Solidity: function verifyHeaderAndExecuteTx(bytes proof, bytes rawHeader, bytes headerProof, bytes curRawHeader, bytes headerSig) returns(bool)

type EthCrossChainManagerTransactor 

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

EthCrossChainManagerTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewEthCrossChainManagerTransactor 

func NewEthCrossChainManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*EthCrossChainManagerTransactor, error)

NewEthCrossChainManagerTransactor creates a new write-only instance of EthCrossChainManager, bound to a specific deployed contract.

func (*EthCrossChainManagerTransactor) AsyncChangeBookKeeper 

func (_EthCrossChainManager *EthCrossChainManagerTransactor) AsyncChangeBookKeeper(handler func(*types.Receipt, error), opts *bind.TransactOpts, rawHeader []byte, pubKeyList []byte, sigList []byte) (*types.Transaction, error)

func (*EthCrossChainManagerTransactor) AsyncCrossChain 

func (_EthCrossChainManager *EthCrossChainManagerTransactor) AsyncCrossChain(handler func(*types.Receipt, error), opts *bind.TransactOpts, toChainId uint64, toContract []byte, method []byte, txData []byte) (*types.Transaction, error)

func (*EthCrossChainManagerTransactor) AsyncInitGenesisBlock 

func (_EthCrossChainManager *EthCrossChainManagerTransactor) AsyncInitGenesisBlock(handler func(*types.Receipt, error), opts *bind.TransactOpts, rawHeader []byte, pubKeyList []byte) (*types.Transaction, error)

func (*EthCrossChainManagerTransactor) AsyncPause 

func (_EthCrossChainManager *EthCrossChainManagerTransactor) AsyncPause(handler func(*types.Receipt, error), opts *bind.TransactOpts) (*types.Transaction, error)

func (*EthCrossChainManagerTransactor) AsyncRenounceOwnership 

func (_EthCrossChainManager *EthCrossChainManagerTransactor) AsyncRenounceOwnership(handler func(*types.Receipt, error), opts *bind.TransactOpts) (*types.Transaction, error)

func (*EthCrossChainManagerTransactor) AsyncTransferOwnership 

func (_EthCrossChainManager *EthCrossChainManagerTransactor) AsyncTransferOwnership(handler func(*types.Receipt, error), opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

func (*EthCrossChainManagerTransactor) AsyncUnpause 

func (_EthCrossChainManager *EthCrossChainManagerTransactor) AsyncUnpause(handler func(*types.Receipt, error), opts *bind.TransactOpts) (*types.Transaction, error)

func (*EthCrossChainManagerTransactor) AsyncUpgradeToNew 

func (_EthCrossChainManager *EthCrossChainManagerTransactor) AsyncUpgradeToNew(handler func(*types.Receipt, error), opts *bind.TransactOpts, newEthCrossChainManagerAddress common.Address) (*types.Transaction, error)

func (*EthCrossChainManagerTransactor) AsyncVerifyHeaderAndExecuteTx 

func (_EthCrossChainManager *EthCrossChainManagerTransactor) AsyncVerifyHeaderAndExecuteTx(handler func(*types.Receipt, error), opts *bind.TransactOpts, proof []byte, rawHeader []byte, headerProof []byte, curRawHeader []byte, headerSig []byte) (*types.Transaction, error)

func (*EthCrossChainManagerTransactor) ChangeBookKeeper 

func (_EthCrossChainManager *EthCrossChainManagerTransactor) ChangeBookKeeper(opts *bind.TransactOpts, rawHeader []byte, pubKeyList []byte, sigList []byte) (*types.Transaction, *types.Receipt, error)

ChangeBookKeeper is a paid mutator transaction binding the contract method 0x9ad77567.

Solidity: function changeBookKeeper(bytes rawHeader, bytes pubKeyList, bytes sigList) returns(bool)

func (*EthCrossChainManagerTransactor) CrossChain 

func (_EthCrossChainManager *EthCrossChainManagerTransactor) CrossChain(opts *bind.TransactOpts, toChainId uint64, toContract []byte, method []byte, txData []byte) (*types.Transaction, *types.Receipt, error)

CrossChain is a paid mutator transaction binding the contract method 0x1f5045a8.

Solidity: function crossChain(uint64 toChainId, bytes toContract, bytes method, bytes txData) returns(bool)

func (*EthCrossChainManagerTransactor) InitGenesisBlock 

func (_EthCrossChainManager *EthCrossChainManagerTransactor) InitGenesisBlock(opts *bind.TransactOpts, rawHeader []byte, pubKeyList []byte) (*types.Transaction, *types.Receipt, error)

InitGenesisBlock is a paid mutator transaction binding the contract method 0xed8873be.

Solidity: function initGenesisBlock(bytes rawHeader, bytes pubKeyList) returns(bool)

func (*EthCrossChainManagerTransactor) Pause 

func (_EthCrossChainManager *EthCrossChainManagerTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

Pause is a paid mutator transaction binding the contract method 0xf4fbb0c8.

Solidity: function pause() returns(bool)

func (*EthCrossChainManagerTransactor) RenounceOwnership 

func (_EthCrossChainManager *EthCrossChainManagerTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

Solidity: function renounceOwnership() returns()

func (*EthCrossChainManagerTransactor) TransferOwnership 

func (_EthCrossChainManager *EthCrossChainManagerTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, *types.Receipt, error)

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

Solidity: function transferOwnership(address newOwner) returns()

func (*EthCrossChainManagerTransactor) Unpause 

func (_EthCrossChainManager *EthCrossChainManagerTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

Unpause is a paid mutator transaction binding the contract method 0x63c37526.

Solidity: function unpause() returns(bool)

func (*EthCrossChainManagerTransactor) UpgradeToNew 

func (_EthCrossChainManager *EthCrossChainManagerTransactor) UpgradeToNew(opts *bind.TransactOpts, newEthCrossChainManagerAddress common.Address) (*types.Transaction, *types.Receipt, error)

UpgradeToNew is a paid mutator transaction binding the contract method 0xf4e614d2.

Solidity: function upgradeToNew(address newEthCrossChainManagerAddress) returns(bool)

func (*EthCrossChainManagerTransactor) VerifyHeaderAndExecuteTx 

func (_EthCrossChainManager *EthCrossChainManagerTransactor) VerifyHeaderAndExecuteTx(opts *bind.TransactOpts, proof []byte, rawHeader []byte, headerProof []byte, curRawHeader []byte, headerSig []byte) (*types.Transaction, *types.Receipt, error)

VerifyHeaderAndExecuteTx is a paid mutator transaction binding the contract method 0xcbd41b35.

Solidity: function verifyHeaderAndExecuteTx(bytes proof, bytes rawHeader, bytes headerProof, bytes curRawHeader, bytes headerSig) returns(bool)

type EthCrossChainManagerTransactorRaw 

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

EthCrossChainManagerTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*EthCrossChainManagerTransactorRaw) Transact 

func (_EthCrossChainManager *EthCrossChainManagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*EthCrossChainManagerTransactorRaw) Transfer 

func (_EthCrossChainManager *EthCrossChainManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type EthCrossChainManagerTransactorSession 

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

EthCrossChainManagerTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

func (*EthCrossChainManagerTransactorSession) AsyncChangeBookKeeper 

func (_EthCrossChainManager *EthCrossChainManagerTransactorSession) AsyncChangeBookKeeper(handler func(*types.Receipt, error), rawHeader []byte, pubKeyList []byte, sigList []byte) (*types.Transaction, error)

func (*EthCrossChainManagerTransactorSession) AsyncCrossChain 

func (_EthCrossChainManager *EthCrossChainManagerTransactorSession) AsyncCrossChain(handler func(*types.Receipt, error), toChainId uint64, toContract []byte, method []byte, txData []byte) (*types.Transaction, error)

func (*EthCrossChainManagerTransactorSession) AsyncInitGenesisBlock 

func (_EthCrossChainManager *EthCrossChainManagerTransactorSession) AsyncInitGenesisBlock(handler func(*types.Receipt, error), rawHeader []byte, pubKeyList []byte) (*types.Transaction, error)

func (*EthCrossChainManagerTransactorSession) AsyncPause 

func (_EthCrossChainManager *EthCrossChainManagerTransactorSession) AsyncPause(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*EthCrossChainManagerTransactorSession) AsyncRenounceOwnership 

func (_EthCrossChainManager *EthCrossChainManagerTransactorSession) AsyncRenounceOwnership(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*EthCrossChainManagerTransactorSession) AsyncTransferOwnership 

func (_EthCrossChainManager *EthCrossChainManagerTransactorSession) AsyncTransferOwnership(handler func(*types.Receipt, error), newOwner common.Address) (*types.Transaction, error)

func (*EthCrossChainManagerTransactorSession) AsyncUnpause 

func (_EthCrossChainManager *EthCrossChainManagerTransactorSession) AsyncUnpause(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*EthCrossChainManagerTransactorSession) AsyncUpgradeToNew 

func (_EthCrossChainManager *EthCrossChainManagerTransactorSession) AsyncUpgradeToNew(handler func(*types.Receipt, error), newEthCrossChainManagerAddress common.Address) (*types.Transaction, error)

func (*EthCrossChainManagerTransactorSession) AsyncVerifyHeaderAndExecuteTx 

func (_EthCrossChainManager *EthCrossChainManagerTransactorSession) AsyncVerifyHeaderAndExecuteTx(handler func(*types.Receipt, error), proof []byte, rawHeader []byte, headerProof []byte, curRawHeader []byte, headerSig []byte) (*types.Transaction, error)

func (*EthCrossChainManagerTransactorSession) ChangeBookKeeper 

func (_EthCrossChainManager *EthCrossChainManagerTransactorSession) ChangeBookKeeper(rawHeader []byte, pubKeyList []byte, sigList []byte) (*types.Transaction, *types.Receipt, error)

ChangeBookKeeper is a paid mutator transaction binding the contract method 0x9ad77567.

Solidity: function changeBookKeeper(bytes rawHeader, bytes pubKeyList, bytes sigList) returns(bool)

func (*EthCrossChainManagerTransactorSession) CrossChain 

func (_EthCrossChainManager *EthCrossChainManagerTransactorSession) CrossChain(toChainId uint64, toContract []byte, method []byte, txData []byte) (*types.Transaction, *types.Receipt, error)

CrossChain is a paid mutator transaction binding the contract method 0x1f5045a8.

Solidity: function crossChain(uint64 toChainId, bytes toContract, bytes method, bytes txData) returns(bool)

func (*EthCrossChainManagerTransactorSession) InitGenesisBlock 

func (_EthCrossChainManager *EthCrossChainManagerTransactorSession) InitGenesisBlock(rawHeader []byte, pubKeyList []byte) (*types.Transaction, *types.Receipt, error)

InitGenesisBlock is a paid mutator transaction binding the contract method 0xed8873be.

Solidity: function initGenesisBlock(bytes rawHeader, bytes pubKeyList) returns(bool)

func (*EthCrossChainManagerTransactorSession) Pause 

func (_EthCrossChainManager *EthCrossChainManagerTransactorSession) Pause() (*types.Transaction, *types.Receipt, error)

Pause is a paid mutator transaction binding the contract method 0xf4fbb0c8.

Solidity: function pause() returns(bool)

func (*EthCrossChainManagerTransactorSession) RenounceOwnership 

func (_EthCrossChainManager *EthCrossChainManagerTransactorSession) RenounceOwnership() (*types.Transaction, *types.Receipt, error)

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

Solidity: function renounceOwnership() returns()

func (*EthCrossChainManagerTransactorSession) TransferOwnership 

func (_EthCrossChainManager *EthCrossChainManagerTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, *types.Receipt, error)

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

Solidity: function transferOwnership(address newOwner) returns()

func (*EthCrossChainManagerTransactorSession) Unpause 

func (_EthCrossChainManager *EthCrossChainManagerTransactorSession) Unpause() (*types.Transaction, *types.Receipt, error)

Unpause is a paid mutator transaction binding the contract method 0x63c37526.

Solidity: function unpause() returns(bool)

func (*EthCrossChainManagerTransactorSession) UpgradeToNew 

func (_EthCrossChainManager *EthCrossChainManagerTransactorSession) UpgradeToNew(newEthCrossChainManagerAddress common.Address) (*types.Transaction, *types.Receipt, error)

UpgradeToNew is a paid mutator transaction binding the contract method 0xf4e614d2.

Solidity: function upgradeToNew(address newEthCrossChainManagerAddress) returns(bool)

func (*EthCrossChainManagerTransactorSession) VerifyHeaderAndExecuteTx 

func (_EthCrossChainManager *EthCrossChainManagerTransactorSession) VerifyHeaderAndExecuteTx(proof []byte, rawHeader []byte, headerProof []byte, curRawHeader []byte, headerSig []byte) (*types.Transaction, *types.Receipt, error)

VerifyHeaderAndExecuteTx is a paid mutator transaction binding the contract method 0xcbd41b35.

Solidity: function verifyHeaderAndExecuteTx(bytes proof, bytes rawHeader, bytes headerProof, bytes curRawHeader, bytes headerSig) returns(bool)

type EthCrossChainManagerUnpaused 

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

EthCrossChainManagerUnpaused represents a Unpaused event raised by the EthCrossChainManager contract.

type EthCrossChainManagerUnpausedIterator 

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

EthCrossChainManagerUnpausedIterator is returned from FilterUnpaused and is used to iterate over the raw logs and unpacked data for Unpaused events raised by the EthCrossChainManager contract.

func (*EthCrossChainManagerUnpausedIterator) Close 

func (it *EthCrossChainManagerUnpausedIterator) Close() error

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

func (*EthCrossChainManagerUnpausedIterator) Error 

func (it *EthCrossChainManagerUnpausedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EthCrossChainManagerUnpausedIterator) Next 

func (it *EthCrossChainManagerUnpausedIterator) 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 EthCrossChainManagerVerifyHeaderAndExecuteTxEvent 

type EthCrossChainManagerVerifyHeaderAndExecuteTxEvent struct {
	FromChainID      uint64
	ToContract       []byte
	CrossChainTxHash []byte
	FromChainTxHash  []byte
	Raw              types.Log // Blockchain specific contextual infos
}

EthCrossChainManagerVerifyHeaderAndExecuteTxEvent represents a VerifyHeaderAndExecuteTxEvent event raised by the EthCrossChainManager contract.

type EthCrossChainManagerVerifyHeaderAndExecuteTxEventIterator 

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

EthCrossChainManagerVerifyHeaderAndExecuteTxEventIterator is returned from FilterVerifyHeaderAndExecuteTxEvent and is used to iterate over the raw logs and unpacked data for VerifyHeaderAndExecuteTxEvent events raised by the EthCrossChainManager contract.

func (*EthCrossChainManagerVerifyHeaderAndExecuteTxEventIterator) Close 

func (it *EthCrossChainManagerVerifyHeaderAndExecuteTxEventIterator) Close() error

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

func (*EthCrossChainManagerVerifyHeaderAndExecuteTxEventIterator) Error 

func (it *EthCrossChainManagerVerifyHeaderAndExecuteTxEventIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EthCrossChainManagerVerifyHeaderAndExecuteTxEventIterator) Next 

func (it *EthCrossChainManagerVerifyHeaderAndExecuteTxEventIterator) 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 IEthCrossChainData 

type IEthCrossChainData struct {
	IEthCrossChainDataCaller     // Read-only binding to the contract
	IEthCrossChainDataTransactor // Write-only binding to the contract
	IEthCrossChainDataFilterer   // Log filterer for contract events
}

IEthCrossChainData is an auto generated Go binding around a Solidity contract.

func NewIEthCrossChainData 

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

NewIEthCrossChainData creates a new instance of IEthCrossChainData, bound to a specific deployed contract.

type IEthCrossChainDataCaller 

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

IEthCrossChainDataCaller is an auto generated read-only Go binding around a Solidity contract.

func NewIEthCrossChainDataCaller 

func NewIEthCrossChainDataCaller(address common.Address, caller bind.ContractCaller) (*IEthCrossChainDataCaller, error)

NewIEthCrossChainDataCaller creates a new read-only instance of IEthCrossChainData, bound to a specific deployed contract.

func (*IEthCrossChainDataCaller) CheckIfFromChainTxExist 

func (_IEthCrossChainData *IEthCrossChainDataCaller) CheckIfFromChainTxExist(opts *bind.CallOpts, fromChainId uint64, fromChainTx [32]byte) (bool, error)

CheckIfFromChainTxExist is a free data retrieval call binding the contract method 0xe7eed3f3.

Solidity: function checkIfFromChainTxExist(uint64 fromChainId, bytes32 fromChainTx) constant returns(bool)

func (*IEthCrossChainDataCaller) GetCurEpochConPubKeyBytes 

func (_IEthCrossChainData *IEthCrossChainDataCaller) GetCurEpochConPubKeyBytes(opts *bind.CallOpts) ([]byte, error)

GetCurEpochConPubKeyBytes is a free data retrieval call binding the contract method 0xa87c3ab2.

Solidity: function getCurEpochConPubKeyBytes() constant returns(bytes)

func (*IEthCrossChainDataCaller) GetCurEpochStartHeight 

func (_IEthCrossChainData *IEthCrossChainDataCaller) GetCurEpochStartHeight(opts *bind.CallOpts) (uint32, error)

GetCurEpochStartHeight is a free data retrieval call binding the contract method 0xa1043138.

Solidity: function getCurEpochStartHeight() constant returns(uint32)

func (*IEthCrossChainDataCaller) GetEthTxHash 

func (_IEthCrossChainData *IEthCrossChainDataCaller) GetEthTxHash(opts *bind.CallOpts, ethTxHashIndex *big.Int) ([32]byte, error)

GetEthTxHash is a free data retrieval call binding the contract method 0xd5b03fca.

Solidity: function getEthTxHash(uint256 ethTxHashIndex) constant returns(bytes32)

func (*IEthCrossChainDataCaller) GetEthTxHashIndex 

func (_IEthCrossChainData *IEthCrossChainDataCaller) GetEthTxHashIndex(opts *bind.CallOpts) (*big.Int, error)

GetEthTxHashIndex is a free data retrieval call binding the contract method 0xab907a6f.

Solidity: function getEthTxHashIndex() constant returns(uint256)

func (*IEthCrossChainDataCaller) GetExtraData 

func (_IEthCrossChainData *IEthCrossChainDataCaller) GetExtraData(opts *bind.CallOpts, key1 [32]byte, key2 [32]byte) ([]byte, error)

GetExtraData is a free data retrieval call binding the contract method 0x2707f9e0.

Solidity: function getExtraData(bytes32 key1, bytes32 key2) constant returns(bytes)

func (*IEthCrossChainDataCaller) Paused 

func (_IEthCrossChainData *IEthCrossChainDataCaller) Paused(opts *bind.CallOpts) (bool, error)

Paused is a free data retrieval call binding the contract method 0xd4bc9601.

Solidity: function paused() constant returns(bool)

type IEthCrossChainDataCallerRaw 

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

IEthCrossChainDataCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*IEthCrossChainDataCallerRaw) Call 

func (_IEthCrossChainData *IEthCrossChainDataCallerRaw) 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 IEthCrossChainDataCallerSession 

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

IEthCrossChainDataCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

func (*IEthCrossChainDataCallerSession) CheckIfFromChainTxExist 

func (_IEthCrossChainData *IEthCrossChainDataCallerSession) CheckIfFromChainTxExist(fromChainId uint64, fromChainTx [32]byte) (bool, error)

CheckIfFromChainTxExist is a free data retrieval call binding the contract method 0xe7eed3f3.

Solidity: function checkIfFromChainTxExist(uint64 fromChainId, bytes32 fromChainTx) constant returns(bool)

func (*IEthCrossChainDataCallerSession) GetCurEpochConPubKeyBytes 

func (_IEthCrossChainData *IEthCrossChainDataCallerSession) GetCurEpochConPubKeyBytes() ([]byte, error)

GetCurEpochConPubKeyBytes is a free data retrieval call binding the contract method 0xa87c3ab2.

Solidity: function getCurEpochConPubKeyBytes() constant returns(bytes)

func (*IEthCrossChainDataCallerSession) GetCurEpochStartHeight 

func (_IEthCrossChainData *IEthCrossChainDataCallerSession) GetCurEpochStartHeight() (uint32, error)

GetCurEpochStartHeight is a free data retrieval call binding the contract method 0xa1043138.

Solidity: function getCurEpochStartHeight() constant returns(uint32)

func (*IEthCrossChainDataCallerSession) GetEthTxHash 

func (_IEthCrossChainData *IEthCrossChainDataCallerSession) GetEthTxHash(ethTxHashIndex *big.Int) ([32]byte, error)

GetEthTxHash is a free data retrieval call binding the contract method 0xd5b03fca.

Solidity: function getEthTxHash(uint256 ethTxHashIndex) constant returns(bytes32)

func (*IEthCrossChainDataCallerSession) GetEthTxHashIndex 

func (_IEthCrossChainData *IEthCrossChainDataCallerSession) GetEthTxHashIndex() (*big.Int, error)

GetEthTxHashIndex is a free data retrieval call binding the contract method 0xab907a6f.

Solidity: function getEthTxHashIndex() constant returns(uint256)

func (*IEthCrossChainDataCallerSession) GetExtraData 

func (_IEthCrossChainData *IEthCrossChainDataCallerSession) GetExtraData(key1 [32]byte, key2 [32]byte) ([]byte, error)

GetExtraData is a free data retrieval call binding the contract method 0x2707f9e0.

Solidity: function getExtraData(bytes32 key1, bytes32 key2) constant returns(bytes)

func (*IEthCrossChainDataCallerSession) Paused 

func (_IEthCrossChainData *IEthCrossChainDataCallerSession) Paused() (bool, error)

Paused is a free data retrieval call binding the contract method 0xd4bc9601.

Solidity: function paused() constant returns(bool)

type IEthCrossChainDataFilterer 

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

IEthCrossChainDataFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewIEthCrossChainDataFilterer 

func NewIEthCrossChainDataFilterer(address common.Address, filterer bind.ContractFilterer) (*IEthCrossChainDataFilterer, error)

NewIEthCrossChainDataFilterer creates a new log filterer instance of IEthCrossChainData, bound to a specific deployed contract.

type IEthCrossChainDataRaw 

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

IEthCrossChainDataRaw is an auto generated low-level Go binding around a Solidity contract.

func (*IEthCrossChainDataRaw) Call 

func (_IEthCrossChainData *IEthCrossChainDataRaw) 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 (*IEthCrossChainDataRaw) Transact 

func (_IEthCrossChainData *IEthCrossChainDataRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*IEthCrossChainDataRaw) Transfer 

func (_IEthCrossChainData *IEthCrossChainDataRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type IEthCrossChainDataSession 

type IEthCrossChainDataSession struct {
	Contract     *IEthCrossChainData // 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
}

IEthCrossChainDataSession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

func (*IEthCrossChainDataSession) AsyncMarkFromChainTxExist 

func (_IEthCrossChainData *IEthCrossChainDataSession) AsyncMarkFromChainTxExist(handler func(*types.Receipt, error), fromChainId uint64, fromChainTx [32]byte) (*types.Transaction, error)

func (*IEthCrossChainDataSession) AsyncPause 

func (_IEthCrossChainData *IEthCrossChainDataSession) AsyncPause(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*IEthCrossChainDataSession) AsyncPutCurEpochConPubKeyBytes 

func (_IEthCrossChainData *IEthCrossChainDataSession) AsyncPutCurEpochConPubKeyBytes(handler func(*types.Receipt, error), curEpochPkBytes []byte) (*types.Transaction, error)

func (*IEthCrossChainDataSession) AsyncPutCurEpochStartHeight 

func (_IEthCrossChainData *IEthCrossChainDataSession) AsyncPutCurEpochStartHeight(handler func(*types.Receipt, error), curEpochStartHeight uint32) (*types.Transaction, error)

func (*IEthCrossChainDataSession) AsyncPutEthTxHash 

func (_IEthCrossChainData *IEthCrossChainDataSession) AsyncPutEthTxHash(handler func(*types.Receipt, error), ethTxHash [32]byte) (*types.Transaction, error)

func (*IEthCrossChainDataSession) AsyncPutExtraData 

func (_IEthCrossChainData *IEthCrossChainDataSession) AsyncPutExtraData(handler func(*types.Receipt, error), key1 [32]byte, key2 [32]byte, value []byte) (*types.Transaction, error)

func (*IEthCrossChainDataSession) AsyncTransferOwnership 

func (_IEthCrossChainData *IEthCrossChainDataSession) AsyncTransferOwnership(handler func(*types.Receipt, error), newOwner common.Address) (*types.Transaction, error)

func (*IEthCrossChainDataSession) AsyncUnpause 

func (_IEthCrossChainData *IEthCrossChainDataSession) AsyncUnpause(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*IEthCrossChainDataSession) CheckIfFromChainTxExist 

func (_IEthCrossChainData *IEthCrossChainDataSession) CheckIfFromChainTxExist(fromChainId uint64, fromChainTx [32]byte) (bool, error)

CheckIfFromChainTxExist is a free data retrieval call binding the contract method 0xe7eed3f3.

Solidity: function checkIfFromChainTxExist(uint64 fromChainId, bytes32 fromChainTx) constant returns(bool)

func (*IEthCrossChainDataSession) GetCurEpochConPubKeyBytes 

func (_IEthCrossChainData *IEthCrossChainDataSession) GetCurEpochConPubKeyBytes() ([]byte, error)

GetCurEpochConPubKeyBytes is a free data retrieval call binding the contract method 0xa87c3ab2.

Solidity: function getCurEpochConPubKeyBytes() constant returns(bytes)

func (*IEthCrossChainDataSession) GetCurEpochStartHeight 

func (_IEthCrossChainData *IEthCrossChainDataSession) GetCurEpochStartHeight() (uint32, error)

GetCurEpochStartHeight is a free data retrieval call binding the contract method 0xa1043138.

Solidity: function getCurEpochStartHeight() constant returns(uint32)

func (*IEthCrossChainDataSession) GetEthTxHash 

func (_IEthCrossChainData *IEthCrossChainDataSession) GetEthTxHash(ethTxHashIndex *big.Int) ([32]byte, error)

GetEthTxHash is a free data retrieval call binding the contract method 0xd5b03fca.

Solidity: function getEthTxHash(uint256 ethTxHashIndex) constant returns(bytes32)

func (*IEthCrossChainDataSession) GetEthTxHashIndex 

func (_IEthCrossChainData *IEthCrossChainDataSession) GetEthTxHashIndex() (*big.Int, error)

GetEthTxHashIndex is a free data retrieval call binding the contract method 0xab907a6f.

Solidity: function getEthTxHashIndex() constant returns(uint256)

func (*IEthCrossChainDataSession) GetExtraData 

func (_IEthCrossChainData *IEthCrossChainDataSession) GetExtraData(key1 [32]byte, key2 [32]byte) ([]byte, error)

GetExtraData is a free data retrieval call binding the contract method 0x2707f9e0.

Solidity: function getExtraData(bytes32 key1, bytes32 key2) constant returns(bytes)

func (*IEthCrossChainDataSession) MarkFromChainTxExist 

func (_IEthCrossChainData *IEthCrossChainDataSession) MarkFromChainTxExist(fromChainId uint64, fromChainTx [32]byte) (*types.Transaction, *types.Receipt, error)

MarkFromChainTxExist is a paid mutator transaction binding the contract method 0x1ce20756.

Solidity: function markFromChainTxExist(uint64 fromChainId, bytes32 fromChainTx) returns(bool)

func (*IEthCrossChainDataSession) Pause 

func (_IEthCrossChainData *IEthCrossChainDataSession) Pause() (*types.Transaction, *types.Receipt, error)

Pause is a paid mutator transaction binding the contract method 0xf4fbb0c8.

Solidity: function pause() returns(bool)

func (*IEthCrossChainDataSession) Paused 

func (_IEthCrossChainData *IEthCrossChainDataSession) Paused() (bool, error)

Paused is a free data retrieval call binding the contract method 0xd4bc9601.

Solidity: function paused() constant returns(bool)

func (*IEthCrossChainDataSession) PutCurEpochConPubKeyBytes 

func (_IEthCrossChainData *IEthCrossChainDataSession) PutCurEpochConPubKeyBytes(curEpochPkBytes []byte) (*types.Transaction, *types.Receipt, error)

PutCurEpochConPubKeyBytes is a paid mutator transaction binding the contract method 0x795c2da6.

Solidity: function putCurEpochConPubKeyBytes(bytes curEpochPkBytes) returns(bool)

func (*IEthCrossChainDataSession) PutCurEpochStartHeight 

func (_IEthCrossChainData *IEthCrossChainDataSession) PutCurEpochStartHeight(curEpochStartHeight uint32) (*types.Transaction, *types.Receipt, error)

PutCurEpochStartHeight is a paid mutator transaction binding the contract method 0x9b9272ae.

Solidity: function putCurEpochStartHeight(uint32 curEpochStartHeight) returns(bool)

func (*IEthCrossChainDataSession) PutEthTxHash 

func (_IEthCrossChainData *IEthCrossChainDataSession) PutEthTxHash(ethTxHash [32]byte) (*types.Transaction, *types.Receipt, error)

PutEthTxHash is a paid mutator transaction binding the contract method 0x93645d57.

Solidity: function putEthTxHash(bytes32 ethTxHash) returns(bool)

func (*IEthCrossChainDataSession) PutExtraData 

func (_IEthCrossChainData *IEthCrossChainDataSession) PutExtraData(key1 [32]byte, key2 [32]byte, value []byte) (*types.Transaction, *types.Receipt, error)

PutExtraData is a paid mutator transaction binding the contract method 0x351f0ea0.

Solidity: function putExtraData(bytes32 key1, bytes32 key2, bytes value) returns(bool)

func (*IEthCrossChainDataSession) TransferOwnership 

func (_IEthCrossChainData *IEthCrossChainDataSession) TransferOwnership(newOwner common.Address) (*types.Transaction, *types.Receipt, error)

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

Solidity: function transferOwnership(address newOwner) returns()

func (*IEthCrossChainDataSession) Unpause 

func (_IEthCrossChainData *IEthCrossChainDataSession) Unpause() (*types.Transaction, *types.Receipt, error)

Unpause is a paid mutator transaction binding the contract method 0x63c37526.

Solidity: function unpause() returns(bool)

type IEthCrossChainDataTransactor 

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

IEthCrossChainDataTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewIEthCrossChainDataTransactor 

func NewIEthCrossChainDataTransactor(address common.Address, transactor bind.ContractTransactor) (*IEthCrossChainDataTransactor, error)

NewIEthCrossChainDataTransactor creates a new write-only instance of IEthCrossChainData, bound to a specific deployed contract.

func (*IEthCrossChainDataTransactor) AsyncMarkFromChainTxExist 

func (_IEthCrossChainData *IEthCrossChainDataTransactor) AsyncMarkFromChainTxExist(handler func(*types.Receipt, error), opts *bind.TransactOpts, fromChainId uint64, fromChainTx [32]byte) (*types.Transaction, error)

func (*IEthCrossChainDataTransactor) AsyncPause 

func (_IEthCrossChainData *IEthCrossChainDataTransactor) AsyncPause(handler func(*types.Receipt, error), opts *bind.TransactOpts) (*types.Transaction, error)

func (*IEthCrossChainDataTransactor) AsyncPutCurEpochConPubKeyBytes 

func (_IEthCrossChainData *IEthCrossChainDataTransactor) AsyncPutCurEpochConPubKeyBytes(handler func(*types.Receipt, error), opts *bind.TransactOpts, curEpochPkBytes []byte) (*types.Transaction, error)

func (*IEthCrossChainDataTransactor) AsyncPutCurEpochStartHeight 

func (_IEthCrossChainData *IEthCrossChainDataTransactor) AsyncPutCurEpochStartHeight(handler func(*types.Receipt, error), opts *bind.TransactOpts, curEpochStartHeight uint32) (*types.Transaction, error)

func (*IEthCrossChainDataTransactor) AsyncPutEthTxHash 

func (_IEthCrossChainData *IEthCrossChainDataTransactor) AsyncPutEthTxHash(handler func(*types.Receipt, error), opts *bind.TransactOpts, ethTxHash [32]byte) (*types.Transaction, error)

func (*IEthCrossChainDataTransactor) AsyncPutExtraData 

func (_IEthCrossChainData *IEthCrossChainDataTransactor) AsyncPutExtraData(handler func(*types.Receipt, error), opts *bind.TransactOpts, key1 [32]byte, key2 [32]byte, value []byte) (*types.Transaction, error)

func (*IEthCrossChainDataTransactor) AsyncTransferOwnership 

func (_IEthCrossChainData *IEthCrossChainDataTransactor) AsyncTransferOwnership(handler func(*types.Receipt, error), opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

func (*IEthCrossChainDataTransactor) AsyncUnpause 

func (_IEthCrossChainData *IEthCrossChainDataTransactor) AsyncUnpause(handler func(*types.Receipt, error), opts *bind.TransactOpts) (*types.Transaction, error)

func (*IEthCrossChainDataTransactor) MarkFromChainTxExist 

func (_IEthCrossChainData *IEthCrossChainDataTransactor) MarkFromChainTxExist(opts *bind.TransactOpts, fromChainId uint64, fromChainTx [32]byte) (*types.Transaction, *types.Receipt, error)

MarkFromChainTxExist is a paid mutator transaction binding the contract method 0x1ce20756.

Solidity: function markFromChainTxExist(uint64 fromChainId, bytes32 fromChainTx) returns(bool)

func (*IEthCrossChainDataTransactor) Pause 

func (_IEthCrossChainData *IEthCrossChainDataTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

Pause is a paid mutator transaction binding the contract method 0xf4fbb0c8.

Solidity: function pause() returns(bool)

func (*IEthCrossChainDataTransactor) PutCurEpochConPubKeyBytes 

func (_IEthCrossChainData *IEthCrossChainDataTransactor) PutCurEpochConPubKeyBytes(opts *bind.TransactOpts, curEpochPkBytes []byte) (*types.Transaction, *types.Receipt, error)

PutCurEpochConPubKeyBytes is a paid mutator transaction binding the contract method 0x795c2da6.

Solidity: function putCurEpochConPubKeyBytes(bytes curEpochPkBytes) returns(bool)

func (*IEthCrossChainDataTransactor) PutCurEpochStartHeight 

func (_IEthCrossChainData *IEthCrossChainDataTransactor) PutCurEpochStartHeight(opts *bind.TransactOpts, curEpochStartHeight uint32) (*types.Transaction, *types.Receipt, error)

PutCurEpochStartHeight is a paid mutator transaction binding the contract method 0x9b9272ae.

Solidity: function putCurEpochStartHeight(uint32 curEpochStartHeight) returns(bool)

func (*IEthCrossChainDataTransactor) PutEthTxHash 

func (_IEthCrossChainData *IEthCrossChainDataTransactor) PutEthTxHash(opts *bind.TransactOpts, ethTxHash [32]byte) (*types.Transaction, *types.Receipt, error)

PutEthTxHash is a paid mutator transaction binding the contract method 0x93645d57.

Solidity: function putEthTxHash(bytes32 ethTxHash) returns(bool)

func (*IEthCrossChainDataTransactor) PutExtraData 

func (_IEthCrossChainData *IEthCrossChainDataTransactor) PutExtraData(opts *bind.TransactOpts, key1 [32]byte, key2 [32]byte, value []byte) (*types.Transaction, *types.Receipt, error)

PutExtraData is a paid mutator transaction binding the contract method 0x351f0ea0.

Solidity: function putExtraData(bytes32 key1, bytes32 key2, bytes value) returns(bool)

func (*IEthCrossChainDataTransactor) TransferOwnership 

func (_IEthCrossChainData *IEthCrossChainDataTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, *types.Receipt, error)

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

Solidity: function transferOwnership(address newOwner) returns()

func (*IEthCrossChainDataTransactor) Unpause 

func (_IEthCrossChainData *IEthCrossChainDataTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

Unpause is a paid mutator transaction binding the contract method 0x63c37526.

Solidity: function unpause() returns(bool)

type IEthCrossChainDataTransactorRaw 

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

IEthCrossChainDataTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*IEthCrossChainDataTransactorRaw) Transact 

func (_IEthCrossChainData *IEthCrossChainDataTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*IEthCrossChainDataTransactorRaw) Transfer 

func (_IEthCrossChainData *IEthCrossChainDataTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type IEthCrossChainDataTransactorSession 

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

IEthCrossChainDataTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

func (*IEthCrossChainDataTransactorSession) AsyncMarkFromChainTxExist 

func (_IEthCrossChainData *IEthCrossChainDataTransactorSession) AsyncMarkFromChainTxExist(handler func(*types.Receipt, error), fromChainId uint64, fromChainTx [32]byte) (*types.Transaction, error)

func (*IEthCrossChainDataTransactorSession) AsyncPause 

func (_IEthCrossChainData *IEthCrossChainDataTransactorSession) AsyncPause(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*IEthCrossChainDataTransactorSession) AsyncPutCurEpochConPubKeyBytes 

func (_IEthCrossChainData *IEthCrossChainDataTransactorSession) AsyncPutCurEpochConPubKeyBytes(handler func(*types.Receipt, error), curEpochPkBytes []byte) (*types.Transaction, error)

func (*IEthCrossChainDataTransactorSession) AsyncPutCurEpochStartHeight 

func (_IEthCrossChainData *IEthCrossChainDataTransactorSession) AsyncPutCurEpochStartHeight(handler func(*types.Receipt, error), curEpochStartHeight uint32) (*types.Transaction, error)

func (*IEthCrossChainDataTransactorSession) AsyncPutEthTxHash 

func (_IEthCrossChainData *IEthCrossChainDataTransactorSession) AsyncPutEthTxHash(handler func(*types.Receipt, error), ethTxHash [32]byte) (*types.Transaction, error)

func (*IEthCrossChainDataTransactorSession) AsyncPutExtraData 

func (_IEthCrossChainData *IEthCrossChainDataTransactorSession) AsyncPutExtraData(handler func(*types.Receipt, error), key1 [32]byte, key2 [32]byte, value []byte) (*types.Transaction, error)

func (*IEthCrossChainDataTransactorSession) AsyncTransferOwnership 

func (_IEthCrossChainData *IEthCrossChainDataTransactorSession) AsyncTransferOwnership(handler func(*types.Receipt, error), newOwner common.Address) (*types.Transaction, error)

func (*IEthCrossChainDataTransactorSession) AsyncUnpause 

func (_IEthCrossChainData *IEthCrossChainDataTransactorSession) AsyncUnpause(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*IEthCrossChainDataTransactorSession) MarkFromChainTxExist 

func (_IEthCrossChainData *IEthCrossChainDataTransactorSession) MarkFromChainTxExist(fromChainId uint64, fromChainTx [32]byte) (*types.Transaction, *types.Receipt, error)

MarkFromChainTxExist is a paid mutator transaction binding the contract method 0x1ce20756.

Solidity: function markFromChainTxExist(uint64 fromChainId, bytes32 fromChainTx) returns(bool)

func (*IEthCrossChainDataTransactorSession) Pause 

func (_IEthCrossChainData *IEthCrossChainDataTransactorSession) Pause() (*types.Transaction, *types.Receipt, error)

Pause is a paid mutator transaction binding the contract method 0xf4fbb0c8.

Solidity: function pause() returns(bool)

func (*IEthCrossChainDataTransactorSession) PutCurEpochConPubKeyBytes 

func (_IEthCrossChainData *IEthCrossChainDataTransactorSession) PutCurEpochConPubKeyBytes(curEpochPkBytes []byte) (*types.Transaction, *types.Receipt, error)

PutCurEpochConPubKeyBytes is a paid mutator transaction binding the contract method 0x795c2da6.

Solidity: function putCurEpochConPubKeyBytes(bytes curEpochPkBytes) returns(bool)

func (*IEthCrossChainDataTransactorSession) PutCurEpochStartHeight 

func (_IEthCrossChainData *IEthCrossChainDataTransactorSession) PutCurEpochStartHeight(curEpochStartHeight uint32) (*types.Transaction, *types.Receipt, error)

PutCurEpochStartHeight is a paid mutator transaction binding the contract method 0x9b9272ae.

Solidity: function putCurEpochStartHeight(uint32 curEpochStartHeight) returns(bool)

func (*IEthCrossChainDataTransactorSession) PutEthTxHash 

func (_IEthCrossChainData *IEthCrossChainDataTransactorSession) PutEthTxHash(ethTxHash [32]byte) (*types.Transaction, *types.Receipt, error)

PutEthTxHash is a paid mutator transaction binding the contract method 0x93645d57.

Solidity: function putEthTxHash(bytes32 ethTxHash) returns(bool)

func (*IEthCrossChainDataTransactorSession) PutExtraData 

func (_IEthCrossChainData *IEthCrossChainDataTransactorSession) PutExtraData(key1 [32]byte, key2 [32]byte, value []byte) (*types.Transaction, *types.Receipt, error)

PutExtraData is a paid mutator transaction binding the contract method 0x351f0ea0.

Solidity: function putExtraData(bytes32 key1, bytes32 key2, bytes value) returns(bool)

func (*IEthCrossChainDataTransactorSession) TransferOwnership 

func (_IEthCrossChainData *IEthCrossChainDataTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, *types.Receipt, error)

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

Solidity: function transferOwnership(address newOwner) returns()

func (*IEthCrossChainDataTransactorSession) Unpause 

func (_IEthCrossChainData *IEthCrossChainDataTransactorSession) Unpause() (*types.Transaction, *types.Receipt, error)

Unpause is a paid mutator transaction binding the contract method 0x63c37526.

Solidity: function unpause() returns(bool)

type IEthCrossChainManager 

type IEthCrossChainManager struct {
	IEthCrossChainManagerCaller     // Read-only binding to the contract
	IEthCrossChainManagerTransactor // Write-only binding to the contract
	IEthCrossChainManagerFilterer   // Log filterer for contract events
}

IEthCrossChainManager is an auto generated Go binding around a Solidity contract.

func NewIEthCrossChainManager 

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

NewIEthCrossChainManager creates a new instance of IEthCrossChainManager, bound to a specific deployed contract.

type IEthCrossChainManagerCaller 

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

IEthCrossChainManagerCaller is an auto generated read-only Go binding around a Solidity contract.

func NewIEthCrossChainManagerCaller 

func NewIEthCrossChainManagerCaller(address common.Address, caller bind.ContractCaller) (*IEthCrossChainManagerCaller, error)

NewIEthCrossChainManagerCaller creates a new read-only instance of IEthCrossChainManager, bound to a specific deployed contract.

type IEthCrossChainManagerCallerRaw 

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

IEthCrossChainManagerCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*IEthCrossChainManagerCallerRaw) Call 

func (_IEthCrossChainManager *IEthCrossChainManagerCallerRaw) 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 IEthCrossChainManagerCallerSession 

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

IEthCrossChainManagerCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

type IEthCrossChainManagerFilterer 

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

IEthCrossChainManagerFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewIEthCrossChainManagerFilterer 

func NewIEthCrossChainManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*IEthCrossChainManagerFilterer, error)

NewIEthCrossChainManagerFilterer creates a new log filterer instance of IEthCrossChainManager, bound to a specific deployed contract.

type IEthCrossChainManagerRaw 

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

IEthCrossChainManagerRaw is an auto generated low-level Go binding around a Solidity contract.

func (*IEthCrossChainManagerRaw) Call 

func (_IEthCrossChainManager *IEthCrossChainManagerRaw) 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 (*IEthCrossChainManagerRaw) Transact 

func (_IEthCrossChainManager *IEthCrossChainManagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*IEthCrossChainManagerRaw) Transfer 

func (_IEthCrossChainManager *IEthCrossChainManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type IEthCrossChainManagerSession 

type IEthCrossChainManagerSession struct {
	Contract     *IEthCrossChainManager // 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
}

IEthCrossChainManagerSession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

func (*IEthCrossChainManagerSession) AsyncCrossChain 

func (_IEthCrossChainManager *IEthCrossChainManagerSession) AsyncCrossChain(handler func(*types.Receipt, error), _toChainId uint64, _toContract []byte, _method []byte, _txData []byte) (*types.Transaction, error)

func (*IEthCrossChainManagerSession) CrossChain 

func (_IEthCrossChainManager *IEthCrossChainManagerSession) CrossChain(_toChainId uint64, _toContract []byte, _method []byte, _txData []byte) (*types.Transaction, *types.Receipt, error)

CrossChain is a paid mutator transaction binding the contract method 0x1f5045a8.

Solidity: function crossChain(uint64 _toChainId, bytes _toContract, bytes _method, bytes _txData) returns(bool)

type IEthCrossChainManagerTransactor 

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

IEthCrossChainManagerTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewIEthCrossChainManagerTransactor 

func NewIEthCrossChainManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*IEthCrossChainManagerTransactor, error)

NewIEthCrossChainManagerTransactor creates a new write-only instance of IEthCrossChainManager, bound to a specific deployed contract.

func (*IEthCrossChainManagerTransactor) AsyncCrossChain 

func (_IEthCrossChainManager *IEthCrossChainManagerTransactor) AsyncCrossChain(handler func(*types.Receipt, error), opts *bind.TransactOpts, _toChainId uint64, _toContract []byte, _method []byte, _txData []byte) (*types.Transaction, error)

func (*IEthCrossChainManagerTransactor) CrossChain 

func (_IEthCrossChainManager *IEthCrossChainManagerTransactor) CrossChain(opts *bind.TransactOpts, _toChainId uint64, _toContract []byte, _method []byte, _txData []byte) (*types.Transaction, *types.Receipt, error)

CrossChain is a paid mutator transaction binding the contract method 0x1f5045a8.

Solidity: function crossChain(uint64 _toChainId, bytes _toContract, bytes _method, bytes _txData) returns(bool)

type IEthCrossChainManagerTransactorRaw 

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

IEthCrossChainManagerTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*IEthCrossChainManagerTransactorRaw) Transact 

func (_IEthCrossChainManager *IEthCrossChainManagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*IEthCrossChainManagerTransactorRaw) Transfer 

func (_IEthCrossChainManager *IEthCrossChainManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type IEthCrossChainManagerTransactorSession 

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

IEthCrossChainManagerTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

func (*IEthCrossChainManagerTransactorSession) AsyncCrossChain 

func (_IEthCrossChainManager *IEthCrossChainManagerTransactorSession) AsyncCrossChain(handler func(*types.Receipt, error), _toChainId uint64, _toContract []byte, _method []byte, _txData []byte) (*types.Transaction, error)

func (*IEthCrossChainManagerTransactorSession) CrossChain 

func (_IEthCrossChainManager *IEthCrossChainManagerTransactorSession) CrossChain(_toChainId uint64, _toContract []byte, _method []byte, _txData []byte) (*types.Transaction, *types.Receipt, error)

CrossChain is a paid mutator transaction binding the contract method 0x1f5045a8.

Solidity: function crossChain(uint64 _toChainId, bytes _toContract, bytes _method, bytes _txData) returns(bool)

type IUpgradableECCM 

type IUpgradableECCM struct {
	IUpgradableECCMCaller     // Read-only binding to the contract
	IUpgradableECCMTransactor // Write-only binding to the contract
	IUpgradableECCMFilterer   // Log filterer for contract events
}

IUpgradableECCM is an auto generated Go binding around a Solidity contract.

func NewIUpgradableECCM 

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

NewIUpgradableECCM creates a new instance of IUpgradableECCM, bound to a specific deployed contract.

type IUpgradableECCMCaller 

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

IUpgradableECCMCaller is an auto generated read-only Go binding around a Solidity contract.

func NewIUpgradableECCMCaller 

func NewIUpgradableECCMCaller(address common.Address, caller bind.ContractCaller) (*IUpgradableECCMCaller, error)

NewIUpgradableECCMCaller creates a new read-only instance of IUpgradableECCM, bound to a specific deployed contract.

func (*IUpgradableECCMCaller) IsOwner 

func (_IUpgradableECCM *IUpgradableECCMCaller) IsOwner(opts *bind.CallOpts) (bool, error)

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

Solidity: function isOwner() constant returns(bool)

func (*IUpgradableECCMCaller) Paused 

func (_IUpgradableECCM *IUpgradableECCMCaller) Paused(opts *bind.CallOpts) (bool, error)

Paused is a free data retrieval call binding the contract method 0xd4bc9601.

Solidity: function paused() constant returns(bool)

type IUpgradableECCMCallerRaw 

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

IUpgradableECCMCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*IUpgradableECCMCallerRaw) Call 

func (_IUpgradableECCM *IUpgradableECCMCallerRaw) 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 IUpgradableECCMCallerSession 

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

IUpgradableECCMCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

func (*IUpgradableECCMCallerSession) IsOwner 

func (_IUpgradableECCM *IUpgradableECCMCallerSession) IsOwner() (bool, error)

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

Solidity: function isOwner() constant returns(bool)

func (*IUpgradableECCMCallerSession) Paused 

func (_IUpgradableECCM *IUpgradableECCMCallerSession) Paused() (bool, error)

Paused is a free data retrieval call binding the contract method 0xd4bc9601.

Solidity: function paused() constant returns(bool)

type IUpgradableECCMFilterer 

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

IUpgradableECCMFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewIUpgradableECCMFilterer 

func NewIUpgradableECCMFilterer(address common.Address, filterer bind.ContractFilterer) (*IUpgradableECCMFilterer, error)

NewIUpgradableECCMFilterer creates a new log filterer instance of IUpgradableECCM, bound to a specific deployed contract.

type IUpgradableECCMRaw 

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

IUpgradableECCMRaw is an auto generated low-level Go binding around a Solidity contract.

func (*IUpgradableECCMRaw) Call 

func (_IUpgradableECCM *IUpgradableECCMRaw) 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 (*IUpgradableECCMRaw) Transact 

func (_IUpgradableECCM *IUpgradableECCMRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*IUpgradableECCMRaw) Transfer 

func (_IUpgradableECCM *IUpgradableECCMRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type IUpgradableECCMSession 

type IUpgradableECCMSession struct {
	Contract     *IUpgradableECCM  // 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
}

IUpgradableECCMSession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

func (*IUpgradableECCMSession) AsyncPause 

func (_IUpgradableECCM *IUpgradableECCMSession) AsyncPause(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*IUpgradableECCMSession) AsyncUnpause 

func (_IUpgradableECCM *IUpgradableECCMSession) AsyncUnpause(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*IUpgradableECCMSession) AsyncUpgradeToNew 

func (_IUpgradableECCM *IUpgradableECCMSession) AsyncUpgradeToNew(handler func(*types.Receipt, error), arg0 common.Address) (*types.Transaction, error)

func (*IUpgradableECCMSession) IsOwner 

func (_IUpgradableECCM *IUpgradableECCMSession) IsOwner() (bool, error)

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

Solidity: function isOwner() constant returns(bool)

func (*IUpgradableECCMSession) Pause 

func (_IUpgradableECCM *IUpgradableECCMSession) Pause() (*types.Transaction, *types.Receipt, error)

Pause is a paid mutator transaction binding the contract method 0xf4fbb0c8.

Solidity: function pause() returns(bool)

func (*IUpgradableECCMSession) Paused 

func (_IUpgradableECCM *IUpgradableECCMSession) Paused() (bool, error)

Paused is a free data retrieval call binding the contract method 0xd4bc9601.

Solidity: function paused() constant returns(bool)

func (*IUpgradableECCMSession) Unpause 

func (_IUpgradableECCM *IUpgradableECCMSession) Unpause() (*types.Transaction, *types.Receipt, error)

Unpause is a paid mutator transaction binding the contract method 0x63c37526.

Solidity: function unpause() returns(bool)

func (*IUpgradableECCMSession) UpgradeToNew 

func (_IUpgradableECCM *IUpgradableECCMSession) UpgradeToNew(arg0 common.Address) (*types.Transaction, *types.Receipt, error)

UpgradeToNew is a paid mutator transaction binding the contract method 0xf4e614d2.

Solidity: function upgradeToNew(address ) returns(bool)

type IUpgradableECCMTransactor 

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

IUpgradableECCMTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewIUpgradableECCMTransactor 

func NewIUpgradableECCMTransactor(address common.Address, transactor bind.ContractTransactor) (*IUpgradableECCMTransactor, error)

NewIUpgradableECCMTransactor creates a new write-only instance of IUpgradableECCM, bound to a specific deployed contract.

func (*IUpgradableECCMTransactor) AsyncPause 

func (_IUpgradableECCM *IUpgradableECCMTransactor) AsyncPause(handler func(*types.Receipt, error), opts *bind.TransactOpts) (*types.Transaction, error)

func (*IUpgradableECCMTransactor) AsyncUnpause 

func (_IUpgradableECCM *IUpgradableECCMTransactor) AsyncUnpause(handler func(*types.Receipt, error), opts *bind.TransactOpts) (*types.Transaction, error)

func (*IUpgradableECCMTransactor) AsyncUpgradeToNew 

func (_IUpgradableECCM *IUpgradableECCMTransactor) AsyncUpgradeToNew(handler func(*types.Receipt, error), opts *bind.TransactOpts, arg0 common.Address) (*types.Transaction, error)

func (*IUpgradableECCMTransactor) Pause 

func (_IUpgradableECCM *IUpgradableECCMTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

Pause is a paid mutator transaction binding the contract method 0xf4fbb0c8.

Solidity: function pause() returns(bool)

func (*IUpgradableECCMTransactor) Unpause 

func (_IUpgradableECCM *IUpgradableECCMTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

Unpause is a paid mutator transaction binding the contract method 0x63c37526.

Solidity: function unpause() returns(bool)

func (*IUpgradableECCMTransactor) UpgradeToNew 

func (_IUpgradableECCM *IUpgradableECCMTransactor) UpgradeToNew(opts *bind.TransactOpts, arg0 common.Address) (*types.Transaction, *types.Receipt, error)

UpgradeToNew is a paid mutator transaction binding the contract method 0xf4e614d2.

Solidity: function upgradeToNew(address ) returns(bool)

type IUpgradableECCMTransactorRaw 

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

IUpgradableECCMTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*IUpgradableECCMTransactorRaw) Transact 

func (_IUpgradableECCM *IUpgradableECCMTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*IUpgradableECCMTransactorRaw) Transfer 

func (_IUpgradableECCM *IUpgradableECCMTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type IUpgradableECCMTransactorSession 

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

IUpgradableECCMTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

func (*IUpgradableECCMTransactorSession) AsyncPause 

func (_IUpgradableECCM *IUpgradableECCMTransactorSession) AsyncPause(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*IUpgradableECCMTransactorSession) AsyncUnpause 

func (_IUpgradableECCM *IUpgradableECCMTransactorSession) AsyncUnpause(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*IUpgradableECCMTransactorSession) AsyncUpgradeToNew 

func (_IUpgradableECCM *IUpgradableECCMTransactorSession) AsyncUpgradeToNew(handler func(*types.Receipt, error), arg0 common.Address) (*types.Transaction, error)

func (*IUpgradableECCMTransactorSession) Pause 

func (_IUpgradableECCM *IUpgradableECCMTransactorSession) Pause() (*types.Transaction, *types.Receipt, error)

Pause is a paid mutator transaction binding the contract method 0xf4fbb0c8.

Solidity: function pause() returns(bool)

func (*IUpgradableECCMTransactorSession) Unpause 

func (_IUpgradableECCM *IUpgradableECCMTransactorSession) Unpause() (*types.Transaction, *types.Receipt, error)

Unpause is a paid mutator transaction binding the contract method 0x63c37526.

Solidity: function unpause() returns(bool)

func (*IUpgradableECCMTransactorSession) UpgradeToNew 

func (_IUpgradableECCM *IUpgradableECCMTransactorSession) UpgradeToNew(arg0 common.Address) (*types.Transaction, *types.Receipt, error)

UpgradeToNew is a paid mutator transaction binding the contract method 0xf4e614d2.

Solidity: function upgradeToNew(address ) returns(bool)

type Ownable 

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

Ownable is an auto generated Go binding around a Solidity contract.

func NewOwnable 

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

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

type OwnableCaller 

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

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

func NewOwnableCaller 

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

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

func (*OwnableCaller) IsOwner 

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

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

Solidity: function isOwner() constant returns(bool)

func (*OwnableCaller) Owner 

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

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

Solidity: function owner() constant returns(address)

type OwnableCallerRaw 

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

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

func (*OwnableCallerRaw) Call 

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

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

type OwnableCallerSession 

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

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

func (*OwnableCallerSession) IsOwner 

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

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

Solidity: function isOwner() constant returns(bool)

func (*OwnableCallerSession) Owner 

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

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

Solidity: function owner() constant returns(address)

type OwnableFilterer 

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

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

func NewOwnableFilterer 

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

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

func (*OwnableFilterer) FilterOwnershipTransferred 

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

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

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

func (*OwnableFilterer) ParseOwnershipTransferred 

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

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

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

func (*OwnableFilterer) WatchOwnershipTransferred 

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

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

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

type OwnableOwnershipTransferred 

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

OwnableOwnershipTransferred represents a OwnershipTransferred event raised by the Ownable contract.

type OwnableOwnershipTransferredIterator 

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

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

func (*OwnableOwnershipTransferredIterator) Close 

func (it *OwnableOwnershipTransferredIterator) Close() error

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

func (*OwnableOwnershipTransferredIterator) Error 

func (it *OwnableOwnershipTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*OwnableOwnershipTransferredIterator) Next 

func (it *OwnableOwnershipTransferredIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type OwnableRaw 

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

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

func (*OwnableRaw) Call 

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

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

func (*OwnableRaw) Transact 

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

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

func (*OwnableRaw) Transfer 

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

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

type OwnableSession 

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

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

func (*OwnableSession) AsyncRenounceOwnership 

func (_Ownable *OwnableSession) AsyncRenounceOwnership(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*OwnableSession) AsyncTransferOwnership 

func (_Ownable *OwnableSession) AsyncTransferOwnership(handler func(*types.Receipt, error), newOwner common.Address) (*types.Transaction, error)

func (*OwnableSession) IsOwner 

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

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

Solidity: function isOwner() constant returns(bool)

func (*OwnableSession) Owner 

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

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

Solidity: function owner() constant returns(address)

func (*OwnableSession) RenounceOwnership 

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

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

Solidity: function renounceOwnership() returns()

func (*OwnableSession) TransferOwnership 

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

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

Solidity: function transferOwnership(address newOwner) returns()

type OwnableTransactor 

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

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

func NewOwnableTransactor 

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

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

func (*OwnableTransactor) AsyncRenounceOwnership 

func (_Ownable *OwnableTransactor) AsyncRenounceOwnership(handler func(*types.Receipt, error), opts *bind.TransactOpts) (*types.Transaction, error)

func (*OwnableTransactor) AsyncTransferOwnership 

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

func (*OwnableTransactor) RenounceOwnership 

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

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

Solidity: function renounceOwnership() returns()

func (*OwnableTransactor) TransferOwnership 

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

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

Solidity: function transferOwnership(address newOwner) returns()

type OwnableTransactorRaw 

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

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

func (*OwnableTransactorRaw) Transact 

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

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

func (*OwnableTransactorRaw) Transfer 

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

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

type OwnableTransactorSession 

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

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

func (*OwnableTransactorSession) AsyncRenounceOwnership 

func (_Ownable *OwnableTransactorSession) AsyncRenounceOwnership(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*OwnableTransactorSession) AsyncTransferOwnership 

func (_Ownable *OwnableTransactorSession) AsyncTransferOwnership(handler func(*types.Receipt, error), newOwner common.Address) (*types.Transaction, error)

func (*OwnableTransactorSession) RenounceOwnership 

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

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

Solidity: function renounceOwnership() returns()

func (*OwnableTransactorSession) TransferOwnership 

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

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

Solidity: function transferOwnership(address newOwner) returns()

type Pausable 

type Pausable struct {
	PausableCaller     // Read-only binding to the contract
	PausableTransactor // Write-only binding to the contract
	PausableFilterer   // Log filterer for contract events
}

Pausable is an auto generated Go binding around a Solidity contract.

func NewPausable 

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

NewPausable creates a new instance of Pausable, bound to a specific deployed contract.

type PausableCaller 

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

PausableCaller is an auto generated read-only Go binding around a Solidity contract.

func NewPausableCaller 

func NewPausableCaller(address common.Address, caller bind.ContractCaller) (*PausableCaller, error)

NewPausableCaller creates a new read-only instance of Pausable, bound to a specific deployed contract.

func (*PausableCaller) Paused 

func (_Pausable *PausableCaller) Paused(opts *bind.CallOpts) (bool, error)

Paused is a free data retrieval call binding the contract method 0xd4bc9601.

Solidity: function paused() constant returns(bool)

type PausableCallerRaw 

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

PausableCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*PausableCallerRaw) Call 

func (_Pausable *PausableCallerRaw) 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 PausableCallerSession 

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

PausableCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

func (*PausableCallerSession) Paused 

func (_Pausable *PausableCallerSession) Paused() (bool, error)

Paused is a free data retrieval call binding the contract method 0xd4bc9601.

Solidity: function paused() constant returns(bool)

type PausableFilterer 

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

PausableFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewPausableFilterer 

func NewPausableFilterer(address common.Address, filterer bind.ContractFilterer) (*PausableFilterer, error)

NewPausableFilterer creates a new log filterer instance of Pausable, bound to a specific deployed contract.

func (*PausableFilterer) FilterPaused 

func (_Pausable *PausableFilterer) FilterPaused(opts *bind.FilterOpts) (*PausablePausedIterator, error)

FilterPaused is a free log retrieval operation binding the contract event 0x000000000000000000000000000000000000000000000000000000003572985a.

Solidity: event Paused(address account)

func (*PausableFilterer) FilterUnpaused 

func (_Pausable *PausableFilterer) FilterUnpaused(opts *bind.FilterOpts) (*PausableUnpausedIterator, error)

FilterUnpaused is a free log retrieval operation binding the contract event 0x0000000000000000000000000000000000000000000000000000000044693cad.

Solidity: event Unpaused(address account)

func (*PausableFilterer) ParsePaused 

func (_Pausable *PausableFilterer) ParsePaused(log types.Log) (*PausablePaused, error)

ParsePaused is a log parse operation binding the contract event 0x000000000000000000000000000000000000000000000000000000003572985a.

Solidity: event Paused(address account)

func (*PausableFilterer) ParseUnpaused 

func (_Pausable *PausableFilterer) ParseUnpaused(log types.Log) (*PausableUnpaused, error)

ParseUnpaused is a log parse operation binding the contract event 0x0000000000000000000000000000000000000000000000000000000044693cad.

Solidity: event Unpaused(address account)

func (*PausableFilterer) WatchPaused 

func (_Pausable *PausableFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *PausablePaused) (event.Subscription, error)

WatchPaused is a free log subscription operation binding the contract event 0x000000000000000000000000000000000000000000000000000000003572985a.

Solidity: event Paused(address account)

func (*PausableFilterer) WatchUnpaused 

func (_Pausable *PausableFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *PausableUnpaused) (event.Subscription, error)

WatchUnpaused is a free log subscription operation binding the contract event 0x0000000000000000000000000000000000000000000000000000000044693cad.

Solidity: event Unpaused(address account)

type PausablePaused 

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

PausablePaused represents a Paused event raised by the Pausable contract.

type PausablePausedIterator 

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

PausablePausedIterator is returned from FilterPaused and is used to iterate over the raw logs and unpacked data for Paused events raised by the Pausable contract.

func (*PausablePausedIterator) Close 

func (it *PausablePausedIterator) Close() error

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

func (*PausablePausedIterator) Error 

func (it *PausablePausedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*PausablePausedIterator) Next 

func (it *PausablePausedIterator) 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 PausableRaw 

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

PausableRaw is an auto generated low-level Go binding around a Solidity contract.

func (*PausableRaw) Call 

func (_Pausable *PausableRaw) 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 (*PausableRaw) Transact 

func (_Pausable *PausableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*PausableRaw) Transfer 

func (_Pausable *PausableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type PausableSession 

type PausableSession struct {
	Contract     *Pausable         // 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
}

PausableSession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

func (*PausableSession) Paused 

func (_Pausable *PausableSession) Paused() (bool, error)

Paused is a free data retrieval call binding the contract method 0xd4bc9601.

Solidity: function paused() constant returns(bool)

type PausableTransactor 

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

PausableTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewPausableTransactor 

func NewPausableTransactor(address common.Address, transactor bind.ContractTransactor) (*PausableTransactor, error)

NewPausableTransactor creates a new write-only instance of Pausable, bound to a specific deployed contract.

type PausableTransactorRaw 

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

PausableTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*PausableTransactorRaw) Transact 

func (_Pausable *PausableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*PausableTransactorRaw) Transfer 

func (_Pausable *PausableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type PausableTransactorSession 

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

PausableTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

type PausableUnpaused 

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

PausableUnpaused represents a Unpaused event raised by the Pausable contract.

type PausableUnpausedIterator 

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

PausableUnpausedIterator is returned from FilterUnpaused and is used to iterate over the raw logs and unpacked data for Unpaused events raised by the Pausable contract.

func (*PausableUnpausedIterator) Close 

func (it *PausableUnpausedIterator) Close() error

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

func (*PausableUnpausedIterator) Error 

func (it *PausableUnpausedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*PausableUnpausedIterator) Next 

func (it *PausableUnpausedIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type SafeMath 

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

SafeMath is an auto generated Go binding around a Solidity contract.

func DeploySafeMath 

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

DeploySafeMath deploys a new 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 a Solidity 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 a Solidity 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 a Solidity 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 a Solidity 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 a Solidity 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, *types.Receipt, error)

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

func (*SafeMathRaw) Transfer 

func (_SafeMath *SafeMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, 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 a Solidity 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 a Solidity 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 a Solidity contract.

func (*SafeMathTransactorRaw) Transact 

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

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

func (*SafeMathTransactorRaw) Transfer 

func (_SafeMath *SafeMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, 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 a Solidity contract, with pre-set transact options.

type UpgradableECCM 

type UpgradableECCM struct {
	UpgradableECCMCaller     // Read-only binding to the contract
	UpgradableECCMTransactor // Write-only binding to the contract
	UpgradableECCMFilterer   // Log filterer for contract events
}

UpgradableECCM is an auto generated Go binding around a Solidity contract.

func DeployUpgradableECCM 

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

DeployUpgradableECCM deploys a new contract, binding an instance of UpgradableECCM to it.

func NewUpgradableECCM 

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

NewUpgradableECCM creates a new instance of UpgradableECCM, bound to a specific deployed contract.

type UpgradableECCMCaller 

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

UpgradableECCMCaller is an auto generated read-only Go binding around a Solidity contract.

func NewUpgradableECCMCaller 

func NewUpgradableECCMCaller(address common.Address, caller bind.ContractCaller) (*UpgradableECCMCaller, error)

NewUpgradableECCMCaller creates a new read-only instance of UpgradableECCM, bound to a specific deployed contract.

func (*UpgradableECCMCaller) EthCrossChainDataAddress 

func (_UpgradableECCM *UpgradableECCMCaller) EthCrossChainDataAddress(opts *bind.CallOpts) (common.Address, error)

EthCrossChainDataAddress is a free data retrieval call binding the contract method 0xed9a3dc3.

Solidity: function EthCrossChainDataAddress() constant returns(address)

func (*UpgradableECCMCaller) IsOwner 

func (_UpgradableECCM *UpgradableECCMCaller) IsOwner(opts *bind.CallOpts) (bool, error)

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

Solidity: function isOwner() constant returns(bool)

func (*UpgradableECCMCaller) Owner 

func (_UpgradableECCM *UpgradableECCMCaller) Owner(opts *bind.CallOpts) (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*UpgradableECCMCaller) Paused 

func (_UpgradableECCM *UpgradableECCMCaller) Paused(opts *bind.CallOpts) (bool, error)

Paused is a free data retrieval call binding the contract method 0xd4bc9601.

Solidity: function paused() constant returns(bool)

type UpgradableECCMCallerRaw 

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

UpgradableECCMCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*UpgradableECCMCallerRaw) Call 

func (_UpgradableECCM *UpgradableECCMCallerRaw) 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 UpgradableECCMCallerSession 

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

UpgradableECCMCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

func (*UpgradableECCMCallerSession) EthCrossChainDataAddress 

func (_UpgradableECCM *UpgradableECCMCallerSession) EthCrossChainDataAddress() (common.Address, error)

EthCrossChainDataAddress is a free data retrieval call binding the contract method 0xed9a3dc3.

Solidity: function EthCrossChainDataAddress() constant returns(address)

func (*UpgradableECCMCallerSession) IsOwner 

func (_UpgradableECCM *UpgradableECCMCallerSession) IsOwner() (bool, error)

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

Solidity: function isOwner() constant returns(bool)

func (*UpgradableECCMCallerSession) Owner 

func (_UpgradableECCM *UpgradableECCMCallerSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*UpgradableECCMCallerSession) Paused 

func (_UpgradableECCM *UpgradableECCMCallerSession) Paused() (bool, error)

Paused is a free data retrieval call binding the contract method 0xd4bc9601.

Solidity: function paused() constant returns(bool)

type UpgradableECCMFilterer 

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

UpgradableECCMFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewUpgradableECCMFilterer 

func NewUpgradableECCMFilterer(address common.Address, filterer bind.ContractFilterer) (*UpgradableECCMFilterer, error)

NewUpgradableECCMFilterer creates a new log filterer instance of UpgradableECCM, bound to a specific deployed contract.

func (*UpgradableECCMFilterer) FilterOwnershipTransferred 

func (_UpgradableECCM *UpgradableECCMFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*UpgradableECCMOwnershipTransferredIterator, error)

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

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

func (*UpgradableECCMFilterer) FilterPaused 

func (_UpgradableECCM *UpgradableECCMFilterer) FilterPaused(opts *bind.FilterOpts) (*UpgradableECCMPausedIterator, error)

FilterPaused is a free log retrieval operation binding the contract event 0x000000000000000000000000000000000000000000000000000000003572985a.

Solidity: event Paused(address account)

func (*UpgradableECCMFilterer) FilterUnpaused 

func (_UpgradableECCM *UpgradableECCMFilterer) FilterUnpaused(opts *bind.FilterOpts) (*UpgradableECCMUnpausedIterator, error)

FilterUnpaused is a free log retrieval operation binding the contract event 0x0000000000000000000000000000000000000000000000000000000044693cad.

Solidity: event Unpaused(address account)

func (*UpgradableECCMFilterer) ParseOwnershipTransferred 

func (_UpgradableECCM *UpgradableECCMFilterer) ParseOwnershipTransferred(log types.Log) (*UpgradableECCMOwnershipTransferred, error)

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

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

func (*UpgradableECCMFilterer) ParsePaused 

func (_UpgradableECCM *UpgradableECCMFilterer) ParsePaused(log types.Log) (*UpgradableECCMPaused, error)

ParsePaused is a log parse operation binding the contract event 0x000000000000000000000000000000000000000000000000000000003572985a.

Solidity: event Paused(address account)

func (*UpgradableECCMFilterer) ParseUnpaused 

func (_UpgradableECCM *UpgradableECCMFilterer) ParseUnpaused(log types.Log) (*UpgradableECCMUnpaused, error)

ParseUnpaused is a log parse operation binding the contract event 0x0000000000000000000000000000000000000000000000000000000044693cad.

Solidity: event Unpaused(address account)

func (*UpgradableECCMFilterer) WatchOwnershipTransferred 

func (_UpgradableECCM *UpgradableECCMFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *UpgradableECCMOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

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

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

func (*UpgradableECCMFilterer) WatchPaused 

func (_UpgradableECCM *UpgradableECCMFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *UpgradableECCMPaused) (event.Subscription, error)

WatchPaused is a free log subscription operation binding the contract event 0x000000000000000000000000000000000000000000000000000000003572985a.

Solidity: event Paused(address account)

func (*UpgradableECCMFilterer) WatchUnpaused 

func (_UpgradableECCM *UpgradableECCMFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *UpgradableECCMUnpaused) (event.Subscription, error)

WatchUnpaused is a free log subscription operation binding the contract event 0x0000000000000000000000000000000000000000000000000000000044693cad.

Solidity: event Unpaused(address account)

type UpgradableECCMOwnershipTransferred 

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

UpgradableECCMOwnershipTransferred represents a OwnershipTransferred event raised by the UpgradableECCM contract.

type UpgradableECCMOwnershipTransferredIterator 

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

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

func (*UpgradableECCMOwnershipTransferredIterator) Close 

func (it *UpgradableECCMOwnershipTransferredIterator) Close() error

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

func (*UpgradableECCMOwnershipTransferredIterator) Error 

func (it *UpgradableECCMOwnershipTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*UpgradableECCMOwnershipTransferredIterator) Next 

func (it *UpgradableECCMOwnershipTransferredIterator) 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 UpgradableECCMPaused 

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

UpgradableECCMPaused represents a Paused event raised by the UpgradableECCM contract.

type UpgradableECCMPausedIterator 

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

UpgradableECCMPausedIterator is returned from FilterPaused and is used to iterate over the raw logs and unpacked data for Paused events raised by the UpgradableECCM contract.

func (*UpgradableECCMPausedIterator) Close 

func (it *UpgradableECCMPausedIterator) Close() error

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

func (*UpgradableECCMPausedIterator) Error 

func (it *UpgradableECCMPausedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*UpgradableECCMPausedIterator) Next 

func (it *UpgradableECCMPausedIterator) 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 UpgradableECCMRaw 

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

UpgradableECCMRaw is an auto generated low-level Go binding around a Solidity contract.

func (*UpgradableECCMRaw) Call 

func (_UpgradableECCM *UpgradableECCMRaw) 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 (*UpgradableECCMRaw) Transact 

func (_UpgradableECCM *UpgradableECCMRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*UpgradableECCMRaw) Transfer 

func (_UpgradableECCM *UpgradableECCMRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type UpgradableECCMSession 

type UpgradableECCMSession struct {
	Contract     *UpgradableECCM   // 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
}

UpgradableECCMSession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

func (*UpgradableECCMSession) AsyncPause 

func (_UpgradableECCM *UpgradableECCMSession) AsyncPause(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*UpgradableECCMSession) AsyncRenounceOwnership 

func (_UpgradableECCM *UpgradableECCMSession) AsyncRenounceOwnership(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*UpgradableECCMSession) AsyncTransferOwnership 

func (_UpgradableECCM *UpgradableECCMSession) AsyncTransferOwnership(handler func(*types.Receipt, error), newOwner common.Address) (*types.Transaction, error)

func (*UpgradableECCMSession) AsyncUnpause 

func (_UpgradableECCM *UpgradableECCMSession) AsyncUnpause(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*UpgradableECCMSession) AsyncUpgradeToNew 

func (_UpgradableECCM *UpgradableECCMSession) AsyncUpgradeToNew(handler func(*types.Receipt, error), newEthCrossChainManagerAddress common.Address) (*types.Transaction, error)

func (*UpgradableECCMSession) EthCrossChainDataAddress 

func (_UpgradableECCM *UpgradableECCMSession) EthCrossChainDataAddress() (common.Address, error)

EthCrossChainDataAddress is a free data retrieval call binding the contract method 0xed9a3dc3.

Solidity: function EthCrossChainDataAddress() constant returns(address)

func (*UpgradableECCMSession) IsOwner 

func (_UpgradableECCM *UpgradableECCMSession) IsOwner() (bool, error)

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

Solidity: function isOwner() constant returns(bool)

func (*UpgradableECCMSession) Owner 

func (_UpgradableECCM *UpgradableECCMSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*UpgradableECCMSession) Pause 

func (_UpgradableECCM *UpgradableECCMSession) Pause() (*types.Transaction, *types.Receipt, error)

Pause is a paid mutator transaction binding the contract method 0xf4fbb0c8.

Solidity: function pause() returns(bool)

func (*UpgradableECCMSession) Paused 

func (_UpgradableECCM *UpgradableECCMSession) Paused() (bool, error)

Paused is a free data retrieval call binding the contract method 0xd4bc9601.

Solidity: function paused() constant returns(bool)

func (*UpgradableECCMSession) RenounceOwnership 

func (_UpgradableECCM *UpgradableECCMSession) RenounceOwnership() (*types.Transaction, *types.Receipt, error)

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

Solidity: function renounceOwnership() returns()

func (*UpgradableECCMSession) TransferOwnership 

func (_UpgradableECCM *UpgradableECCMSession) TransferOwnership(newOwner common.Address) (*types.Transaction, *types.Receipt, error)

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

Solidity: function transferOwnership(address newOwner) returns()

func (*UpgradableECCMSession) Unpause 

func (_UpgradableECCM *UpgradableECCMSession) Unpause() (*types.Transaction, *types.Receipt, error)

Unpause is a paid mutator transaction binding the contract method 0x63c37526.

Solidity: function unpause() returns(bool)

func (*UpgradableECCMSession) UpgradeToNew 

func (_UpgradableECCM *UpgradableECCMSession) UpgradeToNew(newEthCrossChainManagerAddress common.Address) (*types.Transaction, *types.Receipt, error)

UpgradeToNew is a paid mutator transaction binding the contract method 0xf4e614d2.

Solidity: function upgradeToNew(address newEthCrossChainManagerAddress) returns(bool)

type UpgradableECCMTransactor 

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

UpgradableECCMTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewUpgradableECCMTransactor 

func NewUpgradableECCMTransactor(address common.Address, transactor bind.ContractTransactor) (*UpgradableECCMTransactor, error)

NewUpgradableECCMTransactor creates a new write-only instance of UpgradableECCM, bound to a specific deployed contract.

func (*UpgradableECCMTransactor) AsyncPause 

func (_UpgradableECCM *UpgradableECCMTransactor) AsyncPause(handler func(*types.Receipt, error), opts *bind.TransactOpts) (*types.Transaction, error)

func (*UpgradableECCMTransactor) AsyncRenounceOwnership 

func (_UpgradableECCM *UpgradableECCMTransactor) AsyncRenounceOwnership(handler func(*types.Receipt, error), opts *bind.TransactOpts) (*types.Transaction, error)

func (*UpgradableECCMTransactor) AsyncTransferOwnership 

func (_UpgradableECCM *UpgradableECCMTransactor) AsyncTransferOwnership(handler func(*types.Receipt, error), opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

func (*UpgradableECCMTransactor) AsyncUnpause 

func (_UpgradableECCM *UpgradableECCMTransactor) AsyncUnpause(handler func(*types.Receipt, error), opts *bind.TransactOpts) (*types.Transaction, error)

func (*UpgradableECCMTransactor) AsyncUpgradeToNew 

func (_UpgradableECCM *UpgradableECCMTransactor) AsyncUpgradeToNew(handler func(*types.Receipt, error), opts *bind.TransactOpts, newEthCrossChainManagerAddress common.Address) (*types.Transaction, error)

func (*UpgradableECCMTransactor) Pause 

func (_UpgradableECCM *UpgradableECCMTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

Pause is a paid mutator transaction binding the contract method 0xf4fbb0c8.

Solidity: function pause() returns(bool)

func (*UpgradableECCMTransactor) RenounceOwnership 

func (_UpgradableECCM *UpgradableECCMTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

Solidity: function renounceOwnership() returns()

func (*UpgradableECCMTransactor) TransferOwnership 

func (_UpgradableECCM *UpgradableECCMTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, *types.Receipt, error)

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

Solidity: function transferOwnership(address newOwner) returns()

func (*UpgradableECCMTransactor) Unpause 

func (_UpgradableECCM *UpgradableECCMTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

Unpause is a paid mutator transaction binding the contract method 0x63c37526.

Solidity: function unpause() returns(bool)

func (*UpgradableECCMTransactor) UpgradeToNew 

func (_UpgradableECCM *UpgradableECCMTransactor) UpgradeToNew(opts *bind.TransactOpts, newEthCrossChainManagerAddress common.Address) (*types.Transaction, *types.Receipt, error)

UpgradeToNew is a paid mutator transaction binding the contract method 0xf4e614d2.

Solidity: function upgradeToNew(address newEthCrossChainManagerAddress) returns(bool)

type UpgradableECCMTransactorRaw 

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

UpgradableECCMTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*UpgradableECCMTransactorRaw) Transact 

func (_UpgradableECCM *UpgradableECCMTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*UpgradableECCMTransactorRaw) Transfer 

func (_UpgradableECCM *UpgradableECCMTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type UpgradableECCMTransactorSession 

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

UpgradableECCMTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

func (*UpgradableECCMTransactorSession) AsyncPause 

func (_UpgradableECCM *UpgradableECCMTransactorSession) AsyncPause(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*UpgradableECCMTransactorSession) AsyncRenounceOwnership 

func (_UpgradableECCM *UpgradableECCMTransactorSession) AsyncRenounceOwnership(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*UpgradableECCMTransactorSession) AsyncTransferOwnership 

func (_UpgradableECCM *UpgradableECCMTransactorSession) AsyncTransferOwnership(handler func(*types.Receipt, error), newOwner common.Address) (*types.Transaction, error)

func (*UpgradableECCMTransactorSession) AsyncUnpause 

func (_UpgradableECCM *UpgradableECCMTransactorSession) AsyncUnpause(handler func(*types.Receipt, error)) (*types.Transaction, error)

func (*UpgradableECCMTransactorSession) AsyncUpgradeToNew 

func (_UpgradableECCM *UpgradableECCMTransactorSession) AsyncUpgradeToNew(handler func(*types.Receipt, error), newEthCrossChainManagerAddress common.Address) (*types.Transaction, error)

func (*UpgradableECCMTransactorSession) Pause 

func (_UpgradableECCM *UpgradableECCMTransactorSession) Pause() (*types.Transaction, *types.Receipt, error)

Pause is a paid mutator transaction binding the contract method 0xf4fbb0c8.

Solidity: function pause() returns(bool)

func (*UpgradableECCMTransactorSession) RenounceOwnership 

func (_UpgradableECCM *UpgradableECCMTransactorSession) RenounceOwnership() (*types.Transaction, *types.Receipt, error)

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

Solidity: function renounceOwnership() returns()

func (*UpgradableECCMTransactorSession) TransferOwnership 

func (_UpgradableECCM *UpgradableECCMTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, *types.Receipt, error)

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

Solidity: function transferOwnership(address newOwner) returns()

func (*UpgradableECCMTransactorSession) Unpause 

func (_UpgradableECCM *UpgradableECCMTransactorSession) Unpause() (*types.Transaction, *types.Receipt, error)

Unpause is a paid mutator transaction binding the contract method 0x63c37526.

Solidity: function unpause() returns(bool)

func (*UpgradableECCMTransactorSession) UpgradeToNew 

func (_UpgradableECCM *UpgradableECCMTransactorSession) UpgradeToNew(newEthCrossChainManagerAddress common.Address) (*types.Transaction, *types.Receipt, error)

UpgradeToNew is a paid mutator transaction binding the contract method 0xf4e614d2.

Solidity: function upgradeToNew(address newEthCrossChainManagerAddress) returns(bool)

type UpgradableECCMUnpaused 

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

UpgradableECCMUnpaused represents a Unpaused event raised by the UpgradableECCM contract.

type UpgradableECCMUnpausedIterator 

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

UpgradableECCMUnpausedIterator is returned from FilterUnpaused and is used to iterate over the raw logs and unpacked data for Unpaused events raised by the UpgradableECCM contract.

func (*UpgradableECCMUnpausedIterator) Close 

func (it *UpgradableECCMUnpausedIterator) Close() error

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

func (*UpgradableECCMUnpausedIterator) Error 

func (it *UpgradableECCMUnpausedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*UpgradableECCMUnpausedIterator) Next 

func (it *UpgradableECCMUnpausedIterator) 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 Utils 

type Utils struct {
	UtilsCaller     // Read-only binding to the contract
	UtilsTransactor // Write-only binding to the contract
	UtilsFilterer   // Log filterer for contract events
}

Utils is an auto generated Go binding around a Solidity contract.

func DeployUtils 

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

DeployUtils deploys a new contract, binding an instance of Utils to it.

func NewUtils 

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

NewUtils creates a new instance of Utils, bound to a specific deployed contract.

type UtilsCaller 

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

UtilsCaller is an auto generated read-only Go binding around a Solidity contract.

func NewUtilsCaller 

func NewUtilsCaller(address common.Address, caller bind.ContractCaller) (*UtilsCaller, error)

NewUtilsCaller creates a new read-only instance of Utils, bound to a specific deployed contract.

type UtilsCallerRaw 

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

UtilsCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*UtilsCallerRaw) Call 

func (_Utils *UtilsCallerRaw) 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 UtilsCallerSession 

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

UtilsCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

type UtilsFilterer 

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

UtilsFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewUtilsFilterer 

func NewUtilsFilterer(address common.Address, filterer bind.ContractFilterer) (*UtilsFilterer, error)

NewUtilsFilterer creates a new log filterer instance of Utils, bound to a specific deployed contract.

type UtilsRaw 

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

UtilsRaw is an auto generated low-level Go binding around a Solidity contract.

func (*UtilsRaw) Call 

func (_Utils *UtilsRaw) 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 (*UtilsRaw) Transact 

func (_Utils *UtilsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*UtilsRaw) Transfer 

func (_Utils *UtilsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type UtilsSession 

type UtilsSession struct {
	Contract     *Utils            // 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
}

UtilsSession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

type UtilsTransactor 

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

UtilsTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewUtilsTransactor 

func NewUtilsTransactor(address common.Address, transactor bind.ContractTransactor) (*UtilsTransactor, error)

NewUtilsTransactor creates a new write-only instance of Utils, bound to a specific deployed contract.

type UtilsTransactorRaw 

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

UtilsTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*UtilsTransactorRaw) Transact 

func (_Utils *UtilsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*UtilsTransactorRaw) Transfer 

func (_Utils *UtilsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type UtilsTransactorSession 

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

UtilsTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

type ZeroCopySink 

type ZeroCopySink struct {
	ZeroCopySinkCaller     // Read-only binding to the contract
	ZeroCopySinkTransactor // Write-only binding to the contract
	ZeroCopySinkFilterer   // Log filterer for contract events
}

ZeroCopySink is an auto generated Go binding around a Solidity contract.

func DeployZeroCopySink 

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

DeployZeroCopySink deploys a new contract, binding an instance of ZeroCopySink to it.

func NewZeroCopySink 

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

NewZeroCopySink creates a new instance of ZeroCopySink, bound to a specific deployed contract.

type ZeroCopySinkCaller 

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

ZeroCopySinkCaller is an auto generated read-only Go binding around a Solidity contract.

func NewZeroCopySinkCaller 

func NewZeroCopySinkCaller(address common.Address, caller bind.ContractCaller) (*ZeroCopySinkCaller, error)

NewZeroCopySinkCaller creates a new read-only instance of ZeroCopySink, bound to a specific deployed contract.

type ZeroCopySinkCallerRaw 

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

ZeroCopySinkCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*ZeroCopySinkCallerRaw) Call 

func (_ZeroCopySink *ZeroCopySinkCallerRaw) 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 ZeroCopySinkCallerSession 

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

ZeroCopySinkCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

type ZeroCopySinkFilterer 

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

ZeroCopySinkFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewZeroCopySinkFilterer 

func NewZeroCopySinkFilterer(address common.Address, filterer bind.ContractFilterer) (*ZeroCopySinkFilterer, error)

NewZeroCopySinkFilterer creates a new log filterer instance of ZeroCopySink, bound to a specific deployed contract.

type ZeroCopySinkRaw 

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

ZeroCopySinkRaw is an auto generated low-level Go binding around a Solidity contract.

func (*ZeroCopySinkRaw) Call 

func (_ZeroCopySink *ZeroCopySinkRaw) 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 (*ZeroCopySinkRaw) Transact 

func (_ZeroCopySink *ZeroCopySinkRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*ZeroCopySinkRaw) Transfer 

func (_ZeroCopySink *ZeroCopySinkRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type ZeroCopySinkSession 

type ZeroCopySinkSession struct {
	Contract     *ZeroCopySink     // 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
}

ZeroCopySinkSession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

type ZeroCopySinkTransactor 

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

ZeroCopySinkTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewZeroCopySinkTransactor 

func NewZeroCopySinkTransactor(address common.Address, transactor bind.ContractTransactor) (*ZeroCopySinkTransactor, error)

NewZeroCopySinkTransactor creates a new write-only instance of ZeroCopySink, bound to a specific deployed contract.

type ZeroCopySinkTransactorRaw 

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

ZeroCopySinkTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*ZeroCopySinkTransactorRaw) Transact 

func (_ZeroCopySink *ZeroCopySinkTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*ZeroCopySinkTransactorRaw) Transfer 

func (_ZeroCopySink *ZeroCopySinkTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type ZeroCopySinkTransactorSession 

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

ZeroCopySinkTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

type ZeroCopySource 

type ZeroCopySource struct {
	ZeroCopySourceCaller     // Read-only binding to the contract
	ZeroCopySourceTransactor // Write-only binding to the contract
	ZeroCopySourceFilterer   // Log filterer for contract events
}

ZeroCopySource is an auto generated Go binding around a Solidity contract.

func DeployZeroCopySource 

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

DeployZeroCopySource deploys a new contract, binding an instance of ZeroCopySource to it.

func NewZeroCopySource 

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

NewZeroCopySource creates a new instance of ZeroCopySource, bound to a specific deployed contract.

type ZeroCopySourceCaller 

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

ZeroCopySourceCaller is an auto generated read-only Go binding around a Solidity contract.

func NewZeroCopySourceCaller 

func NewZeroCopySourceCaller(address common.Address, caller bind.ContractCaller) (*ZeroCopySourceCaller, error)

NewZeroCopySourceCaller creates a new read-only instance of ZeroCopySource, bound to a specific deployed contract.

type ZeroCopySourceCallerRaw 

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

ZeroCopySourceCallerRaw is an auto generated low-level read-only Go binding around a Solidity contract.

func (*ZeroCopySourceCallerRaw) Call 

func (_ZeroCopySource *ZeroCopySourceCallerRaw) 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 ZeroCopySourceCallerSession 

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

ZeroCopySourceCallerSession is an auto generated read-only Go binding around a Solidity contract, with pre-set call options.

type ZeroCopySourceFilterer 

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

ZeroCopySourceFilterer is an auto generated log filtering Go binding around a Solidity contract events.

func NewZeroCopySourceFilterer 

func NewZeroCopySourceFilterer(address common.Address, filterer bind.ContractFilterer) (*ZeroCopySourceFilterer, error)

NewZeroCopySourceFilterer creates a new log filterer instance of ZeroCopySource, bound to a specific deployed contract.

type ZeroCopySourceRaw 

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

ZeroCopySourceRaw is an auto generated low-level Go binding around a Solidity contract.

func (*ZeroCopySourceRaw) Call 

func (_ZeroCopySource *ZeroCopySourceRaw) 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 (*ZeroCopySourceRaw) Transact 

func (_ZeroCopySource *ZeroCopySourceRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*ZeroCopySourceRaw) Transfer 

func (_ZeroCopySource *ZeroCopySourceRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type ZeroCopySourceSession 

type ZeroCopySourceSession struct {
	Contract     *ZeroCopySource   // 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
}

ZeroCopySourceSession is an auto generated Go binding around a Solidity contract, with pre-set call and transact options.

type ZeroCopySourceTransactor 

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

ZeroCopySourceTransactor is an auto generated write-only Go binding around a Solidity contract.

func NewZeroCopySourceTransactor 

func NewZeroCopySourceTransactor(address common.Address, transactor bind.ContractTransactor) (*ZeroCopySourceTransactor, error)

NewZeroCopySourceTransactor creates a new write-only instance of ZeroCopySource, bound to a specific deployed contract.

type ZeroCopySourceTransactorRaw 

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

ZeroCopySourceTransactorRaw is an auto generated low-level write-only Go binding around a Solidity contract.

func (*ZeroCopySourceTransactorRaw) Transact 

func (_ZeroCopySource *ZeroCopySourceTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, *types.Receipt, error)

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

func (*ZeroCopySourceTransactorRaw) Transfer 

func (_ZeroCopySource *ZeroCopySourceTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, *types.Receipt, error)

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

type ZeroCopySourceTransactorSession 

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

ZeroCopySourceTransactorSession is an auto generated write-only Go binding around a Solidity contract, with pre-set transact options.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.