contracts

package
v0.0.0-...-1f8a15b Latest Latest
Warning

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

 Go to latest Published: Dec 12, 2023 License: GPL-3.0 Imports: 21 Imported by: 0

Documentation

Index

Constants

View Source 
const ChildReceiverABI = "" /* 815-byte string literal not displayed */

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

View Source 
const ChildSenderABI = "" /* 740-byte string literal not displayed */

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

View Source 
const FaucetABI = "" /* 1383-byte string literal not displayed */

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

View Source 
const RootReceiverABI = "" /* 1451-byte string literal not displayed */

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

View Source 
const RootSenderABI = "" /* 653-byte string literal not displayed */

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

View Source 
const SubscriptionABI = "" /* 146-byte string literal not displayed */

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

View Source 
const TestRootChainABI = "" /* 3879-byte string literal not displayed */

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

View Source 
const TestStateSenderABI = "" /* 1963-byte string literal not displayed */

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

Variables

View Source 
var ChildReceiverBin = "" /* 1402-byte string literal not displayed */

ChildReceiverBin is the compiled bytecode used for deploying new contracts.

View Source 
var ChildSenderBin = "" /* 1384-byte string literal not displayed */

ChildSenderBin is the compiled bytecode used for deploying new contracts.

View Source 
var DeploymentChecker = blocks.BlockHandlerFunc(
	func(ctx context.Context, node devnet.Node, block *requests.Block, transaction *jsonrpc.RPCTransaction) error {
		if err := blocks.CompletionChecker(ctx, node, block, transaction); err != nil {
			return nil
		}

		return nil
	})
View Source 
var FaucetBin = "" /* 1558-byte string literal not displayed */

FaucetBin is the compiled bytecode used for deploying new contracts.

View Source 
var RootReceiverBin = "" /* 15780-byte string literal not displayed */

RootReceiverBin is the compiled bytecode used for deploying new contracts.

View Source 
var RootSenderBin = "" /* 1528-byte string literal not displayed */

RootSenderBin is the compiled bytecode used for deploying new contracts.

View Source 
var SubscriptionBin = "" /* 286-byte string literal not displayed */

SubscriptionBin is the compiled bytecode used for deploying new contracts.

View Source 
var TestRootChainBin = "" /* 5704-byte string literal not displayed */

TestRootChainBin is the compiled bytecode used for deploying new contracts.

View Source 
var TestStateSenderBin = "" /* 1806-byte string literal not displayed */

TestStateSenderBin is the compiled bytecode used for deploying new contracts.

Functions

func Deploy 

func Deploy[C any](ctx context.Context, deployer libcommon.Address, deploy func(auth *bind.TransactOpts, backend bind.ContractBackend) (libcommon.Address, types.Transaction, *C, error)) (libcommon.Address, types.Transaction, *C, error)

func DeployWithOps 

func DeployWithOps[C any](ctx context.Context, auth *bind.TransactOpts, deploy func(auth *bind.TransactOpts, backend bind.ContractBackend) (libcommon.Address, types.Transaction, *C, error)) (libcommon.Address, types.Transaction, *C, error)

func DeploymentTransactor 

func DeploymentTransactor(ctx context.Context, deployer libcommon.Address) (*bind.TransactOpts, bind.ContractBackend, error)

func NewBackend 

func NewBackend(node devnet.Node) bind.ContractBackend

func TransactOpts 

func TransactOpts(ctx context.Context, sender libcommon.Address) (*bind.TransactOpts, error)

Types

type ChildReceiver 

type ChildReceiver struct {
	ChildReceiverCaller     // Read-only binding to the contract
	ChildReceiverTransactor // Write-only binding to the contract
	ChildReceiverFilterer   // Log filterer for contract events
}

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

func DeployChildReceiver 

func DeployChildReceiver(auth *bind.TransactOpts, backend bind.ContractBackend) (libcommon.Address, types.Transaction, *ChildReceiver, error)

DeployChildReceiver deploys a new Ethereum contract, binding an instance of ChildReceiver to it.

func NewChildReceiver 

func NewChildReceiver(address libcommon.Address, backend bind.ContractBackend) (*ChildReceiver, error)

NewChildReceiver creates a new instance of ChildReceiver, bound to a specific deployed contract.

type ChildReceiverCaller 

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

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

func NewChildReceiverCaller 

func NewChildReceiverCaller(address libcommon.Address, caller bind.ContractCaller) (*ChildReceiverCaller, error)

NewChildReceiverCaller creates a new read-only instance of ChildReceiver, bound to a specific deployed contract.

func (*ChildReceiverCaller) Senders 

func (_ChildReceiver *ChildReceiverCaller) Senders(opts *bind.CallOpts, arg0 libcommon.Address) (*big.Int, error)

Senders is a free data retrieval call binding the contract method 0x982fb9d8.

Solidity: function senders(address ) view returns(uint256)

type ChildReceiverCallerRaw 

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

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

func (*ChildReceiverCallerRaw) Call 

func (_ChildReceiver *ChildReceiverCallerRaw) 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 ChildReceiverCallerSession 

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

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

func (*ChildReceiverCallerSession) Senders 

func (_ChildReceiver *ChildReceiverCallerSession) Senders(arg0 libcommon.Address) (*big.Int, error)

Senders is a free data retrieval call binding the contract method 0x982fb9d8.

Solidity: function senders(address ) view returns(uint256)

type ChildReceiverFilterer 

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

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

func NewChildReceiverFilterer 

func NewChildReceiverFilterer(address libcommon.Address, filterer bind.ContractFilterer) (*ChildReceiverFilterer, error)

NewChildReceiverFilterer creates a new log filterer instance of ChildReceiver, bound to a specific deployed contract.

func (*ChildReceiverFilterer) FilterReceived 

func (_ChildReceiver *ChildReceiverFilterer) FilterReceived(opts *bind.FilterOpts) (*ChildReceiverReceivedIterator, error)

FilterReceived is a free log retrieval operation binding the contract event 0xf11e547d796cc64acdf758e7cee90439494fd886a19159454aa61e473fdbafef.

Solidity: event received(address _source, uint256 _amount)

func (*ChildReceiverFilterer) ParseReceived 

func (_ChildReceiver *ChildReceiverFilterer) ParseReceived(log types.Log) (*ChildReceiverReceived, error)

ParseReceived is a log parse operation binding the contract event 0xf11e547d796cc64acdf758e7cee90439494fd886a19159454aa61e473fdbafef.

Solidity: event received(address _source, uint256 _amount)

func (*ChildReceiverFilterer) WatchReceived 

func (_ChildReceiver *ChildReceiverFilterer) WatchReceived(opts *bind.WatchOpts, sink chan<- *ChildReceiverReceived) (event.Subscription, error)

WatchReceived is a free log subscription operation binding the contract event 0xf11e547d796cc64acdf758e7cee90439494fd886a19159454aa61e473fdbafef.

Solidity: event received(address _source, uint256 _amount)

type ChildReceiverRaw 

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

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

func (*ChildReceiverRaw) Call 

func (_ChildReceiver *ChildReceiverRaw) 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 (*ChildReceiverRaw) Transact 

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

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

func (*ChildReceiverRaw) Transfer 

func (_ChildReceiver *ChildReceiverRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

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

type ChildReceiverReceived 

type ChildReceiverReceived struct {
	Source libcommon.Address
	Amount *big.Int
	Raw    types.Log // Blockchain specific contextual infos
}

ChildReceiverReceived represents a Received event raised by the ChildReceiver contract.

type ChildReceiverReceivedIterator 

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

ChildReceiverReceivedIterator is returned from FilterReceived and is used to iterate over the raw logs and unpacked data for Received events raised by the ChildReceiver contract.

func (*ChildReceiverReceivedIterator) Close 

func (it *ChildReceiverReceivedIterator) Close() error

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

func (*ChildReceiverReceivedIterator) Error 

func (it *ChildReceiverReceivedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ChildReceiverReceivedIterator) Next 

func (it *ChildReceiverReceivedIterator) 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 ChildReceiverSession 

type ChildReceiverSession struct {
	Contract     *ChildReceiver    // 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
}

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

func (*ChildReceiverSession) OnStateReceive 

func (_ChildReceiver *ChildReceiverSession) OnStateReceive(arg0 *big.Int, data []byte) (types.Transaction, error)

OnStateReceive is a paid mutator transaction binding the contract method 0x26c53bea.

Solidity: function onStateReceive(uint256 , bytes data) returns()

func (*ChildReceiverSession) Senders 

func (_ChildReceiver *ChildReceiverSession) Senders(arg0 libcommon.Address) (*big.Int, error)

Senders is a free data retrieval call binding the contract method 0x982fb9d8.

Solidity: function senders(address ) view returns(uint256)

type ChildReceiverTransactor 

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

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

func NewChildReceiverTransactor 

func NewChildReceiverTransactor(address libcommon.Address, transactor bind.ContractTransactor) (*ChildReceiverTransactor, error)

NewChildReceiverTransactor creates a new write-only instance of ChildReceiver, bound to a specific deployed contract.

func (*ChildReceiverTransactor) OnStateReceive 

func (_ChildReceiver *ChildReceiverTransactor) OnStateReceive(opts *bind.TransactOpts, arg0 *big.Int, data []byte) (types.Transaction, error)

OnStateReceive is a paid mutator transaction binding the contract method 0x26c53bea.

Solidity: function onStateReceive(uint256 , bytes data) returns()

type ChildReceiverTransactorRaw 

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

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

func (*ChildReceiverTransactorRaw) Transact 

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

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

func (*ChildReceiverTransactorRaw) Transfer 

func (_ChildReceiver *ChildReceiverTransactorRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

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

type ChildReceiverTransactorSession 

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

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

func (*ChildReceiverTransactorSession) OnStateReceive 

func (_ChildReceiver *ChildReceiverTransactorSession) OnStateReceive(arg0 *big.Int, data []byte) (types.Transaction, error)

OnStateReceive is a paid mutator transaction binding the contract method 0x26c53bea.

Solidity: function onStateReceive(uint256 , bytes data) returns()

type ChildSender 

type ChildSender struct {
	ChildSenderCaller     // Read-only binding to the contract
	ChildSenderTransactor // Write-only binding to the contract
	ChildSenderFilterer   // Log filterer for contract events
}

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

func DeployChildSender 

func DeployChildSender(auth *bind.TransactOpts, backend bind.ContractBackend, childStateReceiver_ libcommon.Address) (libcommon.Address, types.Transaction, *ChildSender, error)

DeployChildSender deploys a new Ethereum contract, binding an instance of ChildSender to it.

func NewChildSender 

func NewChildSender(address libcommon.Address, backend bind.ContractBackend) (*ChildSender, error)

NewChildSender creates a new instance of ChildSender, bound to a specific deployed contract.

type ChildSenderCaller 

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

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

func NewChildSenderCaller 

func NewChildSenderCaller(address libcommon.Address, caller bind.ContractCaller) (*ChildSenderCaller, error)

NewChildSenderCaller creates a new read-only instance of ChildSender, bound to a specific deployed contract.

func (*ChildSenderCaller) Sent 

func (_ChildSender *ChildSenderCaller) Sent(opts *bind.CallOpts, arg0 libcommon.Address) (*big.Int, error)

Sent is a free data retrieval call binding the contract method 0x7bf786f8.

Solidity: function sent(address ) view returns(uint256)

type ChildSenderCallerRaw 

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

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

func (*ChildSenderCallerRaw) Call 

func (_ChildSender *ChildSenderCallerRaw) 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 ChildSenderCallerSession 

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

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

func (*ChildSenderCallerSession) Sent 

func (_ChildSender *ChildSenderCallerSession) Sent(arg0 libcommon.Address) (*big.Int, error)

Sent is a free data retrieval call binding the contract method 0x7bf786f8.

Solidity: function sent(address ) view returns(uint256)

type ChildSenderFilterer 

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

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

func NewChildSenderFilterer 

func NewChildSenderFilterer(address libcommon.Address, filterer bind.ContractFilterer) (*ChildSenderFilterer, error)

NewChildSenderFilterer creates a new log filterer instance of ChildSender, bound to a specific deployed contract.

func (*ChildSenderFilterer) FilterMessageSent 

func (_ChildSender *ChildSenderFilterer) FilterMessageSent(opts *bind.FilterOpts) (*ChildSenderMessageSentIterator, error)

FilterMessageSent is a free log retrieval operation binding the contract event 0x8c5261668696ce22758910d05bab8f186d6eb247ceac2af2e82c7dc17669b036.

Solidity: event MessageSent(bytes message)

func (*ChildSenderFilterer) ParseMessageSent 

func (_ChildSender *ChildSenderFilterer) ParseMessageSent(log types.Log) (*ChildSenderMessageSent, error)

ParseMessageSent is a log parse operation binding the contract event 0x8c5261668696ce22758910d05bab8f186d6eb247ceac2af2e82c7dc17669b036.

Solidity: event MessageSent(bytes message)

func (*ChildSenderFilterer) WatchMessageSent 

func (_ChildSender *ChildSenderFilterer) WatchMessageSent(opts *bind.WatchOpts, sink chan<- *ChildSenderMessageSent) (event.Subscription, error)

WatchMessageSent is a free log subscription operation binding the contract event 0x8c5261668696ce22758910d05bab8f186d6eb247ceac2af2e82c7dc17669b036.

Solidity: event MessageSent(bytes message)

type ChildSenderMessageSent 

type ChildSenderMessageSent struct {
	Message []byte
	Raw     types.Log // Blockchain specific contextual infos
}

ChildSenderMessageSent represents a MessageSent event raised by the ChildSender contract.

type ChildSenderMessageSentIterator 

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

ChildSenderMessageSentIterator is returned from FilterMessageSent and is used to iterate over the raw logs and unpacked data for MessageSent events raised by the ChildSender contract.

func (*ChildSenderMessageSentIterator) Close 

func (it *ChildSenderMessageSentIterator) Close() error

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

func (*ChildSenderMessageSentIterator) Error 

func (it *ChildSenderMessageSentIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ChildSenderMessageSentIterator) Next 

func (it *ChildSenderMessageSentIterator) 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 ChildSenderRaw 

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

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

func (*ChildSenderRaw) Call 

func (_ChildSender *ChildSenderRaw) 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 (*ChildSenderRaw) Transact 

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

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

func (*ChildSenderRaw) Transfer 

func (_ChildSender *ChildSenderRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

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

type ChildSenderSession 

type ChildSenderSession struct {
	Contract     *ChildSender      // 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
}

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

func (*ChildSenderSession) SendToRoot 

func (_ChildSender *ChildSenderSession) SendToRoot(amount *big.Int) (types.Transaction, error)

SendToRoot is a paid mutator transaction binding the contract method 0x8152e502.

Solidity: function sendToRoot(uint256 amount) returns()

func (*ChildSenderSession) Sent 

func (_ChildSender *ChildSenderSession) Sent(arg0 libcommon.Address) (*big.Int, error)

Sent is a free data retrieval call binding the contract method 0x7bf786f8.

Solidity: function sent(address ) view returns(uint256)

type ChildSenderTransactor 

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

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

func NewChildSenderTransactor 

func NewChildSenderTransactor(address libcommon.Address, transactor bind.ContractTransactor) (*ChildSenderTransactor, error)

NewChildSenderTransactor creates a new write-only instance of ChildSender, bound to a specific deployed contract.

func (*ChildSenderTransactor) SendToRoot 

func (_ChildSender *ChildSenderTransactor) SendToRoot(opts *bind.TransactOpts, amount *big.Int) (types.Transaction, error)

SendToRoot is a paid mutator transaction binding the contract method 0x8152e502.

Solidity: function sendToRoot(uint256 amount) returns()

type ChildSenderTransactorRaw 

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

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

func (*ChildSenderTransactorRaw) Transact 

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

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

func (*ChildSenderTransactorRaw) Transfer 

func (_ChildSender *ChildSenderTransactorRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

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

type ChildSenderTransactorSession 

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

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

func (*ChildSenderTransactorSession) SendToRoot 

func (_ChildSender *ChildSenderTransactorSession) SendToRoot(amount *big.Int) (types.Transaction, error)

SendToRoot is a paid mutator transaction binding the contract method 0x8152e502.

Solidity: function sendToRoot(uint256 amount) returns()

type Faucet 

type Faucet struct {
	FaucetCaller     // Read-only binding to the contract
	FaucetTransactor // Write-only binding to the contract
	FaucetFilterer   // Log filterer for contract events
}

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

func DeployFaucet 

func DeployFaucet(auth *bind.TransactOpts, backend bind.ContractBackend) (libcommon.Address, types.Transaction, *Faucet, error)

DeployFaucet deploys a new Ethereum contract, binding an instance of Faucet to it.

func NewFaucet 

func NewFaucet(address libcommon.Address, backend bind.ContractBackend) (*Faucet, error)

NewFaucet creates a new instance of Faucet, bound to a specific deployed contract.

type FaucetCaller 

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

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

func NewFaucetCaller 

func NewFaucetCaller(address libcommon.Address, caller bind.ContractCaller) (*FaucetCaller, error)

NewFaucetCaller creates a new read-only instance of Faucet, bound to a specific deployed contract.

func (*FaucetCaller) Destinations 

func (_Faucet *FaucetCaller) Destinations(opts *bind.CallOpts, arg0 libcommon.Address) (*big.Int, error)

Destinations is a free data retrieval call binding the contract method 0x59c02c37.

Solidity: function destinations(address ) view returns(uint256)

func (*FaucetCaller) Sources 

func (_Faucet *FaucetCaller) Sources(opts *bind.CallOpts, arg0 libcommon.Address) (*big.Int, error)

Sources is a free data retrieval call binding the contract method 0xb750bdde.

Solidity: function sources(address ) view returns(uint256)

type FaucetCallerRaw 

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

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

func (*FaucetCallerRaw) Call 

func (_Faucet *FaucetCallerRaw) 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 FaucetCallerSession 

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

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

func (*FaucetCallerSession) Destinations 

func (_Faucet *FaucetCallerSession) Destinations(arg0 libcommon.Address) (*big.Int, error)

Destinations is a free data retrieval call binding the contract method 0x59c02c37.

Solidity: function destinations(address ) view returns(uint256)

func (*FaucetCallerSession) Sources 

func (_Faucet *FaucetCallerSession) Sources(arg0 libcommon.Address) (*big.Int, error)

Sources is a free data retrieval call binding the contract method 0xb750bdde.

Solidity: function sources(address ) view returns(uint256)

type FaucetFilterer 

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

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

func NewFaucetFilterer 

func NewFaucetFilterer(address libcommon.Address, filterer bind.ContractFilterer) (*FaucetFilterer, error)

NewFaucetFilterer creates a new log filterer instance of Faucet, bound to a specific deployed contract.

func (*FaucetFilterer) FilterReceived 

func (_Faucet *FaucetFilterer) FilterReceived(opts *bind.FilterOpts) (*FaucetReceivedIterator, error)

FilterReceived is a free log retrieval operation binding the contract event 0xf11e547d796cc64acdf758e7cee90439494fd886a19159454aa61e473fdbafef.

Solidity: event received(address _source, uint256 _amount)

func (*FaucetFilterer) FilterSent 

func (_Faucet *FaucetFilterer) FilterSent(opts *bind.FilterOpts) (*FaucetSentIterator, error)

FilterSent is a free log retrieval operation binding the contract event 0x3bcb2e664d8f57273201bc888e82d6549f8308a52a9fcd7702b2ea8387f769a9.

Solidity: event sent(address _destination, uint256 _amount)

func (*FaucetFilterer) ParseReceived 

func (_Faucet *FaucetFilterer) ParseReceived(log types.Log) (*FaucetReceived, error)

ParseReceived is a log parse operation binding the contract event 0xf11e547d796cc64acdf758e7cee90439494fd886a19159454aa61e473fdbafef.

Solidity: event received(address _source, uint256 _amount)

func (*FaucetFilterer) ParseSent 

func (_Faucet *FaucetFilterer) ParseSent(log types.Log) (*FaucetSent, error)

ParseSent is a log parse operation binding the contract event 0x3bcb2e664d8f57273201bc888e82d6549f8308a52a9fcd7702b2ea8387f769a9.

Solidity: event sent(address _destination, uint256 _amount)

func (*FaucetFilterer) WatchReceived 

func (_Faucet *FaucetFilterer) WatchReceived(opts *bind.WatchOpts, sink chan<- *FaucetReceived) (event.Subscription, error)

WatchReceived is a free log subscription operation binding the contract event 0xf11e547d796cc64acdf758e7cee90439494fd886a19159454aa61e473fdbafef.

Solidity: event received(address _source, uint256 _amount)

func (*FaucetFilterer) WatchSent 

func (_Faucet *FaucetFilterer) WatchSent(opts *bind.WatchOpts, sink chan<- *FaucetSent) (event.Subscription, error)

WatchSent is a free log subscription operation binding the contract event 0x3bcb2e664d8f57273201bc888e82d6549f8308a52a9fcd7702b2ea8387f769a9.

Solidity: event sent(address _destination, uint256 _amount)

type FaucetRaw 

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

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

func (*FaucetRaw) Call 

func (_Faucet *FaucetRaw) 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 (*FaucetRaw) Transact 

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

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

func (*FaucetRaw) Transfer 

func (_Faucet *FaucetRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

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

type FaucetReceived 

type FaucetReceived struct {
	Source libcommon.Address
	Amount *big.Int
	Raw    types.Log // Blockchain specific contextual infos
}

FaucetReceived represents a Received event raised by the Faucet contract.

type FaucetReceivedIterator 

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

FaucetReceivedIterator is returned from FilterReceived and is used to iterate over the raw logs and unpacked data for Received events raised by the Faucet contract.

func (*FaucetReceivedIterator) Close 

func (it *FaucetReceivedIterator) Close() error

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

func (*FaucetReceivedIterator) Error 

func (it *FaucetReceivedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*FaucetReceivedIterator) Next 

func (it *FaucetReceivedIterator) 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 FaucetSent 

type FaucetSent struct {
	Destination libcommon.Address
	Amount      *big.Int
	Raw         types.Log // Blockchain specific contextual infos
}

FaucetSent represents a Sent event raised by the Faucet contract.

type FaucetSentIterator 

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

FaucetSentIterator is returned from FilterSent and is used to iterate over the raw logs and unpacked data for Sent events raised by the Faucet contract.

func (*FaucetSentIterator) Close 

func (it *FaucetSentIterator) Close() error

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

func (*FaucetSentIterator) Error 

func (it *FaucetSentIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*FaucetSentIterator) Next 

func (it *FaucetSentIterator) 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 FaucetSession 

type FaucetSession struct {
	Contract     *Faucet           // 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
}

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

func (*FaucetSession) Destinations 

func (_Faucet *FaucetSession) Destinations(arg0 libcommon.Address) (*big.Int, error)

Destinations is a free data retrieval call binding the contract method 0x59c02c37.

Solidity: function destinations(address ) view returns(uint256)

func (*FaucetSession) Receive 

func (_Faucet *FaucetSession) Receive() (types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

func (*FaucetSession) Send 

func (_Faucet *FaucetSession) Send(_destination libcommon.Address, _requested *big.Int) (types.Transaction, error)

Send is a paid mutator transaction binding the contract method 0xd0679d34.

Solidity: function send(address _destination, uint256 _requested) payable returns()

func (*FaucetSession) Sources 

func (_Faucet *FaucetSession) Sources(arg0 libcommon.Address) (*big.Int, error)

Sources is a free data retrieval call binding the contract method 0xb750bdde.

Solidity: function sources(address ) view returns(uint256)

type FaucetTransactor 

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

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

func NewFaucetTransactor 

func NewFaucetTransactor(address libcommon.Address, transactor bind.ContractTransactor) (*FaucetTransactor, error)

NewFaucetTransactor creates a new write-only instance of Faucet, bound to a specific deployed contract.

func (*FaucetTransactor) Receive 

func (_Faucet *FaucetTransactor) Receive(opts *bind.TransactOpts) (types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

func (*FaucetTransactor) Send 

func (_Faucet *FaucetTransactor) Send(opts *bind.TransactOpts, _destination libcommon.Address, _requested *big.Int) (types.Transaction, error)

Send is a paid mutator transaction binding the contract method 0xd0679d34.

Solidity: function send(address _destination, uint256 _requested) payable returns()

type FaucetTransactorRaw 

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

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

func (*FaucetTransactorRaw) Transact 

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

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

func (*FaucetTransactorRaw) Transfer 

func (_Faucet *FaucetTransactorRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

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

type FaucetTransactorSession 

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

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

func (*FaucetTransactorSession) Receive 

func (_Faucet *FaucetTransactorSession) Receive() (types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

func (*FaucetTransactorSession) Send 

func (_Faucet *FaucetTransactorSession) Send(_destination libcommon.Address, _requested *big.Int) (types.Transaction, error)

Send is a paid mutator transaction binding the contract method 0xd0679d34.

Solidity: function send(address _destination, uint256 _requested) payable returns()

type OnStateReceiveParams 

type OnStateReceiveParams struct {
	Param_arg0 *big.Int
	Param_data []byte
}

OnStateReceiveParams is an auto generated read-only Go binding of transcaction calldata params

func ParseOnStateReceive 

func ParseOnStateReceive(calldata []byte) (*OnStateReceiveParams, error)

Parse OnStateReceive method from calldata of a transaction

Solidity: function onStateReceive(uint256 , bytes data) returns()

type ReceiveMessageParams 

type ReceiveMessageParams struct {
	Param_inputData []byte
}

ReceiveMessageParams is an auto generated read-only Go binding of transcaction calldata params

func ParseReceiveMessage 

func ParseReceiveMessage(calldata []byte) (*ReceiveMessageParams, error)

Parse ReceiveMessage method from calldata of a transaction

Solidity: function receiveMessage(bytes inputData) returns()

type RegisterParams 

type RegisterParams struct {
	Param_sender   libcommon.Address
	Param_receiver libcommon.Address
}

RegisterParams is an auto generated read-only Go binding of transcaction calldata params

func ParseRegister 

func ParseRegister(calldata []byte) (*RegisterParams, error)

Parse Register method from calldata of a transaction

Solidity: function register(address sender, address receiver) returns()

type RootReceiver 

type RootReceiver struct {
	RootReceiverCaller     // Read-only binding to the contract
	RootReceiverTransactor // Write-only binding to the contract
	RootReceiverFilterer   // Log filterer for contract events
}

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

func DeployRootReceiver 

func DeployRootReceiver(auth *bind.TransactOpts, backend bind.ContractBackend, _checkpointManager libcommon.Address) (libcommon.Address, types.Transaction, *RootReceiver, error)

DeployRootReceiver deploys a new Ethereum contract, binding an instance of RootReceiver to it.

func NewRootReceiver 

func NewRootReceiver(address libcommon.Address, backend bind.ContractBackend) (*RootReceiver, error)

NewRootReceiver creates a new instance of RootReceiver, bound to a specific deployed contract.

type RootReceiverCaller 

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

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

func NewRootReceiverCaller 

func NewRootReceiverCaller(address libcommon.Address, caller bind.ContractCaller) (*RootReceiverCaller, error)

NewRootReceiverCaller creates a new read-only instance of RootReceiver, bound to a specific deployed contract.

func (*RootReceiverCaller) CheckpointManager 

func (_RootReceiver *RootReceiverCaller) CheckpointManager(opts *bind.CallOpts) (libcommon.Address, error)

CheckpointManager is a free data retrieval call binding the contract method 0xc0857ba0.

Solidity: function checkpointManager() view returns(address)

func (*RootReceiverCaller) ProcessedExits 

func (_RootReceiver *RootReceiverCaller) ProcessedExits(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

ProcessedExits is a free data retrieval call binding the contract method 0x607f2d42.

Solidity: function processedExits(bytes32 ) view returns(bool)

func (*RootReceiverCaller) SENDMESSAGEEVENTSIG 

func (_RootReceiver *RootReceiverCaller) SENDMESSAGEEVENTSIG(opts *bind.CallOpts) ([32]byte, error)

SENDMESSAGEEVENTSIG is a free data retrieval call binding the contract method 0x0e387de6.

Solidity: function SEND_MESSAGE_EVENT_SIG() view returns(bytes32)

func (*RootReceiverCaller) Senders 

func (_RootReceiver *RootReceiverCaller) Senders(opts *bind.CallOpts, arg0 libcommon.Address) (*big.Int, error)

Senders is a free data retrieval call binding the contract method 0x982fb9d8.

Solidity: function senders(address ) view returns(uint256)

type RootReceiverCallerRaw 

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

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

func (*RootReceiverCallerRaw) Call 

func (_RootReceiver *RootReceiverCallerRaw) 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 RootReceiverCallerSession 

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

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

func (*RootReceiverCallerSession) CheckpointManager 

func (_RootReceiver *RootReceiverCallerSession) CheckpointManager() (libcommon.Address, error)

CheckpointManager is a free data retrieval call binding the contract method 0xc0857ba0.

Solidity: function checkpointManager() view returns(address)

func (*RootReceiverCallerSession) ProcessedExits 

func (_RootReceiver *RootReceiverCallerSession) ProcessedExits(arg0 [32]byte) (bool, error)

ProcessedExits is a free data retrieval call binding the contract method 0x607f2d42.

Solidity: function processedExits(bytes32 ) view returns(bool)

func (*RootReceiverCallerSession) SENDMESSAGEEVENTSIG 

func (_RootReceiver *RootReceiverCallerSession) SENDMESSAGEEVENTSIG() ([32]byte, error)

SENDMESSAGEEVENTSIG is a free data retrieval call binding the contract method 0x0e387de6.

Solidity: function SEND_MESSAGE_EVENT_SIG() view returns(bytes32)

func (*RootReceiverCallerSession) Senders 

func (_RootReceiver *RootReceiverCallerSession) Senders(arg0 libcommon.Address) (*big.Int, error)

Senders is a free data retrieval call binding the contract method 0x982fb9d8.

Solidity: function senders(address ) view returns(uint256)

type RootReceiverFilterer 

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

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

func NewRootReceiverFilterer 

func NewRootReceiverFilterer(address libcommon.Address, filterer bind.ContractFilterer) (*RootReceiverFilterer, error)

NewRootReceiverFilterer creates a new log filterer instance of RootReceiver, bound to a specific deployed contract.

func (*RootReceiverFilterer) FilterReceived 

func (_RootReceiver *RootReceiverFilterer) FilterReceived(opts *bind.FilterOpts) (*RootReceiverReceivedIterator, error)

FilterReceived is a free log retrieval operation binding the contract event 0xf11e547d796cc64acdf758e7cee90439494fd886a19159454aa61e473fdbafef.

Solidity: event received(address _source, uint256 _amount)

func (*RootReceiverFilterer) ParseReceived 

func (_RootReceiver *RootReceiverFilterer) ParseReceived(log types.Log) (*RootReceiverReceived, error)

ParseReceived is a log parse operation binding the contract event 0xf11e547d796cc64acdf758e7cee90439494fd886a19159454aa61e473fdbafef.

Solidity: event received(address _source, uint256 _amount)

func (*RootReceiverFilterer) WatchReceived 

func (_RootReceiver *RootReceiverFilterer) WatchReceived(opts *bind.WatchOpts, sink chan<- *RootReceiverReceived) (event.Subscription, error)

WatchReceived is a free log subscription operation binding the contract event 0xf11e547d796cc64acdf758e7cee90439494fd886a19159454aa61e473fdbafef.

Solidity: event received(address _source, uint256 _amount)

type RootReceiverRaw 

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

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

func (*RootReceiverRaw) Call 

func (_RootReceiver *RootReceiverRaw) 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 (*RootReceiverRaw) Transact 

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

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

func (*RootReceiverRaw) Transfer 

func (_RootReceiver *RootReceiverRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

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

type RootReceiverReceived 

type RootReceiverReceived struct {
	Source libcommon.Address
	Amount *big.Int
	Raw    types.Log // Blockchain specific contextual infos
}

RootReceiverReceived represents a Received event raised by the RootReceiver contract.

type RootReceiverReceivedIterator 

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

RootReceiverReceivedIterator is returned from FilterReceived and is used to iterate over the raw logs and unpacked data for Received events raised by the RootReceiver contract.

func (*RootReceiverReceivedIterator) Close 

func (it *RootReceiverReceivedIterator) Close() error

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

func (*RootReceiverReceivedIterator) Error 

func (it *RootReceiverReceivedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootReceiverReceivedIterator) Next 

func (it *RootReceiverReceivedIterator) 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 RootReceiverSession 

type RootReceiverSession struct {
	Contract     *RootReceiver     // 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
}

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

func (*RootReceiverSession) CheckpointManager 

func (_RootReceiver *RootReceiverSession) CheckpointManager() (libcommon.Address, error)

CheckpointManager is a free data retrieval call binding the contract method 0xc0857ba0.

Solidity: function checkpointManager() view returns(address)

func (*RootReceiverSession) ProcessedExits 

func (_RootReceiver *RootReceiverSession) ProcessedExits(arg0 [32]byte) (bool, error)

ProcessedExits is a free data retrieval call binding the contract method 0x607f2d42.

Solidity: function processedExits(bytes32 ) view returns(bool)

func (*RootReceiverSession) ReceiveMessage 

func (_RootReceiver *RootReceiverSession) ReceiveMessage(inputData []byte) (types.Transaction, error)

ReceiveMessage is a paid mutator transaction binding the contract method 0xf953cec7.

Solidity: function receiveMessage(bytes inputData) returns()

func (*RootReceiverSession) SENDMESSAGEEVENTSIG 

func (_RootReceiver *RootReceiverSession) SENDMESSAGEEVENTSIG() ([32]byte, error)

SENDMESSAGEEVENTSIG is a free data retrieval call binding the contract method 0x0e387de6.

Solidity: function SEND_MESSAGE_EVENT_SIG() view returns(bytes32)

func (*RootReceiverSession) Senders 

func (_RootReceiver *RootReceiverSession) Senders(arg0 libcommon.Address) (*big.Int, error)

Senders is a free data retrieval call binding the contract method 0x982fb9d8.

Solidity: function senders(address ) view returns(uint256)

type RootReceiverTransactor 

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

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

func NewRootReceiverTransactor 

func NewRootReceiverTransactor(address libcommon.Address, transactor bind.ContractTransactor) (*RootReceiverTransactor, error)

NewRootReceiverTransactor creates a new write-only instance of RootReceiver, bound to a specific deployed contract.

func (*RootReceiverTransactor) ReceiveMessage 

func (_RootReceiver *RootReceiverTransactor) ReceiveMessage(opts *bind.TransactOpts, inputData []byte) (types.Transaction, error)

ReceiveMessage is a paid mutator transaction binding the contract method 0xf953cec7.

Solidity: function receiveMessage(bytes inputData) returns()

type RootReceiverTransactorRaw 

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

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

func (*RootReceiverTransactorRaw) Transact 

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

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

func (*RootReceiverTransactorRaw) Transfer 

func (_RootReceiver *RootReceiverTransactorRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

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

type RootReceiverTransactorSession 

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

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

func (*RootReceiverTransactorSession) ReceiveMessage 

func (_RootReceiver *RootReceiverTransactorSession) ReceiveMessage(inputData []byte) (types.Transaction, error)

ReceiveMessage is a paid mutator transaction binding the contract method 0xf953cec7.

Solidity: function receiveMessage(bytes inputData) returns()

type RootSender 

type RootSender struct {
	RootSenderCaller     // Read-only binding to the contract
	RootSenderTransactor // Write-only binding to the contract
	RootSenderFilterer   // Log filterer for contract events
}

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

func DeployRootSender 

func DeployRootSender(auth *bind.TransactOpts, backend bind.ContractBackend, stateSender_ libcommon.Address, childStateReceiver_ libcommon.Address) (libcommon.Address, types.Transaction, *RootSender, error)

DeployRootSender deploys a new Ethereum contract, binding an instance of RootSender to it.

func NewRootSender 

func NewRootSender(address libcommon.Address, backend bind.ContractBackend) (*RootSender, error)

NewRootSender creates a new instance of RootSender, bound to a specific deployed contract.

type RootSenderCaller 

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

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

func NewRootSenderCaller 

func NewRootSenderCaller(address libcommon.Address, caller bind.ContractCaller) (*RootSenderCaller, error)

NewRootSenderCaller creates a new read-only instance of RootSender, bound to a specific deployed contract.

func (*RootSenderCaller) Sent 

func (_RootSender *RootSenderCaller) Sent(opts *bind.CallOpts, arg0 libcommon.Address) (*big.Int, error)

Sent is a free data retrieval call binding the contract method 0x7bf786f8.

Solidity: function sent(address ) view returns(uint256)

type RootSenderCallerRaw 

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

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

func (*RootSenderCallerRaw) Call 

func (_RootSender *RootSenderCallerRaw) 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 RootSenderCallerSession 

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

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

func (*RootSenderCallerSession) Sent 

func (_RootSender *RootSenderCallerSession) Sent(arg0 libcommon.Address) (*big.Int, error)

Sent is a free data retrieval call binding the contract method 0x7bf786f8.

Solidity: function sent(address ) view returns(uint256)

type RootSenderFilterer 

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

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

func NewRootSenderFilterer 

func NewRootSenderFilterer(address libcommon.Address, filterer bind.ContractFilterer) (*RootSenderFilterer, error)

NewRootSenderFilterer creates a new log filterer instance of RootSender, bound to a specific deployed contract.

type RootSenderRaw 

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

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

func (*RootSenderRaw) Call 

func (_RootSender *RootSenderRaw) 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 (*RootSenderRaw) Transact 

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

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

func (*RootSenderRaw) Transfer 

func (_RootSender *RootSenderRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

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

type RootSenderSession 

type RootSenderSession struct {
	Contract     *RootSender       // 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
}

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

func (*RootSenderSession) SendToChild 

func (_RootSender *RootSenderSession) SendToChild(amount *big.Int) (types.Transaction, error)

SendToChild is a paid mutator transaction binding the contract method 0x513e29ff.

Solidity: function sendToChild(uint256 amount) returns()

func (*RootSenderSession) Sent 

func (_RootSender *RootSenderSession) Sent(arg0 libcommon.Address) (*big.Int, error)

Sent is a free data retrieval call binding the contract method 0x7bf786f8.

Solidity: function sent(address ) view returns(uint256)

type RootSenderTransactor 

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

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

func NewRootSenderTransactor 

func NewRootSenderTransactor(address libcommon.Address, transactor bind.ContractTransactor) (*RootSenderTransactor, error)

NewRootSenderTransactor creates a new write-only instance of RootSender, bound to a specific deployed contract.

func (*RootSenderTransactor) SendToChild 

func (_RootSender *RootSenderTransactor) SendToChild(opts *bind.TransactOpts, amount *big.Int) (types.Transaction, error)

SendToChild is a paid mutator transaction binding the contract method 0x513e29ff.

Solidity: function sendToChild(uint256 amount) returns()

type RootSenderTransactorRaw 

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

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

func (*RootSenderTransactorRaw) Transact 

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

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

func (*RootSenderTransactorRaw) Transfer 

func (_RootSender *RootSenderTransactorRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

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

type RootSenderTransactorSession 

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

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

func (*RootSenderTransactorSession) SendToChild 

func (_RootSender *RootSenderTransactorSession) SendToChild(amount *big.Int) (types.Transaction, error)

SendToChild is a paid mutator transaction binding the contract method 0x513e29ff.

Solidity: function sendToChild(uint256 amount) returns()

type SendParams 

type SendParams struct {
	Param__destination libcommon.Address
	Param__requested   *big.Int
}

SendParams is an auto generated read-only Go binding of transcaction calldata params

func ParseSend 

func ParseSend(calldata []byte) (*SendParams, error)

Parse Send method from calldata of a transaction

Solidity: function send(address _destination, uint256 _requested) payable returns()

type SendToChildParams 

type SendToChildParams struct {
	Param_amount *big.Int
}

SendToChildParams is an auto generated read-only Go binding of transcaction calldata params

func ParseSendToChild 

func ParseSendToChild(calldata []byte) (*SendToChildParams, error)

Parse SendToChild method from calldata of a transaction

Solidity: function sendToChild(uint256 amount) returns()

type SendToRootParams 

type SendToRootParams struct {
	Param_amount *big.Int
}

SendToRootParams is an auto generated read-only Go binding of transcaction calldata params

func ParseSendToRoot 

func ParseSendToRoot(calldata []byte) (*SendToRootParams, error)

Parse SendToRoot method from calldata of a transaction

Solidity: function sendToRoot(uint256 amount) returns()

type SetHeimdallIdParams 

type SetHeimdallIdParams struct {
	Param__heimdallId string
}

SetHeimdallIdParams is an auto generated read-only Go binding of transcaction calldata params

func ParseSetHeimdallId 

func ParseSetHeimdallId(calldata []byte) (*SetHeimdallIdParams, error)

Parse SetHeimdallId method from calldata of a transaction

Solidity: function setHeimdallId(string _heimdallId) returns()

type SetNextHeaderBlockParams 

type SetNextHeaderBlockParams struct {
	Param__value *big.Int
}

SetNextHeaderBlockParams is an auto generated read-only Go binding of transcaction calldata params

func ParseSetNextHeaderBlock 

func ParseSetNextHeaderBlock(calldata []byte) (*SetNextHeaderBlockParams, error)

Parse SetNextHeaderBlock method from calldata of a transaction

Solidity: function setNextHeaderBlock(uint256 _value) returns()

type SubmitCheckpointParams 

type SubmitCheckpointParams struct {
	Param_data []byte
	Param_arg1 [][3]*big.Int
}

SubmitCheckpointParams is an auto generated read-only Go binding of transcaction calldata params

func ParseSubmitCheckpoint 

func ParseSubmitCheckpoint(calldata []byte) (*SubmitCheckpointParams, error)

Parse SubmitCheckpoint method from calldata of a transaction

Solidity: function submitCheckpoint(bytes data, uint256[3][] ) returns()

type Subscription 

type Subscription struct {
	SubscriptionCaller     // Read-only binding to the contract
	SubscriptionTransactor // Write-only binding to the contract
	SubscriptionFilterer   // Log filterer for contract events
}

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

func DeploySubscription 

func DeploySubscription(auth *bind.TransactOpts, backend bind.ContractBackend) (libcommon.Address, types.Transaction, *Subscription, error)

DeploySubscription deploys a new Ethereum contract, binding an instance of Subscription to it.

func NewSubscription 

func NewSubscription(address libcommon.Address, backend bind.ContractBackend) (*Subscription, error)

NewSubscription creates a new instance of Subscription, bound to a specific deployed contract.

type SubscriptionCaller 

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

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

func NewSubscriptionCaller 

func NewSubscriptionCaller(address libcommon.Address, caller bind.ContractCaller) (*SubscriptionCaller, error)

NewSubscriptionCaller creates a new read-only instance of Subscription, bound to a specific deployed contract.

type SubscriptionCallerRaw 

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

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

func (*SubscriptionCallerRaw) Call 

func (_Subscription *SubscriptionCallerRaw) 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 SubscriptionCallerSession 

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

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

type SubscriptionFilterer 

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

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

func NewSubscriptionFilterer 

func NewSubscriptionFilterer(address libcommon.Address, filterer bind.ContractFilterer) (*SubscriptionFilterer, error)

NewSubscriptionFilterer creates a new log filterer instance of Subscription, bound to a specific deployed contract.

func (*SubscriptionFilterer) FilterSubscriptionEvent 

func (_Subscription *SubscriptionFilterer) FilterSubscriptionEvent(opts *bind.FilterOpts) (*SubscriptionSubscriptionEventIterator, error)

FilterSubscriptionEvent is a free log retrieval operation binding the contract event 0x67abc7edb0ab50964ef0e90541d39366b9c69f6f714520f2ff4570059ee8ad80.

Solidity: event SubscriptionEvent()

func (*SubscriptionFilterer) ParseSubscriptionEvent 

func (_Subscription *SubscriptionFilterer) ParseSubscriptionEvent(log types.Log) (*SubscriptionSubscriptionEvent, error)

ParseSubscriptionEvent is a log parse operation binding the contract event 0x67abc7edb0ab50964ef0e90541d39366b9c69f6f714520f2ff4570059ee8ad80.

Solidity: event SubscriptionEvent()

func (*SubscriptionFilterer) WatchSubscriptionEvent 

func (_Subscription *SubscriptionFilterer) WatchSubscriptionEvent(opts *bind.WatchOpts, sink chan<- *SubscriptionSubscriptionEvent) (event.Subscription, error)

WatchSubscriptionEvent is a free log subscription operation binding the contract event 0x67abc7edb0ab50964ef0e90541d39366b9c69f6f714520f2ff4570059ee8ad80.

Solidity: event SubscriptionEvent()

type SubscriptionRaw 

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

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

func (*SubscriptionRaw) Call 

func (_Subscription *SubscriptionRaw) 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 (*SubscriptionRaw) Transact 

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

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

func (*SubscriptionRaw) Transfer 

func (_Subscription *SubscriptionRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

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

type SubscriptionSession 

type SubscriptionSession struct {
	Contract     *Subscription     // 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
}

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

func (*SubscriptionSession) Fallback 

func (_Subscription *SubscriptionSession) Fallback(calldata []byte) (types.Transaction, error)

Fallback is a paid mutator transaction binding the contract fallback function.

Solidity: fallback() returns()

type SubscriptionSubscriptionEvent 

type SubscriptionSubscriptionEvent struct {
	Raw types.Log // Blockchain specific contextual infos
}

SubscriptionSubscriptionEvent represents a SubscriptionEvent event raised by the Subscription contract.

type SubscriptionSubscriptionEventIterator 

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

SubscriptionSubscriptionEventIterator is returned from FilterSubscriptionEvent and is used to iterate over the raw logs and unpacked data for SubscriptionEvent events raised by the Subscription contract.

func (*SubscriptionSubscriptionEventIterator) Close 

func (it *SubscriptionSubscriptionEventIterator) Close() error

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

func (*SubscriptionSubscriptionEventIterator) Error 

func (it *SubscriptionSubscriptionEventIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*SubscriptionSubscriptionEventIterator) Next 

func (it *SubscriptionSubscriptionEventIterator) 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 SubscriptionTransactor 

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

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

func NewSubscriptionTransactor 

func NewSubscriptionTransactor(address libcommon.Address, transactor bind.ContractTransactor) (*SubscriptionTransactor, error)

NewSubscriptionTransactor creates a new write-only instance of Subscription, bound to a specific deployed contract.

func (*SubscriptionTransactor) Fallback 

func (_Subscription *SubscriptionTransactor) Fallback(opts *bind.TransactOpts, calldata []byte) (types.Transaction, error)

Fallback is a paid mutator transaction binding the contract fallback function.

Solidity: fallback() returns()

type SubscriptionTransactorRaw 

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

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

func (*SubscriptionTransactorRaw) Transact 

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

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

func (*SubscriptionTransactorRaw) Transfer 

func (_Subscription *SubscriptionTransactorRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

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

type SubscriptionTransactorSession 

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

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

func (*SubscriptionTransactorSession) Fallback 

func (_Subscription *SubscriptionTransactorSession) Fallback(calldata []byte) (types.Transaction, error)

Fallback is a paid mutator transaction binding the contract fallback function.

Solidity: fallback() returns()

type SyncStateParams 

type SyncStateParams struct {
	Param_receiver libcommon.Address
	Param_data     []byte
}

SyncStateParams is an auto generated read-only Go binding of transcaction calldata params

func ParseSyncState 

func ParseSyncState(calldata []byte) (*SyncStateParams, error)

Parse SyncState method from calldata of a transaction

Solidity: function syncState(address receiver, bytes data) returns()

type TestRootChain 

type TestRootChain struct {
	TestRootChainCaller     // Read-only binding to the contract
	TestRootChainTransactor // Write-only binding to the contract
	TestRootChainFilterer   // Log filterer for contract events
}

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

func DeployTestRootChain 

func DeployTestRootChain(auth *bind.TransactOpts, backend bind.ContractBackend) (libcommon.Address, types.Transaction, *TestRootChain, error)

DeployTestRootChain deploys a new Ethereum contract, binding an instance of TestRootChain to it.

func NewTestRootChain 

func NewTestRootChain(address libcommon.Address, backend bind.ContractBackend) (*TestRootChain, error)

NewTestRootChain creates a new instance of TestRootChain, bound to a specific deployed contract.

type TestRootChainCaller 

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

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

func NewTestRootChainCaller 

func NewTestRootChainCaller(address libcommon.Address, caller bind.ContractCaller) (*TestRootChainCaller, error)

NewTestRootChainCaller creates a new read-only instance of TestRootChain, bound to a specific deployed contract.

func (*TestRootChainCaller) CHAINID 

func (_TestRootChain *TestRootChainCaller) CHAINID(opts *bind.CallOpts) (*big.Int, error)

CHAINID is a free data retrieval call binding the contract method 0xcc79f97b.

Solidity: function CHAINID() view returns(uint256)

func (*TestRootChainCaller) CurrentHeaderBlock 

func (_TestRootChain *TestRootChainCaller) CurrentHeaderBlock(opts *bind.CallOpts) (*big.Int, error)

CurrentHeaderBlock is a free data retrieval call binding the contract method 0xec7e4855.

Solidity: function currentHeaderBlock() view returns(uint256)

func (*TestRootChainCaller) GetLastChildBlock 

func (_TestRootChain *TestRootChainCaller) GetLastChildBlock(opts *bind.CallOpts) (*big.Int, error)

GetLastChildBlock is a free data retrieval call binding the contract method 0xb87e1b66.

Solidity: function getLastChildBlock() view returns(uint256)

func (*TestRootChainCaller) HeaderBlocks 

func (_TestRootChain *TestRootChainCaller) HeaderBlocks(opts *bind.CallOpts, arg0 *big.Int) (struct {
	Root      [32]byte
	Start     *big.Int
	End       *big.Int
	CreatedAt *big.Int
	Proposer  libcommon.Address
}, error)

HeaderBlocks is a free data retrieval call binding the contract method 0x41539d4a.

Solidity: function headerBlocks(uint256 ) view returns(bytes32 root, uint256 start, uint256 end, uint256 createdAt, address proposer)

func (*TestRootChainCaller) HeimdallId 

func (_TestRootChain *TestRootChainCaller) HeimdallId(opts *bind.CallOpts) ([32]byte, error)

HeimdallId is a free data retrieval call binding the contract method 0xfbc3dd36.

Solidity: function heimdallId() view returns(bytes32)

func (*TestRootChainCaller) NetworkId 

func (_TestRootChain *TestRootChainCaller) NetworkId(opts *bind.CallOpts) ([]byte, error)

NetworkId is a free data retrieval call binding the contract method 0x9025e64c.

Solidity: function networkId() view returns(bytes)

func (*TestRootChainCaller) NextHeaderBlock 

func (_TestRootChain *TestRootChainCaller) NextHeaderBlock(opts *bind.CallOpts) (*big.Int, error)

NextHeaderBlock is a free data retrieval call binding the contract method 0x8d978d88.

Solidity: function _nextHeaderBlock() view returns(uint256)

func (*TestRootChainCaller) SubmitHeaderBlock 

func (_TestRootChain *TestRootChainCaller) SubmitHeaderBlock(opts *bind.CallOpts, arg0 []byte, arg1 []byte) error

SubmitHeaderBlock is a free data retrieval call binding the contract method 0x6a791f11.

Solidity: function submitHeaderBlock(bytes , bytes ) pure returns()

func (*TestRootChainCaller) VOTETYPE 

func (_TestRootChain *TestRootChainCaller) VOTETYPE(opts *bind.CallOpts) (uint8, error)

VOTETYPE is a free data retrieval call binding the contract method 0xd5b844eb.

Solidity: function VOTE_TYPE() view returns(uint8)

type TestRootChainCallerRaw 

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

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

func (*TestRootChainCallerRaw) Call 

func (_TestRootChain *TestRootChainCallerRaw) 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 TestRootChainCallerSession 

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

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

func (*TestRootChainCallerSession) CHAINID 

func (_TestRootChain *TestRootChainCallerSession) CHAINID() (*big.Int, error)

CHAINID is a free data retrieval call binding the contract method 0xcc79f97b.

Solidity: function CHAINID() view returns(uint256)

func (*TestRootChainCallerSession) CurrentHeaderBlock 

func (_TestRootChain *TestRootChainCallerSession) CurrentHeaderBlock() (*big.Int, error)

CurrentHeaderBlock is a free data retrieval call binding the contract method 0xec7e4855.

Solidity: function currentHeaderBlock() view returns(uint256)

func (*TestRootChainCallerSession) GetLastChildBlock 

func (_TestRootChain *TestRootChainCallerSession) GetLastChildBlock() (*big.Int, error)

GetLastChildBlock is a free data retrieval call binding the contract method 0xb87e1b66.

Solidity: function getLastChildBlock() view returns(uint256)

func (*TestRootChainCallerSession) HeaderBlocks 

func (_TestRootChain *TestRootChainCallerSession) HeaderBlocks(arg0 *big.Int) (struct {
	Root      [32]byte
	Start     *big.Int
	End       *big.Int
	CreatedAt *big.Int
	Proposer  libcommon.Address
}, error)

HeaderBlocks is a free data retrieval call binding the contract method 0x41539d4a.

Solidity: function headerBlocks(uint256 ) view returns(bytes32 root, uint256 start, uint256 end, uint256 createdAt, address proposer)

func (*TestRootChainCallerSession) HeimdallId 

func (_TestRootChain *TestRootChainCallerSession) HeimdallId() ([32]byte, error)

HeimdallId is a free data retrieval call binding the contract method 0xfbc3dd36.

Solidity: function heimdallId() view returns(bytes32)

func (*TestRootChainCallerSession) NetworkId 

func (_TestRootChain *TestRootChainCallerSession) NetworkId() ([]byte, error)

NetworkId is a free data retrieval call binding the contract method 0x9025e64c.

Solidity: function networkId() view returns(bytes)

func (*TestRootChainCallerSession) NextHeaderBlock 

func (_TestRootChain *TestRootChainCallerSession) NextHeaderBlock() (*big.Int, error)

NextHeaderBlock is a free data retrieval call binding the contract method 0x8d978d88.

Solidity: function _nextHeaderBlock() view returns(uint256)

func (*TestRootChainCallerSession) SubmitHeaderBlock 

func (_TestRootChain *TestRootChainCallerSession) SubmitHeaderBlock(arg0 []byte, arg1 []byte) error

SubmitHeaderBlock is a free data retrieval call binding the contract method 0x6a791f11.

Solidity: function submitHeaderBlock(bytes , bytes ) pure returns()

func (*TestRootChainCallerSession) VOTETYPE 

func (_TestRootChain *TestRootChainCallerSession) VOTETYPE() (uint8, error)

VOTETYPE is a free data retrieval call binding the contract method 0xd5b844eb.

Solidity: function VOTE_TYPE() view returns(uint8)

type TestRootChainFilterer 

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

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

func NewTestRootChainFilterer 

func NewTestRootChainFilterer(address libcommon.Address, filterer bind.ContractFilterer) (*TestRootChainFilterer, error)

NewTestRootChainFilterer creates a new log filterer instance of TestRootChain, bound to a specific deployed contract.

func (*TestRootChainFilterer) FilterNewHeaderBlock 

func (_TestRootChain *TestRootChainFilterer) FilterNewHeaderBlock(opts *bind.FilterOpts, proposer []libcommon.Address, headerBlockId []*big.Int, reward []*big.Int) (*TestRootChainNewHeaderBlockIterator, error)

FilterNewHeaderBlock is a free log retrieval operation binding the contract event 0xba5de06d22af2685c6c7765f60067f7d2b08c2d29f53cdf14d67f6d1c9bfb527.

Solidity: event NewHeaderBlock(address indexed proposer, uint256 indexed headerBlockId, uint256 indexed reward, uint256 start, uint256 end, bytes32 root)

func (*TestRootChainFilterer) FilterResetHeaderBlock 

func (_TestRootChain *TestRootChainFilterer) FilterResetHeaderBlock(opts *bind.FilterOpts, proposer []libcommon.Address, headerBlockId []*big.Int) (*TestRootChainResetHeaderBlockIterator, error)

FilterResetHeaderBlock is a free log retrieval operation binding the contract event 0xca1d8316287f938830e225956a7bb10fd5a1a1506dd2eb3a476751a488117205.

Solidity: event ResetHeaderBlock(address indexed proposer, uint256 indexed headerBlockId)

func (*TestRootChainFilterer) ParseNewHeaderBlock 

func (_TestRootChain *TestRootChainFilterer) ParseNewHeaderBlock(log types.Log) (*TestRootChainNewHeaderBlock, error)

ParseNewHeaderBlock is a log parse operation binding the contract event 0xba5de06d22af2685c6c7765f60067f7d2b08c2d29f53cdf14d67f6d1c9bfb527.

Solidity: event NewHeaderBlock(address indexed proposer, uint256 indexed headerBlockId, uint256 indexed reward, uint256 start, uint256 end, bytes32 root)

func (*TestRootChainFilterer) ParseResetHeaderBlock 

func (_TestRootChain *TestRootChainFilterer) ParseResetHeaderBlock(log types.Log) (*TestRootChainResetHeaderBlock, error)

ParseResetHeaderBlock is a log parse operation binding the contract event 0xca1d8316287f938830e225956a7bb10fd5a1a1506dd2eb3a476751a488117205.

Solidity: event ResetHeaderBlock(address indexed proposer, uint256 indexed headerBlockId)

func (*TestRootChainFilterer) WatchNewHeaderBlock 

func (_TestRootChain *TestRootChainFilterer) WatchNewHeaderBlock(opts *bind.WatchOpts, sink chan<- *TestRootChainNewHeaderBlock, proposer []libcommon.Address, headerBlockId []*big.Int, reward []*big.Int) (event.Subscription, error)

WatchNewHeaderBlock is a free log subscription operation binding the contract event 0xba5de06d22af2685c6c7765f60067f7d2b08c2d29f53cdf14d67f6d1c9bfb527.

Solidity: event NewHeaderBlock(address indexed proposer, uint256 indexed headerBlockId, uint256 indexed reward, uint256 start, uint256 end, bytes32 root)

func (*TestRootChainFilterer) WatchResetHeaderBlock 

func (_TestRootChain *TestRootChainFilterer) WatchResetHeaderBlock(opts *bind.WatchOpts, sink chan<- *TestRootChainResetHeaderBlock, proposer []libcommon.Address, headerBlockId []*big.Int) (event.Subscription, error)

WatchResetHeaderBlock is a free log subscription operation binding the contract event 0xca1d8316287f938830e225956a7bb10fd5a1a1506dd2eb3a476751a488117205.

Solidity: event ResetHeaderBlock(address indexed proposer, uint256 indexed headerBlockId)

type TestRootChainNewHeaderBlock 

type TestRootChainNewHeaderBlock struct {
	Proposer      libcommon.Address
	HeaderBlockId *big.Int
	Reward        *big.Int
	Start         *big.Int
	End           *big.Int
	Root          [32]byte
	Raw           types.Log // Blockchain specific contextual infos
}

TestRootChainNewHeaderBlock represents a NewHeaderBlock event raised by the TestRootChain contract.

type TestRootChainNewHeaderBlockIterator 

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

TestRootChainNewHeaderBlockIterator is returned from FilterNewHeaderBlock and is used to iterate over the raw logs and unpacked data for NewHeaderBlock events raised by the TestRootChain contract.

func (*TestRootChainNewHeaderBlockIterator) Close 

func (it *TestRootChainNewHeaderBlockIterator) Close() error

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

func (*TestRootChainNewHeaderBlockIterator) Error 

func (it *TestRootChainNewHeaderBlockIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TestRootChainNewHeaderBlockIterator) Next 

func (it *TestRootChainNewHeaderBlockIterator) 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 TestRootChainRaw 

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

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

func (*TestRootChainRaw) Call 

func (_TestRootChain *TestRootChainRaw) 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 (*TestRootChainRaw) Transact 

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

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

func (*TestRootChainRaw) Transfer 

func (_TestRootChain *TestRootChainRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

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

type TestRootChainResetHeaderBlock 

type TestRootChainResetHeaderBlock struct {
	Proposer      libcommon.Address
	HeaderBlockId *big.Int
	Raw           types.Log // Blockchain specific contextual infos
}

TestRootChainResetHeaderBlock represents a ResetHeaderBlock event raised by the TestRootChain contract.

type TestRootChainResetHeaderBlockIterator 

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

TestRootChainResetHeaderBlockIterator is returned from FilterResetHeaderBlock and is used to iterate over the raw logs and unpacked data for ResetHeaderBlock events raised by the TestRootChain contract.

func (*TestRootChainResetHeaderBlockIterator) Close 

func (it *TestRootChainResetHeaderBlockIterator) Close() error

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

func (*TestRootChainResetHeaderBlockIterator) Error 

func (it *TestRootChainResetHeaderBlockIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TestRootChainResetHeaderBlockIterator) Next 

func (it *TestRootChainResetHeaderBlockIterator) 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 TestRootChainSession 

type TestRootChainSession struct {
	Contract     *TestRootChain    // 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
}

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

func (*TestRootChainSession) CHAINID 

func (_TestRootChain *TestRootChainSession) CHAINID() (*big.Int, error)

CHAINID is a free data retrieval call binding the contract method 0xcc79f97b.

Solidity: function CHAINID() view returns(uint256)

func (*TestRootChainSession) CurrentHeaderBlock 

func (_TestRootChain *TestRootChainSession) CurrentHeaderBlock() (*big.Int, error)

CurrentHeaderBlock is a free data retrieval call binding the contract method 0xec7e4855.

Solidity: function currentHeaderBlock() view returns(uint256)

func (*TestRootChainSession) GetLastChildBlock 

func (_TestRootChain *TestRootChainSession) GetLastChildBlock() (*big.Int, error)

GetLastChildBlock is a free data retrieval call binding the contract method 0xb87e1b66.

Solidity: function getLastChildBlock() view returns(uint256)

func (*TestRootChainSession) HeaderBlocks 

func (_TestRootChain *TestRootChainSession) HeaderBlocks(arg0 *big.Int) (struct {
	Root      [32]byte
	Start     *big.Int
	End       *big.Int
	CreatedAt *big.Int
	Proposer  libcommon.Address
}, error)

HeaderBlocks is a free data retrieval call binding the contract method 0x41539d4a.

Solidity: function headerBlocks(uint256 ) view returns(bytes32 root, uint256 start, uint256 end, uint256 createdAt, address proposer)

func (*TestRootChainSession) HeimdallId 

func (_TestRootChain *TestRootChainSession) HeimdallId() ([32]byte, error)

HeimdallId is a free data retrieval call binding the contract method 0xfbc3dd36.

Solidity: function heimdallId() view returns(bytes32)

func (*TestRootChainSession) NetworkId 

func (_TestRootChain *TestRootChainSession) NetworkId() ([]byte, error)

NetworkId is a free data retrieval call binding the contract method 0x9025e64c.

Solidity: function networkId() view returns(bytes)

func (*TestRootChainSession) NextHeaderBlock 

func (_TestRootChain *TestRootChainSession) NextHeaderBlock() (*big.Int, error)

NextHeaderBlock is a free data retrieval call binding the contract method 0x8d978d88.

Solidity: function _nextHeaderBlock() view returns(uint256)

func (*TestRootChainSession) SetHeimdallId 

func (_TestRootChain *TestRootChainSession) SetHeimdallId(_heimdallId string) (types.Transaction, error)

SetHeimdallId is a paid mutator transaction binding the contract method 0xea0688b3.

Solidity: function setHeimdallId(string _heimdallId) returns()

func (*TestRootChainSession) SetNextHeaderBlock 

func (_TestRootChain *TestRootChainSession) SetNextHeaderBlock(_value *big.Int) (types.Transaction, error)

SetNextHeaderBlock is a paid mutator transaction binding the contract method 0xcf24a0ea.

Solidity: function setNextHeaderBlock(uint256 _value) returns()

func (*TestRootChainSession) Slash 

func (_TestRootChain *TestRootChainSession) Slash() (types.Transaction, error)

Slash is a paid mutator transaction binding the contract method 0x2da25de3.

Solidity: function slash() returns()

func (*TestRootChainSession) SubmitCheckpoint 

func (_TestRootChain *TestRootChainSession) SubmitCheckpoint(data []byte, arg1 [][3]*big.Int) (types.Transaction, error)

SubmitCheckpoint is a paid mutator transaction binding the contract method 0x4e43e495.

Solidity: function submitCheckpoint(bytes data, uint256[3][] ) returns()

func (*TestRootChainSession) SubmitHeaderBlock 

func (_TestRootChain *TestRootChainSession) SubmitHeaderBlock(arg0 []byte, arg1 []byte) error

SubmitHeaderBlock is a free data retrieval call binding the contract method 0x6a791f11.

Solidity: function submitHeaderBlock(bytes , bytes ) pure returns()

func (*TestRootChainSession) UpdateDepositId 

func (_TestRootChain *TestRootChainSession) UpdateDepositId(numDeposits *big.Int) (types.Transaction, error)

UpdateDepositId is a paid mutator transaction binding the contract method 0x5391f483.

Solidity: function updateDepositId(uint256 numDeposits) returns(uint256 depositId)

func (*TestRootChainSession) VOTETYPE 

func (_TestRootChain *TestRootChainSession) VOTETYPE() (uint8, error)

VOTETYPE is a free data retrieval call binding the contract method 0xd5b844eb.

Solidity: function VOTE_TYPE() view returns(uint8)

type TestRootChainTransactor 

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

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

func NewTestRootChainTransactor 

func NewTestRootChainTransactor(address libcommon.Address, transactor bind.ContractTransactor) (*TestRootChainTransactor, error)

NewTestRootChainTransactor creates a new write-only instance of TestRootChain, bound to a specific deployed contract.

func (*TestRootChainTransactor) SetHeimdallId 

func (_TestRootChain *TestRootChainTransactor) SetHeimdallId(opts *bind.TransactOpts, _heimdallId string) (types.Transaction, error)

SetHeimdallId is a paid mutator transaction binding the contract method 0xea0688b3.

Solidity: function setHeimdallId(string _heimdallId) returns()

func (*TestRootChainTransactor) SetNextHeaderBlock 

func (_TestRootChain *TestRootChainTransactor) SetNextHeaderBlock(opts *bind.TransactOpts, _value *big.Int) (types.Transaction, error)

SetNextHeaderBlock is a paid mutator transaction binding the contract method 0xcf24a0ea.

Solidity: function setNextHeaderBlock(uint256 _value) returns()

func (*TestRootChainTransactor) Slash 

func (_TestRootChain *TestRootChainTransactor) Slash(opts *bind.TransactOpts) (types.Transaction, error)

Slash is a paid mutator transaction binding the contract method 0x2da25de3.

Solidity: function slash() returns()

func (*TestRootChainTransactor) SubmitCheckpoint 

func (_TestRootChain *TestRootChainTransactor) SubmitCheckpoint(opts *bind.TransactOpts, data []byte, arg1 [][3]*big.Int) (types.Transaction, error)

SubmitCheckpoint is a paid mutator transaction binding the contract method 0x4e43e495.

Solidity: function submitCheckpoint(bytes data, uint256[3][] ) returns()

func (*TestRootChainTransactor) UpdateDepositId 

func (_TestRootChain *TestRootChainTransactor) UpdateDepositId(opts *bind.TransactOpts, numDeposits *big.Int) (types.Transaction, error)

UpdateDepositId is a paid mutator transaction binding the contract method 0x5391f483.

Solidity: function updateDepositId(uint256 numDeposits) returns(uint256 depositId)

type TestRootChainTransactorRaw 

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

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

func (*TestRootChainTransactorRaw) Transact 

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

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

func (*TestRootChainTransactorRaw) Transfer 

func (_TestRootChain *TestRootChainTransactorRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

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

type TestRootChainTransactorSession 

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

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

func (*TestRootChainTransactorSession) SetHeimdallId 

func (_TestRootChain *TestRootChainTransactorSession) SetHeimdallId(_heimdallId string) (types.Transaction, error)

SetHeimdallId is a paid mutator transaction binding the contract method 0xea0688b3.

Solidity: function setHeimdallId(string _heimdallId) returns()

func (*TestRootChainTransactorSession) SetNextHeaderBlock 

func (_TestRootChain *TestRootChainTransactorSession) SetNextHeaderBlock(_value *big.Int) (types.Transaction, error)

SetNextHeaderBlock is a paid mutator transaction binding the contract method 0xcf24a0ea.

Solidity: function setNextHeaderBlock(uint256 _value) returns()

func (*TestRootChainTransactorSession) Slash 

func (_TestRootChain *TestRootChainTransactorSession) Slash() (types.Transaction, error)

Slash is a paid mutator transaction binding the contract method 0x2da25de3.

Solidity: function slash() returns()

func (*TestRootChainTransactorSession) SubmitCheckpoint 

func (_TestRootChain *TestRootChainTransactorSession) SubmitCheckpoint(data []byte, arg1 [][3]*big.Int) (types.Transaction, error)

SubmitCheckpoint is a paid mutator transaction binding the contract method 0x4e43e495.

Solidity: function submitCheckpoint(bytes data, uint256[3][] ) returns()

func (*TestRootChainTransactorSession) UpdateDepositId 

func (_TestRootChain *TestRootChainTransactorSession) UpdateDepositId(numDeposits *big.Int) (types.Transaction, error)

UpdateDepositId is a paid mutator transaction binding the contract method 0x5391f483.

Solidity: function updateDepositId(uint256 numDeposits) returns(uint256 depositId)

type TestStateSender 

type TestStateSender struct {
	TestStateSenderCaller     // Read-only binding to the contract
	TestStateSenderTransactor // Write-only binding to the contract
	TestStateSenderFilterer   // Log filterer for contract events
}

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

func DeployTestStateSender 

func DeployTestStateSender(auth *bind.TransactOpts, backend bind.ContractBackend) (libcommon.Address, types.Transaction, *TestStateSender, error)

DeployTestStateSender deploys a new Ethereum contract, binding an instance of TestStateSender to it.

func NewTestStateSender 

func NewTestStateSender(address libcommon.Address, backend bind.ContractBackend) (*TestStateSender, error)

NewTestStateSender creates a new instance of TestStateSender, bound to a specific deployed contract.

type TestStateSenderCaller 

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

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

func NewTestStateSenderCaller 

func NewTestStateSenderCaller(address libcommon.Address, caller bind.ContractCaller) (*TestStateSenderCaller, error)

NewTestStateSenderCaller creates a new read-only instance of TestStateSender, bound to a specific deployed contract.

func (*TestStateSenderCaller) Counter 

func (_TestStateSender *TestStateSenderCaller) Counter(opts *bind.CallOpts) (*big.Int, error)

Counter is a free data retrieval call binding the contract method 0x61bc221a.

Solidity: function counter() view returns(uint256)

func (*TestStateSenderCaller) Registrations 

func (_TestStateSender *TestStateSenderCaller) Registrations(opts *bind.CallOpts, arg0 libcommon.Address) (libcommon.Address, error)

Registrations is a free data retrieval call binding the contract method 0x942e6bcf.

Solidity: function registrations(address ) view returns(address)

type TestStateSenderCallerRaw 

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

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

func (*TestStateSenderCallerRaw) Call 

func (_TestStateSender *TestStateSenderCallerRaw) 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 TestStateSenderCallerSession 

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

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

func (*TestStateSenderCallerSession) Counter 

func (_TestStateSender *TestStateSenderCallerSession) Counter() (*big.Int, error)

Counter is a free data retrieval call binding the contract method 0x61bc221a.

Solidity: function counter() view returns(uint256)

func (*TestStateSenderCallerSession) Registrations 

func (_TestStateSender *TestStateSenderCallerSession) Registrations(arg0 libcommon.Address) (libcommon.Address, error)

Registrations is a free data retrieval call binding the contract method 0x942e6bcf.

Solidity: function registrations(address ) view returns(address)

type TestStateSenderFilterer 

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

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

func NewTestStateSenderFilterer 

func NewTestStateSenderFilterer(address libcommon.Address, filterer bind.ContractFilterer) (*TestStateSenderFilterer, error)

NewTestStateSenderFilterer creates a new log filterer instance of TestStateSender, bound to a specific deployed contract.

func (*TestStateSenderFilterer) FilterNewRegistration 

func (_TestStateSender *TestStateSenderFilterer) FilterNewRegistration(opts *bind.FilterOpts, user []libcommon.Address, sender []libcommon.Address, receiver []libcommon.Address) (*TestStateSenderNewRegistrationIterator, error)

FilterNewRegistration is a free log retrieval operation binding the contract event 0x3f4512aacd7a664fdb321a48e8340120d63253a91c6367a143abd19ecf68aedd.

Solidity: event NewRegistration(address indexed user, address indexed sender, address indexed receiver)

func (*TestStateSenderFilterer) FilterRegistrationUpdated 

func (_TestStateSender *TestStateSenderFilterer) FilterRegistrationUpdated(opts *bind.FilterOpts, user []libcommon.Address, sender []libcommon.Address, receiver []libcommon.Address) (*TestStateSenderRegistrationUpdatedIterator, error)

FilterRegistrationUpdated is a free log retrieval operation binding the contract event 0xc51cb1a93ec91e927852b3445875ec77b148271953e5c0b43698c968ad6fc47d.

Solidity: event RegistrationUpdated(address indexed user, address indexed sender, address indexed receiver)

func (*TestStateSenderFilterer) FilterStateSynced 

func (_TestStateSender *TestStateSenderFilterer) FilterStateSynced(opts *bind.FilterOpts, id []*big.Int, contractAddress []libcommon.Address) (*TestStateSenderStateSyncedIterator, error)

FilterStateSynced is a free log retrieval operation binding the contract event 0x103fed9db65eac19c4d870f49ab7520fe03b99f1838e5996caf47e9e43308392.

Solidity: event StateSynced(uint256 indexed id, address indexed contractAddress, bytes data)

func (*TestStateSenderFilterer) ParseNewRegistration 

func (_TestStateSender *TestStateSenderFilterer) ParseNewRegistration(log types.Log) (*TestStateSenderNewRegistration, error)

ParseNewRegistration is a log parse operation binding the contract event 0x3f4512aacd7a664fdb321a48e8340120d63253a91c6367a143abd19ecf68aedd.

Solidity: event NewRegistration(address indexed user, address indexed sender, address indexed receiver)

func (*TestStateSenderFilterer) ParseRegistrationUpdated 

func (_TestStateSender *TestStateSenderFilterer) ParseRegistrationUpdated(log types.Log) (*TestStateSenderRegistrationUpdated, error)

ParseRegistrationUpdated is a log parse operation binding the contract event 0xc51cb1a93ec91e927852b3445875ec77b148271953e5c0b43698c968ad6fc47d.

Solidity: event RegistrationUpdated(address indexed user, address indexed sender, address indexed receiver)

func (*TestStateSenderFilterer) ParseStateSynced 

func (_TestStateSender *TestStateSenderFilterer) ParseStateSynced(log types.Log) (*TestStateSenderStateSynced, error)

ParseStateSynced is a log parse operation binding the contract event 0x103fed9db65eac19c4d870f49ab7520fe03b99f1838e5996caf47e9e43308392.

Solidity: event StateSynced(uint256 indexed id, address indexed contractAddress, bytes data)

func (*TestStateSenderFilterer) WatchNewRegistration 

func (_TestStateSender *TestStateSenderFilterer) WatchNewRegistration(opts *bind.WatchOpts, sink chan<- *TestStateSenderNewRegistration, user []libcommon.Address, sender []libcommon.Address, receiver []libcommon.Address) (event.Subscription, error)

WatchNewRegistration is a free log subscription operation binding the contract event 0x3f4512aacd7a664fdb321a48e8340120d63253a91c6367a143abd19ecf68aedd.

Solidity: event NewRegistration(address indexed user, address indexed sender, address indexed receiver)

func (*TestStateSenderFilterer) WatchRegistrationUpdated 

func (_TestStateSender *TestStateSenderFilterer) WatchRegistrationUpdated(opts *bind.WatchOpts, sink chan<- *TestStateSenderRegistrationUpdated, user []libcommon.Address, sender []libcommon.Address, receiver []libcommon.Address) (event.Subscription, error)

WatchRegistrationUpdated is a free log subscription operation binding the contract event 0xc51cb1a93ec91e927852b3445875ec77b148271953e5c0b43698c968ad6fc47d.

Solidity: event RegistrationUpdated(address indexed user, address indexed sender, address indexed receiver)

func (*TestStateSenderFilterer) WatchStateSynced 

func (_TestStateSender *TestStateSenderFilterer) WatchStateSynced(opts *bind.WatchOpts, sink chan<- *TestStateSenderStateSynced, id []*big.Int, contractAddress []libcommon.Address) (event.Subscription, error)

WatchStateSynced is a free log subscription operation binding the contract event 0x103fed9db65eac19c4d870f49ab7520fe03b99f1838e5996caf47e9e43308392.

Solidity: event StateSynced(uint256 indexed id, address indexed contractAddress, bytes data)

type TestStateSenderNewRegistration 

type TestStateSenderNewRegistration struct {
	User     libcommon.Address
	Sender   libcommon.Address
	Receiver libcommon.Address
	Raw      types.Log // Blockchain specific contextual infos
}

TestStateSenderNewRegistration represents a NewRegistration event raised by the TestStateSender contract.

type TestStateSenderNewRegistrationIterator 

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

TestStateSenderNewRegistrationIterator is returned from FilterNewRegistration and is used to iterate over the raw logs and unpacked data for NewRegistration events raised by the TestStateSender contract.

func (*TestStateSenderNewRegistrationIterator) Close 

func (it *TestStateSenderNewRegistrationIterator) Close() error

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

func (*TestStateSenderNewRegistrationIterator) Error 

func (it *TestStateSenderNewRegistrationIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TestStateSenderNewRegistrationIterator) Next 

func (it *TestStateSenderNewRegistrationIterator) 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 TestStateSenderRaw 

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

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

func (*TestStateSenderRaw) Call 

func (_TestStateSender *TestStateSenderRaw) 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 (*TestStateSenderRaw) Transact 

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

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

func (*TestStateSenderRaw) Transfer 

func (_TestStateSender *TestStateSenderRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

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

type TestStateSenderRegistrationUpdated 

type TestStateSenderRegistrationUpdated struct {
	User     libcommon.Address
	Sender   libcommon.Address
	Receiver libcommon.Address
	Raw      types.Log // Blockchain specific contextual infos
}

TestStateSenderRegistrationUpdated represents a RegistrationUpdated event raised by the TestStateSender contract.

type TestStateSenderRegistrationUpdatedIterator 

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

TestStateSenderRegistrationUpdatedIterator is returned from FilterRegistrationUpdated and is used to iterate over the raw logs and unpacked data for RegistrationUpdated events raised by the TestStateSender contract.

func (*TestStateSenderRegistrationUpdatedIterator) Close 

func (it *TestStateSenderRegistrationUpdatedIterator) Close() error

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

func (*TestStateSenderRegistrationUpdatedIterator) Error 

func (it *TestStateSenderRegistrationUpdatedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TestStateSenderRegistrationUpdatedIterator) Next 

func (it *TestStateSenderRegistrationUpdatedIterator) 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 TestStateSenderSession 

type TestStateSenderSession struct {
	Contract     *TestStateSender  // 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
}

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

func (*TestStateSenderSession) Counter 

func (_TestStateSender *TestStateSenderSession) Counter() (*big.Int, error)

Counter is a free data retrieval call binding the contract method 0x61bc221a.

Solidity: function counter() view returns(uint256)

func (*TestStateSenderSession) Register 

func (_TestStateSender *TestStateSenderSession) Register(sender libcommon.Address, receiver libcommon.Address) (types.Transaction, error)

Register is a paid mutator transaction binding the contract method 0xaa677354.

Solidity: function register(address sender, address receiver) returns()

func (*TestStateSenderSession) Registrations 

func (_TestStateSender *TestStateSenderSession) Registrations(arg0 libcommon.Address) (libcommon.Address, error)

Registrations is a free data retrieval call binding the contract method 0x942e6bcf.

Solidity: function registrations(address ) view returns(address)

func (*TestStateSenderSession) SyncState 

func (_TestStateSender *TestStateSenderSession) SyncState(receiver libcommon.Address, data []byte) (types.Transaction, error)

SyncState is a paid mutator transaction binding the contract method 0x16f19831.

Solidity: function syncState(address receiver, bytes data) returns()

type TestStateSenderStateSynced 

type TestStateSenderStateSynced struct {
	Id              *big.Int
	ContractAddress libcommon.Address
	Data            []byte
	Raw             types.Log // Blockchain specific contextual infos
}

TestStateSenderStateSynced represents a StateSynced event raised by the TestStateSender contract.

type TestStateSenderStateSyncedIterator 

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

TestStateSenderStateSyncedIterator is returned from FilterStateSynced and is used to iterate over the raw logs and unpacked data for StateSynced events raised by the TestStateSender contract.

func (*TestStateSenderStateSyncedIterator) Close 

func (it *TestStateSenderStateSyncedIterator) Close() error

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

func (*TestStateSenderStateSyncedIterator) Error 

func (it *TestStateSenderStateSyncedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TestStateSenderStateSyncedIterator) Next 

func (it *TestStateSenderStateSyncedIterator) 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 TestStateSenderTransactor 

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

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

func NewTestStateSenderTransactor 

func NewTestStateSenderTransactor(address libcommon.Address, transactor bind.ContractTransactor) (*TestStateSenderTransactor, error)

NewTestStateSenderTransactor creates a new write-only instance of TestStateSender, bound to a specific deployed contract.

func (*TestStateSenderTransactor) Register 

func (_TestStateSender *TestStateSenderTransactor) Register(opts *bind.TransactOpts, sender libcommon.Address, receiver libcommon.Address) (types.Transaction, error)

Register is a paid mutator transaction binding the contract method 0xaa677354.

Solidity: function register(address sender, address receiver) returns()

func (*TestStateSenderTransactor) SyncState 

func (_TestStateSender *TestStateSenderTransactor) SyncState(opts *bind.TransactOpts, receiver libcommon.Address, data []byte) (types.Transaction, error)

SyncState is a paid mutator transaction binding the contract method 0x16f19831.

Solidity: function syncState(address receiver, bytes data) returns()

type TestStateSenderTransactorRaw 

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

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

func (*TestStateSenderTransactorRaw) Transact 

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

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

func (*TestStateSenderTransactorRaw) Transfer 

func (_TestStateSender *TestStateSenderTransactorRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

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

type TestStateSenderTransactorSession 

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

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

func (*TestStateSenderTransactorSession) Register 

func (_TestStateSender *TestStateSenderTransactorSession) Register(sender libcommon.Address, receiver libcommon.Address) (types.Transaction, error)

Register is a paid mutator transaction binding the contract method 0xaa677354.

Solidity: function register(address sender, address receiver) returns()

func (*TestStateSenderTransactorSession) SyncState 

func (_TestStateSender *TestStateSenderTransactorSession) SyncState(receiver libcommon.Address, data []byte) (types.Transaction, error)

SyncState is a paid mutator transaction binding the contract method 0x16f19831.

Solidity: function syncState(address receiver, bytes data) returns()

type UpdateDepositIdParams 

type UpdateDepositIdParams struct {
	Param_numDeposits *big.Int
}

UpdateDepositIdParams is an auto generated read-only Go binding of transcaction calldata params

func ParseUpdateDepositId 

func ParseUpdateDepositId(calldata []byte) (*UpdateDepositIdParams, error)

Parse UpdateDepositId method from calldata of a transaction

Solidity: function updateDepositId(uint256 numDeposits) returns(uint256 depositId)

Source Files

View all Source files

Directories

Path Synopsis

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.