ethbridgetestcontracts

package
v0.7.3 Latest Latest
Warning

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

 Go to latest Published: Nov 24, 2020 License: Apache-2.0 Imports: 8 Imported by: 0

Documentation

Index

Constants

View Source 
const ChallengeTesterABI = "" /* 1050-byte string literal not displayed */

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

View Source 
const MachineTesterABI = "" /* 688-byte string literal not displayed */

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

View Source 
const MessageTesterABI = "" /* 3687-byte string literal not displayed */

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

View Source 
const NodeGraphUtilsABI = "[]"

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

View Source 
const PrecompilesTesterABI = "" /* 655-byte string literal not displayed */

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

View Source 
const RollupTesterABI = "" /* 7745-byte string literal not displayed */

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

View Source 
const RollupUtilsABI = "[]"

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

View Source 
const SafeMathABI = "[]"

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

View Source 
const VMABI = "[]"

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

View Source 
const ValueTesterABI = "" /* 1901-byte string literal not displayed */

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

Variables

View Source 
var ChallengeTesterBin = "" /* 1022-byte string literal not displayed */

ChallengeTesterBin is the compiled bytecode used for deploying new contracts.

View Source 
var ChallengeTesterFuncSigs = map[string]string{
	"396f51cf": "resolveChallenge(address,address)",
	"8f43ee32": "startChallenge(address,address,uint128,bytes32,uint256)",
}

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

View Source 
var MachineTesterBin = "" /* 9254-byte string literal not displayed */

MachineTesterBin is the compiled bytecode used for deploying new contracts.

View Source 
var MachineTesterFuncSigs = map[string]string{
	"5f098d7f": "addStackVal(bytes,bytes)",
	"5270f3e9": "deserializeMachine(bytes)",
}

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

View Source 
var MessageTesterBin = "" /* 11516-byte string literal not displayed */

MessageTesterBin is the compiled bytecode used for deploying new contracts.

View Source 
var MessageTesterFuncSigs = map[string]string{
	"a3b39209": "addMessageToInbox(bytes32,bytes32)",
	"fdaf43c1": "messageHash(uint8,address,uint256,uint256,uint256,bytes32)",
	"9aa86e86": "messageValueHash(uint8,uint256,uint256,address,uint256,bytes)",
	"6520427f": "parseERC20Message(bytes)",
	"fe517bd0": "parseERC721Message(bytes)",
	"ec65668c": "parseEthMessage(bytes)",
	"6b0d3519": "unmarshalOutgoingMessage(bytes,uint256)",
}

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

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

NodeGraphUtilsBin is the compiled bytecode used for deploying new contracts.

View Source 
var PrecompilesTesterBin = "" /* 11020-byte string literal not displayed */

PrecompilesTesterBin is the compiled bytecode used for deploying new contracts.

View Source 
var PrecompilesTesterFuncSigs = map[string]string{
	"ac90ed46": "keccakF(uint256[25])",
	"7757783d": "sha256Block(uint256[2],uint256)",
}

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

View Source 
var RollupTesterBin = "" /* 20164-byte string literal not displayed */

RollupTesterBin is the compiled bytecode used for deploying new contracts.

View Source 
var RollupTesterFuncSigs = map[string]string{
	"9584b946": "calculateLeafFromPath(bytes32,bytes32[])",
	"df8f77ed": "childNodeHash(bytes32,uint256,bytes32,uint256,bytes32)",
	"28ef9d40": "computePrevLeaf(bytes32[8],uint256[5],uint32,uint64,uint64,uint64,uint64)",
	"47994dc6": "computeProtoHashBefore(bytes32,bytes32,uint256,uint256,uint256)",
	"dcea8ab2": "confirm(bytes32,bytes32,uint256,uint256[],uint256[],bytes32[],bytes32[],bytes32[],uint256[],bytes)",
	"5f2de795": "generateInvalidExecutionLeaf(uint256,uint256,uint256,bytes32[8],uint256[5],uint32,uint64,uint64,uint64,uint64)",
	"65aee548": "generateInvalidInboxTopLeaf(uint256[4],bytes32[8],uint256[5],uint32,uint64,uint64,uint64,uint64)",
	"02be0bd0": "generateLastMessageHash(bytes,uint256,uint256)",
	"785b5774": "generateValidLeaf(uint256,bytes32[8],uint256[5],uint32,uint64,uint64,uint64,uint64)",
	"b1fca916": "processValidNode(bytes32[],bytes32[],uint256[],bytes,uint256,uint256,uint256)",
}

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

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

RollupUtilsBin is the compiled bytecode used for deploying new contracts.

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

SafeMathBin is the compiled bytecode used for deploying new contracts.

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

VMBin is the compiled bytecode used for deploying new contracts.

View Source 
var ValueTesterBin = "" /* 11442-byte string literal not displayed */

ValueTesterBin is the compiled bytecode used for deploying new contracts.

View Source 
var ValueTesterFuncSigs = map[string]string{
	"b325b7d0": "bytesToBytestackHash(bytes,uint256,uint256)",
	"e4d476f4": "bytestackToBytes(bytes,uint256)",
	"98206792": "deserializeHash(bytes,uint256)",
	"fd5d0c8b": "hashTestTuple()",
	"c6d25c8e": "hashTuplePreImage(bytes32,uint256)",
}

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

Functions

This section is empty.

Types

type ChallengeTester 

type ChallengeTester struct {
	ChallengeTesterCaller     // Read-only binding to the contract
	ChallengeTesterTransactor // Write-only binding to the contract
	ChallengeTesterFilterer   // Log filterer for contract events
}

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

func DeployChallengeTester 

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

DeployChallengeTester deploys a new Ethereum contract, binding an instance of ChallengeTester to it.

func NewChallengeTester 

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

NewChallengeTester creates a new instance of ChallengeTester, bound to a specific deployed contract.

type ChallengeTesterCaller 

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

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

func NewChallengeTesterCaller 

func NewChallengeTesterCaller(address common.Address, caller bind.ContractCaller) (*ChallengeTesterCaller, error)

NewChallengeTesterCaller creates a new read-only instance of ChallengeTester, bound to a specific deployed contract.

type ChallengeTesterCallerRaw 

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

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

func (*ChallengeTesterCallerRaw) Call 

func (_ChallengeTester *ChallengeTesterCallerRaw) 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 ChallengeTesterCallerSession 

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

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

type ChallengeTesterFilterer 

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

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

func NewChallengeTesterFilterer 

func NewChallengeTesterFilterer(address common.Address, filterer bind.ContractFilterer) (*ChallengeTesterFilterer, error)

NewChallengeTesterFilterer creates a new log filterer instance of ChallengeTester, bound to a specific deployed contract.

type ChallengeTesterRaw 

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

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

func (*ChallengeTesterRaw) Call 

func (_ChallengeTester *ChallengeTesterRaw) 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 (*ChallengeTesterRaw) Transact 

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

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

func (*ChallengeTesterRaw) Transfer 

func (_ChallengeTester *ChallengeTesterRaw) 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 ChallengeTesterSession 

type ChallengeTesterSession struct {
	Contract     *ChallengeTester  // 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
}

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

func (*ChallengeTesterSession) ResolveChallenge 

func (_ChallengeTester *ChallengeTesterSession) ResolveChallenge(arg0 common.Address, arg1 common.Address) (*types.Transaction, error)

ResolveChallenge is a paid mutator transaction binding the contract method 0x396f51cf.

Solidity: function resolveChallenge(address , address ) returns()

func (*ChallengeTesterSession) StartChallenge 

func (_ChallengeTester *ChallengeTesterSession) StartChallenge(asserterAddress common.Address, challengerAddress common.Address, challengerPeriodTicks *big.Int, challengerDataHash [32]byte, challengeType *big.Int) (*types.Transaction, error)

StartChallenge is a paid mutator transaction binding the contract method 0x8f43ee32.

Solidity: function startChallenge(address asserterAddress, address challengerAddress, uint128 challengerPeriodTicks, bytes32 challengerDataHash, uint256 challengeType) returns()

type ChallengeTesterTransactor 

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

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

func NewChallengeTesterTransactor 

func NewChallengeTesterTransactor(address common.Address, transactor bind.ContractTransactor) (*ChallengeTesterTransactor, error)

NewChallengeTesterTransactor creates a new write-only instance of ChallengeTester, bound to a specific deployed contract.

func (*ChallengeTesterTransactor) ResolveChallenge 

func (_ChallengeTester *ChallengeTesterTransactor) ResolveChallenge(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address) (*types.Transaction, error)

ResolveChallenge is a paid mutator transaction binding the contract method 0x396f51cf.

Solidity: function resolveChallenge(address , address ) returns()

func (*ChallengeTesterTransactor) StartChallenge 

func (_ChallengeTester *ChallengeTesterTransactor) StartChallenge(opts *bind.TransactOpts, asserterAddress common.Address, challengerAddress common.Address, challengerPeriodTicks *big.Int, challengerDataHash [32]byte, challengeType *big.Int) (*types.Transaction, error)

StartChallenge is a paid mutator transaction binding the contract method 0x8f43ee32.

Solidity: function startChallenge(address asserterAddress, address challengerAddress, uint128 challengerPeriodTicks, bytes32 challengerDataHash, uint256 challengeType) returns()

type ChallengeTesterTransactorRaw 

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

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

func (*ChallengeTesterTransactorRaw) Transact 

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

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

func (*ChallengeTesterTransactorRaw) Transfer 

func (_ChallengeTester *ChallengeTesterTransactorRaw) 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 ChallengeTesterTransactorSession 

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

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

func (*ChallengeTesterTransactorSession) ResolveChallenge 

func (_ChallengeTester *ChallengeTesterTransactorSession) ResolveChallenge(arg0 common.Address, arg1 common.Address) (*types.Transaction, error)

ResolveChallenge is a paid mutator transaction binding the contract method 0x396f51cf.

Solidity: function resolveChallenge(address , address ) returns()

func (*ChallengeTesterTransactorSession) StartChallenge 

func (_ChallengeTester *ChallengeTesterTransactorSession) StartChallenge(asserterAddress common.Address, challengerAddress common.Address, challengerPeriodTicks *big.Int, challengerDataHash [32]byte, challengeType *big.Int) (*types.Transaction, error)

StartChallenge is a paid mutator transaction binding the contract method 0x8f43ee32.

Solidity: function startChallenge(address asserterAddress, address challengerAddress, uint128 challengerPeriodTicks, bytes32 challengerDataHash, uint256 challengeType) returns()

type MachineTester 

type MachineTester struct {
	MachineTesterCaller     // Read-only binding to the contract
	MachineTesterTransactor // Write-only binding to the contract
	MachineTesterFilterer   // Log filterer for contract events
}

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

func DeployMachineTester 

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

DeployMachineTester deploys a new Ethereum contract, binding an instance of MachineTester to it.

func NewMachineTester 

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

NewMachineTester creates a new instance of MachineTester, bound to a specific deployed contract.

type MachineTesterCaller 

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

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

func NewMachineTesterCaller 

func NewMachineTesterCaller(address common.Address, caller bind.ContractCaller) (*MachineTesterCaller, error)

NewMachineTesterCaller creates a new read-only instance of MachineTester, bound to a specific deployed contract.

func (*MachineTesterCaller) AddStackVal 

func (_MachineTester *MachineTesterCaller) AddStackVal(opts *bind.CallOpts, data1 []byte, data2 []byte) ([32]byte, error)

AddStackVal is a free data retrieval call binding the contract method 0x5f098d7f.

Solidity: function addStackVal(bytes data1, bytes data2) pure returns(bytes32)

func (*MachineTesterCaller) DeserializeMachine 

func (_MachineTester *MachineTesterCaller) DeserializeMachine(opts *bind.CallOpts, data []byte) (*big.Int, [32]byte, error)

DeserializeMachine is a free data retrieval call binding the contract method 0x5270f3e9.

Solidity: function deserializeMachine(bytes data) pure returns(uint256, bytes32)

type MachineTesterCallerRaw 

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

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

func (*MachineTesterCallerRaw) Call 

func (_MachineTester *MachineTesterCallerRaw) 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 MachineTesterCallerSession 

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

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

func (*MachineTesterCallerSession) AddStackVal 

func (_MachineTester *MachineTesterCallerSession) AddStackVal(data1 []byte, data2 []byte) ([32]byte, error)

AddStackVal is a free data retrieval call binding the contract method 0x5f098d7f.

Solidity: function addStackVal(bytes data1, bytes data2) pure returns(bytes32)

func (*MachineTesterCallerSession) DeserializeMachine 

func (_MachineTester *MachineTesterCallerSession) DeserializeMachine(data []byte) (*big.Int, [32]byte, error)

DeserializeMachine is a free data retrieval call binding the contract method 0x5270f3e9.

Solidity: function deserializeMachine(bytes data) pure returns(uint256, bytes32)

type MachineTesterFilterer 

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

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

func NewMachineTesterFilterer 

func NewMachineTesterFilterer(address common.Address, filterer bind.ContractFilterer) (*MachineTesterFilterer, error)

NewMachineTesterFilterer creates a new log filterer instance of MachineTester, bound to a specific deployed contract.

type MachineTesterRaw 

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

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

func (*MachineTesterRaw) Call 

func (_MachineTester *MachineTesterRaw) 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 (*MachineTesterRaw) Transact 

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

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

func (*MachineTesterRaw) Transfer 

func (_MachineTester *MachineTesterRaw) 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 MachineTesterSession 

type MachineTesterSession struct {
	Contract     *MachineTester    // 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
}

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

func (*MachineTesterSession) AddStackVal 

func (_MachineTester *MachineTesterSession) AddStackVal(data1 []byte, data2 []byte) ([32]byte, error)

AddStackVal is a free data retrieval call binding the contract method 0x5f098d7f.

Solidity: function addStackVal(bytes data1, bytes data2) pure returns(bytes32)

func (*MachineTesterSession) DeserializeMachine 

func (_MachineTester *MachineTesterSession) DeserializeMachine(data []byte) (*big.Int, [32]byte, error)

DeserializeMachine is a free data retrieval call binding the contract method 0x5270f3e9.

Solidity: function deserializeMachine(bytes data) pure returns(uint256, bytes32)

type MachineTesterTransactor 

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

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

func NewMachineTesterTransactor 

func NewMachineTesterTransactor(address common.Address, transactor bind.ContractTransactor) (*MachineTesterTransactor, error)

NewMachineTesterTransactor creates a new write-only instance of MachineTester, bound to a specific deployed contract.

type MachineTesterTransactorRaw 

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

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

func (*MachineTesterTransactorRaw) Transact 

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

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

func (*MachineTesterTransactorRaw) Transfer 

func (_MachineTester *MachineTesterTransactorRaw) 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 MachineTesterTransactorSession 

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

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

type MessageTester 

type MessageTester struct {
	MessageTesterCaller     // Read-only binding to the contract
	MessageTesterTransactor // Write-only binding to the contract
	MessageTesterFilterer   // Log filterer for contract events
}

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

func DeployMessageTester 

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

DeployMessageTester deploys a new Ethereum contract, binding an instance of MessageTester to it.

func NewMessageTester 

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

NewMessageTester creates a new instance of MessageTester, bound to a specific deployed contract.

type MessageTesterCaller 

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

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

func NewMessageTesterCaller 

func NewMessageTesterCaller(address common.Address, caller bind.ContractCaller) (*MessageTesterCaller, error)

NewMessageTesterCaller creates a new read-only instance of MessageTester, bound to a specific deployed contract.

func (*MessageTesterCaller) AddMessageToInbox 

func (_MessageTester *MessageTesterCaller) AddMessageToInbox(opts *bind.CallOpts, inbox [32]byte, message [32]byte) ([32]byte, error)

AddMessageToInbox is a free data retrieval call binding the contract method 0xa3b39209.

Solidity: function addMessageToInbox(bytes32 inbox, bytes32 message) pure returns(bytes32)

func (*MessageTesterCaller) MessageHash 

func (_MessageTester *MessageTesterCaller) MessageHash(opts *bind.CallOpts, messageType uint8, sender common.Address, blockNumber *big.Int, timestamp *big.Int, inboxSeqNum *big.Int, messageDataHash [32]byte) ([32]byte, error)

MessageHash is a free data retrieval call binding the contract method 0xfdaf43c1.

Solidity: function messageHash(uint8 messageType, address sender, uint256 blockNumber, uint256 timestamp, uint256 inboxSeqNum, bytes32 messageDataHash) pure returns(bytes32)

func (*MessageTesterCaller) MessageValueHash 

func (_MessageTester *MessageTesterCaller) MessageValueHash(opts *bind.CallOpts, messageType uint8, blockNumber *big.Int, timestamp *big.Int, sender common.Address, inboxSeqNum *big.Int, messageData []byte) ([32]byte, error)

MessageValueHash is a free data retrieval call binding the contract method 0x9aa86e86.

Solidity: function messageValueHash(uint8 messageType, uint256 blockNumber, uint256 timestamp, address sender, uint256 inboxSeqNum, bytes messageData) pure returns(bytes32)

func (*MessageTesterCaller) ParseERC20Message 

func (_MessageTester *MessageTesterCaller) ParseERC20Message(opts *bind.CallOpts, data []byte) (struct {
	Valid bool
	Token common.Address
	Dest  common.Address
	Value *big.Int
}, error)

ParseERC20Message is a free data retrieval call binding the contract method 0x6520427f.

Solidity: function parseERC20Message(bytes data) pure returns(bool valid, address token, address dest, uint256 value)

func (*MessageTesterCaller) ParseERC721Message 

func (_MessageTester *MessageTesterCaller) ParseERC721Message(opts *bind.CallOpts, data []byte) (struct {
	Valid bool
	Token common.Address
	Dest  common.Address
	Id    *big.Int
}, error)

ParseERC721Message is a free data retrieval call binding the contract method 0xfe517bd0.

Solidity: function parseERC721Message(bytes data) pure returns(bool valid, address token, address dest, uint256 id)

func (*MessageTesterCaller) ParseEthMessage 

func (_MessageTester *MessageTesterCaller) ParseEthMessage(opts *bind.CallOpts, data []byte) (struct {
	Valid bool
	Dest  common.Address
	Value *big.Int
}, error)

ParseEthMessage is a free data retrieval call binding the contract method 0xec65668c.

Solidity: function parseEthMessage(bytes data) pure returns(bool valid, address dest, uint256 value)

func (*MessageTesterCaller) UnmarshalOutgoingMessage 

func (_MessageTester *MessageTesterCaller) UnmarshalOutgoingMessage(opts *bind.CallOpts, data []byte, startOffset *big.Int) (bool, *big.Int, uint8, common.Address, []byte, error)

UnmarshalOutgoingMessage is a free data retrieval call binding the contract method 0x6b0d3519.

Solidity: function unmarshalOutgoingMessage(bytes data, uint256 startOffset) pure returns(bool, uint256, uint8, address, bytes)

type MessageTesterCallerRaw 

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

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

func (*MessageTesterCallerRaw) Call 

func (_MessageTester *MessageTesterCallerRaw) 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 MessageTesterCallerSession 

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

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

func (*MessageTesterCallerSession) AddMessageToInbox 

func (_MessageTester *MessageTesterCallerSession) AddMessageToInbox(inbox [32]byte, message [32]byte) ([32]byte, error)

AddMessageToInbox is a free data retrieval call binding the contract method 0xa3b39209.

Solidity: function addMessageToInbox(bytes32 inbox, bytes32 message) pure returns(bytes32)

func (*MessageTesterCallerSession) MessageHash 

func (_MessageTester *MessageTesterCallerSession) MessageHash(messageType uint8, sender common.Address, blockNumber *big.Int, timestamp *big.Int, inboxSeqNum *big.Int, messageDataHash [32]byte) ([32]byte, error)

MessageHash is a free data retrieval call binding the contract method 0xfdaf43c1.

Solidity: function messageHash(uint8 messageType, address sender, uint256 blockNumber, uint256 timestamp, uint256 inboxSeqNum, bytes32 messageDataHash) pure returns(bytes32)

func (*MessageTesterCallerSession) MessageValueHash 

func (_MessageTester *MessageTesterCallerSession) MessageValueHash(messageType uint8, blockNumber *big.Int, timestamp *big.Int, sender common.Address, inboxSeqNum *big.Int, messageData []byte) ([32]byte, error)

MessageValueHash is a free data retrieval call binding the contract method 0x9aa86e86.

Solidity: function messageValueHash(uint8 messageType, uint256 blockNumber, uint256 timestamp, address sender, uint256 inboxSeqNum, bytes messageData) pure returns(bytes32)

func (*MessageTesterCallerSession) ParseERC20Message 

func (_MessageTester *MessageTesterCallerSession) ParseERC20Message(data []byte) (struct {
	Valid bool
	Token common.Address
	Dest  common.Address
	Value *big.Int
}, error)

ParseERC20Message is a free data retrieval call binding the contract method 0x6520427f.

Solidity: function parseERC20Message(bytes data) pure returns(bool valid, address token, address dest, uint256 value)

func (*MessageTesterCallerSession) ParseERC721Message 

func (_MessageTester *MessageTesterCallerSession) ParseERC721Message(data []byte) (struct {
	Valid bool
	Token common.Address
	Dest  common.Address
	Id    *big.Int
}, error)

ParseERC721Message is a free data retrieval call binding the contract method 0xfe517bd0.

Solidity: function parseERC721Message(bytes data) pure returns(bool valid, address token, address dest, uint256 id)

func (*MessageTesterCallerSession) ParseEthMessage 

func (_MessageTester *MessageTesterCallerSession) ParseEthMessage(data []byte) (struct {
	Valid bool
	Dest  common.Address
	Value *big.Int
}, error)

ParseEthMessage is a free data retrieval call binding the contract method 0xec65668c.

Solidity: function parseEthMessage(bytes data) pure returns(bool valid, address dest, uint256 value)

func (*MessageTesterCallerSession) UnmarshalOutgoingMessage 

func (_MessageTester *MessageTesterCallerSession) UnmarshalOutgoingMessage(data []byte, startOffset *big.Int) (bool, *big.Int, uint8, common.Address, []byte, error)

UnmarshalOutgoingMessage is a free data retrieval call binding the contract method 0x6b0d3519.

Solidity: function unmarshalOutgoingMessage(bytes data, uint256 startOffset) pure returns(bool, uint256, uint8, address, bytes)

type MessageTesterFilterer 

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

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

func NewMessageTesterFilterer 

func NewMessageTesterFilterer(address common.Address, filterer bind.ContractFilterer) (*MessageTesterFilterer, error)

NewMessageTesterFilterer creates a new log filterer instance of MessageTester, bound to a specific deployed contract.

type MessageTesterRaw 

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

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

func (*MessageTesterRaw) Call 

func (_MessageTester *MessageTesterRaw) 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 (*MessageTesterRaw) Transact 

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

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

func (*MessageTesterRaw) Transfer 

func (_MessageTester *MessageTesterRaw) 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 MessageTesterSession 

type MessageTesterSession struct {
	Contract     *MessageTester    // 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
}

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

func (*MessageTesterSession) AddMessageToInbox 

func (_MessageTester *MessageTesterSession) AddMessageToInbox(inbox [32]byte, message [32]byte) ([32]byte, error)

AddMessageToInbox is a free data retrieval call binding the contract method 0xa3b39209.

Solidity: function addMessageToInbox(bytes32 inbox, bytes32 message) pure returns(bytes32)

func (*MessageTesterSession) MessageHash 

func (_MessageTester *MessageTesterSession) MessageHash(messageType uint8, sender common.Address, blockNumber *big.Int, timestamp *big.Int, inboxSeqNum *big.Int, messageDataHash [32]byte) ([32]byte, error)

MessageHash is a free data retrieval call binding the contract method 0xfdaf43c1.

Solidity: function messageHash(uint8 messageType, address sender, uint256 blockNumber, uint256 timestamp, uint256 inboxSeqNum, bytes32 messageDataHash) pure returns(bytes32)

func (*MessageTesterSession) MessageValueHash 

func (_MessageTester *MessageTesterSession) MessageValueHash(messageType uint8, blockNumber *big.Int, timestamp *big.Int, sender common.Address, inboxSeqNum *big.Int, messageData []byte) ([32]byte, error)

MessageValueHash is a free data retrieval call binding the contract method 0x9aa86e86.

Solidity: function messageValueHash(uint8 messageType, uint256 blockNumber, uint256 timestamp, address sender, uint256 inboxSeqNum, bytes messageData) pure returns(bytes32)

func (*MessageTesterSession) ParseERC20Message 

func (_MessageTester *MessageTesterSession) ParseERC20Message(data []byte) (struct {
	Valid bool
	Token common.Address
	Dest  common.Address
	Value *big.Int
}, error)

ParseERC20Message is a free data retrieval call binding the contract method 0x6520427f.

Solidity: function parseERC20Message(bytes data) pure returns(bool valid, address token, address dest, uint256 value)

func (*MessageTesterSession) ParseERC721Message 

func (_MessageTester *MessageTesterSession) ParseERC721Message(data []byte) (struct {
	Valid bool
	Token common.Address
	Dest  common.Address
	Id    *big.Int
}, error)

ParseERC721Message is a free data retrieval call binding the contract method 0xfe517bd0.

Solidity: function parseERC721Message(bytes data) pure returns(bool valid, address token, address dest, uint256 id)

func (*MessageTesterSession) ParseEthMessage 

func (_MessageTester *MessageTesterSession) ParseEthMessage(data []byte) (struct {
	Valid bool
	Dest  common.Address
	Value *big.Int
}, error)

ParseEthMessage is a free data retrieval call binding the contract method 0xec65668c.

Solidity: function parseEthMessage(bytes data) pure returns(bool valid, address dest, uint256 value)

func (*MessageTesterSession) UnmarshalOutgoingMessage 

func (_MessageTester *MessageTesterSession) UnmarshalOutgoingMessage(data []byte, startOffset *big.Int) (bool, *big.Int, uint8, common.Address, []byte, error)

UnmarshalOutgoingMessage is a free data retrieval call binding the contract method 0x6b0d3519.

Solidity: function unmarshalOutgoingMessage(bytes data, uint256 startOffset) pure returns(bool, uint256, uint8, address, bytes)

type MessageTesterTransactor 

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

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

func NewMessageTesterTransactor 

func NewMessageTesterTransactor(address common.Address, transactor bind.ContractTransactor) (*MessageTesterTransactor, error)

NewMessageTesterTransactor creates a new write-only instance of MessageTester, bound to a specific deployed contract.

type MessageTesterTransactorRaw 

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

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

func (*MessageTesterTransactorRaw) Transact 

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

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

func (*MessageTesterTransactorRaw) Transfer 

func (_MessageTester *MessageTesterTransactorRaw) 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 MessageTesterTransactorSession 

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

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

type NodeGraphUtils 

type NodeGraphUtils struct {
	NodeGraphUtilsCaller     // Read-only binding to the contract
	NodeGraphUtilsTransactor // Write-only binding to the contract
	NodeGraphUtilsFilterer   // Log filterer for contract events
}

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

func DeployNodeGraphUtils 

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

DeployNodeGraphUtils deploys a new Ethereum contract, binding an instance of NodeGraphUtils to it.

func NewNodeGraphUtils 

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

NewNodeGraphUtils creates a new instance of NodeGraphUtils, bound to a specific deployed contract.

type NodeGraphUtilsCaller 

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

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

func NewNodeGraphUtilsCaller 

func NewNodeGraphUtilsCaller(address common.Address, caller bind.ContractCaller) (*NodeGraphUtilsCaller, error)

NewNodeGraphUtilsCaller creates a new read-only instance of NodeGraphUtils, bound to a specific deployed contract.

type NodeGraphUtilsCallerRaw 

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

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

func (*NodeGraphUtilsCallerRaw) Call 

func (_NodeGraphUtils *NodeGraphUtilsCallerRaw) 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 NodeGraphUtilsCallerSession 

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

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

type NodeGraphUtilsFilterer 

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

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

func NewNodeGraphUtilsFilterer 

func NewNodeGraphUtilsFilterer(address common.Address, filterer bind.ContractFilterer) (*NodeGraphUtilsFilterer, error)

NewNodeGraphUtilsFilterer creates a new log filterer instance of NodeGraphUtils, bound to a specific deployed contract.

type NodeGraphUtilsRaw 

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

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

func (*NodeGraphUtilsRaw) Call 

func (_NodeGraphUtils *NodeGraphUtilsRaw) 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 (*NodeGraphUtilsRaw) Transact 

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

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

func (*NodeGraphUtilsRaw) Transfer 

func (_NodeGraphUtils *NodeGraphUtilsRaw) 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 NodeGraphUtilsSession 

type NodeGraphUtilsSession struct {
	Contract     *NodeGraphUtils   // 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
}

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

type NodeGraphUtilsTransactor 

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

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

func NewNodeGraphUtilsTransactor 

func NewNodeGraphUtilsTransactor(address common.Address, transactor bind.ContractTransactor) (*NodeGraphUtilsTransactor, error)

NewNodeGraphUtilsTransactor creates a new write-only instance of NodeGraphUtils, bound to a specific deployed contract.

type NodeGraphUtilsTransactorRaw 

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

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

func (*NodeGraphUtilsTransactorRaw) Transact 

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

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

func (*NodeGraphUtilsTransactorRaw) Transfer 

func (_NodeGraphUtils *NodeGraphUtilsTransactorRaw) 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 NodeGraphUtilsTransactorSession 

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

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

type PrecompilesTester added in v0.7.2 

type PrecompilesTester struct {
	PrecompilesTesterCaller     // Read-only binding to the contract
	PrecompilesTesterTransactor // Write-only binding to the contract
	PrecompilesTesterFilterer   // Log filterer for contract events
}

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

func DeployPrecompilesTester added in v0.7.2 

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

DeployPrecompilesTester deploys a new Ethereum contract, binding an instance of PrecompilesTester to it.

func NewPrecompilesTester added in v0.7.2 

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

NewPrecompilesTester creates a new instance of PrecompilesTester, bound to a specific deployed contract.

type PrecompilesTesterCaller added in v0.7.2 

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

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

func NewPrecompilesTesterCaller added in v0.7.2 

func NewPrecompilesTesterCaller(address common.Address, caller bind.ContractCaller) (*PrecompilesTesterCaller, error)

NewPrecompilesTesterCaller creates a new read-only instance of PrecompilesTester, bound to a specific deployed contract.

func (*PrecompilesTesterCaller) KeccakF added in v0.7.2 

func (_PrecompilesTester *PrecompilesTesterCaller) KeccakF(opts *bind.CallOpts, input [25]*big.Int) ([25]*big.Int, error)

KeccakF is a free data retrieval call binding the contract method 0xac90ed46.

Solidity: function keccakF(uint256[25] input) pure returns(uint256[25])

func (*PrecompilesTesterCaller) Sha256Block added in v0.7.2 

func (_PrecompilesTester *PrecompilesTesterCaller) Sha256Block(opts *bind.CallOpts, inputChunk [2]*big.Int, hashState *big.Int) (*big.Int, error)

Sha256Block is a free data retrieval call binding the contract method 0x7757783d.

Solidity: function sha256Block(uint256[2] inputChunk, uint256 hashState) pure returns(uint256)

type PrecompilesTesterCallerRaw added in v0.7.2 

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

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

func (*PrecompilesTesterCallerRaw) Call added in v0.7.2 

func (_PrecompilesTester *PrecompilesTesterCallerRaw) 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 PrecompilesTesterCallerSession added in v0.7.2 

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

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

func (*PrecompilesTesterCallerSession) KeccakF added in v0.7.2 

func (_PrecompilesTester *PrecompilesTesterCallerSession) KeccakF(input [25]*big.Int) ([25]*big.Int, error)

KeccakF is a free data retrieval call binding the contract method 0xac90ed46.

Solidity: function keccakF(uint256[25] input) pure returns(uint256[25])

func (*PrecompilesTesterCallerSession) Sha256Block added in v0.7.2 

func (_PrecompilesTester *PrecompilesTesterCallerSession) Sha256Block(inputChunk [2]*big.Int, hashState *big.Int) (*big.Int, error)

Sha256Block is a free data retrieval call binding the contract method 0x7757783d.

Solidity: function sha256Block(uint256[2] inputChunk, uint256 hashState) pure returns(uint256)

type PrecompilesTesterFilterer added in v0.7.2 

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

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

func NewPrecompilesTesterFilterer added in v0.7.2 

func NewPrecompilesTesterFilterer(address common.Address, filterer bind.ContractFilterer) (*PrecompilesTesterFilterer, error)

NewPrecompilesTesterFilterer creates a new log filterer instance of PrecompilesTester, bound to a specific deployed contract.

type PrecompilesTesterRaw added in v0.7.2 

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

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

func (*PrecompilesTesterRaw) Call added in v0.7.2 

func (_PrecompilesTester *PrecompilesTesterRaw) 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 (*PrecompilesTesterRaw) Transact added in v0.7.2 

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

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

func (*PrecompilesTesterRaw) Transfer added in v0.7.2 

func (_PrecompilesTester *PrecompilesTesterRaw) 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 PrecompilesTesterSession added in v0.7.2 

type PrecompilesTesterSession struct {
	Contract     *PrecompilesTester // 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
}

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

func (*PrecompilesTesterSession) KeccakF added in v0.7.2 

func (_PrecompilesTester *PrecompilesTesterSession) KeccakF(input [25]*big.Int) ([25]*big.Int, error)

KeccakF is a free data retrieval call binding the contract method 0xac90ed46.

Solidity: function keccakF(uint256[25] input) pure returns(uint256[25])

func (*PrecompilesTesterSession) Sha256Block added in v0.7.2 

func (_PrecompilesTester *PrecompilesTesterSession) Sha256Block(inputChunk [2]*big.Int, hashState *big.Int) (*big.Int, error)

Sha256Block is a free data retrieval call binding the contract method 0x7757783d.

Solidity: function sha256Block(uint256[2] inputChunk, uint256 hashState) pure returns(uint256)

type PrecompilesTesterTransactor added in v0.7.2 

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

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

func NewPrecompilesTesterTransactor added in v0.7.2 

func NewPrecompilesTesterTransactor(address common.Address, transactor bind.ContractTransactor) (*PrecompilesTesterTransactor, error)

NewPrecompilesTesterTransactor creates a new write-only instance of PrecompilesTester, bound to a specific deployed contract.

type PrecompilesTesterTransactorRaw added in v0.7.2 

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

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

func (*PrecompilesTesterTransactorRaw) Transact added in v0.7.2 

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

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

func (*PrecompilesTesterTransactorRaw) Transfer added in v0.7.2 

func (_PrecompilesTester *PrecompilesTesterTransactorRaw) 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 PrecompilesTesterTransactorSession added in v0.7.2 

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

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

type RollupTester 

type RollupTester struct {
	RollupTesterCaller     // Read-only binding to the contract
	RollupTesterTransactor // Write-only binding to the contract
	RollupTesterFilterer   // Log filterer for contract events
}

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

func DeployRollupTester 

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

DeployRollupTester deploys a new Ethereum contract, binding an instance of RollupTester to it.

func NewRollupTester 

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

NewRollupTester creates a new instance of RollupTester, bound to a specific deployed contract.

type RollupTesterCaller 

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

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

func NewRollupTesterCaller 

func NewRollupTesterCaller(address common.Address, caller bind.ContractCaller) (*RollupTesterCaller, error)

NewRollupTesterCaller creates a new read-only instance of RollupTester, bound to a specific deployed contract.

func (*RollupTesterCaller) CalculateLeafFromPath 

func (_RollupTester *RollupTesterCaller) CalculateLeafFromPath(opts *bind.CallOpts, from [32]byte, proof [][32]byte) ([32]byte, error)

CalculateLeafFromPath is a free data retrieval call binding the contract method 0x9584b946.

Solidity: function calculateLeafFromPath(bytes32 from, bytes32[] proof) pure returns(bytes32)

func (*RollupTesterCaller) ChildNodeHash 

func (_RollupTester *RollupTesterCaller) ChildNodeHash(opts *bind.CallOpts, prevNodeHash [32]byte, deadlineTicks *big.Int, nodeDataHash [32]byte, childType *big.Int, vmProtoStateHash [32]byte) ([32]byte, error)

ChildNodeHash is a free data retrieval call binding the contract method 0xdf8f77ed.

Solidity: function childNodeHash(bytes32 prevNodeHash, uint256 deadlineTicks, bytes32 nodeDataHash, uint256 childType, bytes32 vmProtoStateHash) pure returns(bytes32)

func (*RollupTesterCaller) ComputePrevLeaf 

func (_RollupTester *RollupTesterCaller) ComputePrevLeaf(opts *bind.CallOpts, fields [8][32]byte, fields2 [5]*big.Int, prevChildType uint32, numSteps uint64, numArbGas uint64, messageCount uint64, logCount uint64) (struct {
	PrevLeaf          [32]byte
	VmProtoHashBefore [32]byte
}, error)

ComputePrevLeaf is a free data retrieval call binding the contract method 0x28ef9d40.

Solidity: function computePrevLeaf(bytes32[8] fields, uint256[5] fields2, uint32 prevChildType, uint64 numSteps, uint64 numArbGas, uint64 messageCount, uint64 logCount) pure returns(bytes32 prevLeaf, bytes32 vmProtoHashBefore)

func (*RollupTesterCaller) ComputeProtoHashBefore 

func (_RollupTester *RollupTesterCaller) ComputeProtoHashBefore(opts *bind.CallOpts, machineHash [32]byte, inboxTop [32]byte, inboxCount *big.Int, messageCount *big.Int, logCount *big.Int) ([32]byte, error)

ComputeProtoHashBefore is a free data retrieval call binding the contract method 0x47994dc6.

Solidity: function computeProtoHashBefore(bytes32 machineHash, bytes32 inboxTop, uint256 inboxCount, uint256 messageCount, uint256 logCount) pure returns(bytes32)

func (*RollupTesterCaller) Confirm 

func (_RollupTester *RollupTesterCaller) Confirm(opts *bind.CallOpts, confNode [32]byte, initalProtoStateHash [32]byte, beforeSendCount *big.Int, branches []*big.Int, deadlineTicks []*big.Int, challengeNodeData [][32]byte, logsAcc [][32]byte, vmProtoStateHashes [][32]byte, messageCounts []*big.Int, messages []byte) (struct {
	ValidNodeHashes  [][32]byte
	VmProtoStateHash [32]byte
	LastNodeHash     [32]byte
}, error)

Confirm is a free data retrieval call binding the contract method 0xdcea8ab2.

Solidity: function confirm(bytes32 confNode, bytes32 initalProtoStateHash, uint256 beforeSendCount, uint256[] branches, uint256[] deadlineTicks, bytes32[] challengeNodeData, bytes32[] logsAcc, bytes32[] vmProtoStateHashes, uint256[] messageCounts, bytes messages) pure returns(bytes32[] validNodeHashes, bytes32 vmProtoStateHash, bytes32 lastNodeHash)

func (*RollupTesterCaller) GenerateInvalidExecutionLeaf 

func (_RollupTester *RollupTesterCaller) GenerateInvalidExecutionLeaf(opts *bind.CallOpts, gracePeriodTicks *big.Int, checkTimeTicks *big.Int, deadlineTicks *big.Int, fields [8][32]byte, fields2 [5]*big.Int, prevChildType uint32, numSteps uint64, numArbGas uint64, messageCount uint64, logCount uint64) ([32]byte, error)

GenerateInvalidExecutionLeaf is a free data retrieval call binding the contract method 0x5f2de795.

Solidity: function generateInvalidExecutionLeaf(uint256 gracePeriodTicks, uint256 checkTimeTicks, uint256 deadlineTicks, bytes32[8] fields, uint256[5] fields2, uint32 prevChildType, uint64 numSteps, uint64 numArbGas, uint64 messageCount, uint64 logCount) pure returns(bytes32)

func (*RollupTesterCaller) GenerateInvalidInboxTopLeaf 

func (_RollupTester *RollupTesterCaller) GenerateInvalidInboxTopLeaf(opts *bind.CallOpts, invalidInboxData [4]*big.Int, fields [8][32]byte, fields2 [5]*big.Int, prevChildType uint32, numSteps uint64, numArbGas uint64, messageCount uint64, logCount uint64) ([32]byte, error)

GenerateInvalidInboxTopLeaf is a free data retrieval call binding the contract method 0x65aee548.

Solidity: function generateInvalidInboxTopLeaf(uint256[4] invalidInboxData, bytes32[8] fields, uint256[5] fields2, uint32 prevChildType, uint64 numSteps, uint64 numArbGas, uint64 messageCount, uint64 logCount) pure returns(bytes32)

func (*RollupTesterCaller) GenerateLastMessageHash 

func (_RollupTester *RollupTesterCaller) GenerateLastMessageHash(opts *bind.CallOpts, messages []byte, startOffset *big.Int, length *big.Int) ([32]byte, *big.Int, error)

GenerateLastMessageHash is a free data retrieval call binding the contract method 0x02be0bd0.

Solidity: function generateLastMessageHash(bytes messages, uint256 startOffset, uint256 length) pure returns(bytes32, uint256)

func (*RollupTesterCaller) GenerateValidLeaf 

func (_RollupTester *RollupTesterCaller) GenerateValidLeaf(opts *bind.CallOpts, deadlineTicks *big.Int, fields [8][32]byte, fields2 [5]*big.Int, prevChildType uint32, numSteps uint64, numArbGas uint64, messageCount uint64, logCount uint64) ([32]byte, error)

GenerateValidLeaf is a free data retrieval call binding the contract method 0x785b5774.

Solidity: function generateValidLeaf(uint256 deadlineTicks, bytes32[8] fields, uint256[5] fields2, uint32 prevChildType, uint64 numSteps, uint64 numArbGas, uint64 messageCount, uint64 logCount) pure returns(bytes32)

func (*RollupTesterCaller) ProcessValidNode 

func (_RollupTester *RollupTesterCaller) ProcessValidNode(opts *bind.CallOpts, logsAcc [][32]byte, vmProtoStateHashes [][32]byte, messageCounts []*big.Int, messages []byte, validNum *big.Int, beforeSendCount *big.Int, startOffset *big.Int) (struct {
	AfterSendCount   *big.Int
	AfterOffset      *big.Int
	NodeDataHash     [32]byte
	VmProtoStateHash [32]byte
}, error)

ProcessValidNode is a free data retrieval call binding the contract method 0xb1fca916.

Solidity: function processValidNode(bytes32[] logsAcc, bytes32[] vmProtoStateHashes, uint256[] messageCounts, bytes messages, uint256 validNum, uint256 beforeSendCount, uint256 startOffset) pure returns(uint256 afterSendCount, uint256 afterOffset, bytes32 nodeDataHash, bytes32 vmProtoStateHash)

type RollupTesterCallerRaw 

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

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

func (*RollupTesterCallerRaw) Call 

func (_RollupTester *RollupTesterCallerRaw) 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 RollupTesterCallerSession 

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

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

func (*RollupTesterCallerSession) CalculateLeafFromPath 

func (_RollupTester *RollupTesterCallerSession) CalculateLeafFromPath(from [32]byte, proof [][32]byte) ([32]byte, error)

CalculateLeafFromPath is a free data retrieval call binding the contract method 0x9584b946.

Solidity: function calculateLeafFromPath(bytes32 from, bytes32[] proof) pure returns(bytes32)

func (*RollupTesterCallerSession) ChildNodeHash 

func (_RollupTester *RollupTesterCallerSession) ChildNodeHash(prevNodeHash [32]byte, deadlineTicks *big.Int, nodeDataHash [32]byte, childType *big.Int, vmProtoStateHash [32]byte) ([32]byte, error)

ChildNodeHash is a free data retrieval call binding the contract method 0xdf8f77ed.

Solidity: function childNodeHash(bytes32 prevNodeHash, uint256 deadlineTicks, bytes32 nodeDataHash, uint256 childType, bytes32 vmProtoStateHash) pure returns(bytes32)

func (*RollupTesterCallerSession) ComputePrevLeaf 

func (_RollupTester *RollupTesterCallerSession) ComputePrevLeaf(fields [8][32]byte, fields2 [5]*big.Int, prevChildType uint32, numSteps uint64, numArbGas uint64, messageCount uint64, logCount uint64) (struct {
	PrevLeaf          [32]byte
	VmProtoHashBefore [32]byte
}, error)

ComputePrevLeaf is a free data retrieval call binding the contract method 0x28ef9d40.

Solidity: function computePrevLeaf(bytes32[8] fields, uint256[5] fields2, uint32 prevChildType, uint64 numSteps, uint64 numArbGas, uint64 messageCount, uint64 logCount) pure returns(bytes32 prevLeaf, bytes32 vmProtoHashBefore)

func (*RollupTesterCallerSession) ComputeProtoHashBefore 

func (_RollupTester *RollupTesterCallerSession) ComputeProtoHashBefore(machineHash [32]byte, inboxTop [32]byte, inboxCount *big.Int, messageCount *big.Int, logCount *big.Int) ([32]byte, error)

ComputeProtoHashBefore is a free data retrieval call binding the contract method 0x47994dc6.

Solidity: function computeProtoHashBefore(bytes32 machineHash, bytes32 inboxTop, uint256 inboxCount, uint256 messageCount, uint256 logCount) pure returns(bytes32)

func (*RollupTesterCallerSession) Confirm 

func (_RollupTester *RollupTesterCallerSession) Confirm(confNode [32]byte, initalProtoStateHash [32]byte, beforeSendCount *big.Int, branches []*big.Int, deadlineTicks []*big.Int, challengeNodeData [][32]byte, logsAcc [][32]byte, vmProtoStateHashes [][32]byte, messageCounts []*big.Int, messages []byte) (struct {
	ValidNodeHashes  [][32]byte
	VmProtoStateHash [32]byte
	LastNodeHash     [32]byte
}, error)

Confirm is a free data retrieval call binding the contract method 0xdcea8ab2.

Solidity: function confirm(bytes32 confNode, bytes32 initalProtoStateHash, uint256 beforeSendCount, uint256[] branches, uint256[] deadlineTicks, bytes32[] challengeNodeData, bytes32[] logsAcc, bytes32[] vmProtoStateHashes, uint256[] messageCounts, bytes messages) pure returns(bytes32[] validNodeHashes, bytes32 vmProtoStateHash, bytes32 lastNodeHash)

func (*RollupTesterCallerSession) GenerateInvalidExecutionLeaf 

func (_RollupTester *RollupTesterCallerSession) GenerateInvalidExecutionLeaf(gracePeriodTicks *big.Int, checkTimeTicks *big.Int, deadlineTicks *big.Int, fields [8][32]byte, fields2 [5]*big.Int, prevChildType uint32, numSteps uint64, numArbGas uint64, messageCount uint64, logCount uint64) ([32]byte, error)

GenerateInvalidExecutionLeaf is a free data retrieval call binding the contract method 0x5f2de795.

Solidity: function generateInvalidExecutionLeaf(uint256 gracePeriodTicks, uint256 checkTimeTicks, uint256 deadlineTicks, bytes32[8] fields, uint256[5] fields2, uint32 prevChildType, uint64 numSteps, uint64 numArbGas, uint64 messageCount, uint64 logCount) pure returns(bytes32)

func (*RollupTesterCallerSession) GenerateInvalidInboxTopLeaf 

func (_RollupTester *RollupTesterCallerSession) GenerateInvalidInboxTopLeaf(invalidInboxData [4]*big.Int, fields [8][32]byte, fields2 [5]*big.Int, prevChildType uint32, numSteps uint64, numArbGas uint64, messageCount uint64, logCount uint64) ([32]byte, error)

GenerateInvalidInboxTopLeaf is a free data retrieval call binding the contract method 0x65aee548.

Solidity: function generateInvalidInboxTopLeaf(uint256[4] invalidInboxData, bytes32[8] fields, uint256[5] fields2, uint32 prevChildType, uint64 numSteps, uint64 numArbGas, uint64 messageCount, uint64 logCount) pure returns(bytes32)

func (*RollupTesterCallerSession) GenerateLastMessageHash 

func (_RollupTester *RollupTesterCallerSession) GenerateLastMessageHash(messages []byte, startOffset *big.Int, length *big.Int) ([32]byte, *big.Int, error)

GenerateLastMessageHash is a free data retrieval call binding the contract method 0x02be0bd0.

Solidity: function generateLastMessageHash(bytes messages, uint256 startOffset, uint256 length) pure returns(bytes32, uint256)

func (*RollupTesterCallerSession) GenerateValidLeaf 

func (_RollupTester *RollupTesterCallerSession) GenerateValidLeaf(deadlineTicks *big.Int, fields [8][32]byte, fields2 [5]*big.Int, prevChildType uint32, numSteps uint64, numArbGas uint64, messageCount uint64, logCount uint64) ([32]byte, error)

GenerateValidLeaf is a free data retrieval call binding the contract method 0x785b5774.

Solidity: function generateValidLeaf(uint256 deadlineTicks, bytes32[8] fields, uint256[5] fields2, uint32 prevChildType, uint64 numSteps, uint64 numArbGas, uint64 messageCount, uint64 logCount) pure returns(bytes32)

func (*RollupTesterCallerSession) ProcessValidNode 

func (_RollupTester *RollupTesterCallerSession) ProcessValidNode(logsAcc [][32]byte, vmProtoStateHashes [][32]byte, messageCounts []*big.Int, messages []byte, validNum *big.Int, beforeSendCount *big.Int, startOffset *big.Int) (struct {
	AfterSendCount   *big.Int
	AfterOffset      *big.Int
	NodeDataHash     [32]byte
	VmProtoStateHash [32]byte
}, error)

ProcessValidNode is a free data retrieval call binding the contract method 0xb1fca916.

Solidity: function processValidNode(bytes32[] logsAcc, bytes32[] vmProtoStateHashes, uint256[] messageCounts, bytes messages, uint256 validNum, uint256 beforeSendCount, uint256 startOffset) pure returns(uint256 afterSendCount, uint256 afterOffset, bytes32 nodeDataHash, bytes32 vmProtoStateHash)

type RollupTesterFilterer 

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

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

func NewRollupTesterFilterer 

func NewRollupTesterFilterer(address common.Address, filterer bind.ContractFilterer) (*RollupTesterFilterer, error)

NewRollupTesterFilterer creates a new log filterer instance of RollupTester, bound to a specific deployed contract.

type RollupTesterRaw 

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

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

func (*RollupTesterRaw) Call 

func (_RollupTester *RollupTesterRaw) 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 (*RollupTesterRaw) Transact 

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

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

func (*RollupTesterRaw) Transfer 

func (_RollupTester *RollupTesterRaw) 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 RollupTesterSession 

type RollupTesterSession struct {
	Contract     *RollupTester     // 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
}

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

func (*RollupTesterSession) CalculateLeafFromPath 

func (_RollupTester *RollupTesterSession) CalculateLeafFromPath(from [32]byte, proof [][32]byte) ([32]byte, error)

CalculateLeafFromPath is a free data retrieval call binding the contract method 0x9584b946.

Solidity: function calculateLeafFromPath(bytes32 from, bytes32[] proof) pure returns(bytes32)

func (*RollupTesterSession) ChildNodeHash 

func (_RollupTester *RollupTesterSession) ChildNodeHash(prevNodeHash [32]byte, deadlineTicks *big.Int, nodeDataHash [32]byte, childType *big.Int, vmProtoStateHash [32]byte) ([32]byte, error)

ChildNodeHash is a free data retrieval call binding the contract method 0xdf8f77ed.

Solidity: function childNodeHash(bytes32 prevNodeHash, uint256 deadlineTicks, bytes32 nodeDataHash, uint256 childType, bytes32 vmProtoStateHash) pure returns(bytes32)

func (*RollupTesterSession) ComputePrevLeaf 

func (_RollupTester *RollupTesterSession) ComputePrevLeaf(fields [8][32]byte, fields2 [5]*big.Int, prevChildType uint32, numSteps uint64, numArbGas uint64, messageCount uint64, logCount uint64) (struct {
	PrevLeaf          [32]byte
	VmProtoHashBefore [32]byte
}, error)

ComputePrevLeaf is a free data retrieval call binding the contract method 0x28ef9d40.

Solidity: function computePrevLeaf(bytes32[8] fields, uint256[5] fields2, uint32 prevChildType, uint64 numSteps, uint64 numArbGas, uint64 messageCount, uint64 logCount) pure returns(bytes32 prevLeaf, bytes32 vmProtoHashBefore)

func (*RollupTesterSession) ComputeProtoHashBefore 

func (_RollupTester *RollupTesterSession) ComputeProtoHashBefore(machineHash [32]byte, inboxTop [32]byte, inboxCount *big.Int, messageCount *big.Int, logCount *big.Int) ([32]byte, error)

ComputeProtoHashBefore is a free data retrieval call binding the contract method 0x47994dc6.

Solidity: function computeProtoHashBefore(bytes32 machineHash, bytes32 inboxTop, uint256 inboxCount, uint256 messageCount, uint256 logCount) pure returns(bytes32)

func (*RollupTesterSession) Confirm 

func (_RollupTester *RollupTesterSession) Confirm(confNode [32]byte, initalProtoStateHash [32]byte, beforeSendCount *big.Int, branches []*big.Int, deadlineTicks []*big.Int, challengeNodeData [][32]byte, logsAcc [][32]byte, vmProtoStateHashes [][32]byte, messageCounts []*big.Int, messages []byte) (struct {
	ValidNodeHashes  [][32]byte
	VmProtoStateHash [32]byte
	LastNodeHash     [32]byte
}, error)

Confirm is a free data retrieval call binding the contract method 0xdcea8ab2.

Solidity: function confirm(bytes32 confNode, bytes32 initalProtoStateHash, uint256 beforeSendCount, uint256[] branches, uint256[] deadlineTicks, bytes32[] challengeNodeData, bytes32[] logsAcc, bytes32[] vmProtoStateHashes, uint256[] messageCounts, bytes messages) pure returns(bytes32[] validNodeHashes, bytes32 vmProtoStateHash, bytes32 lastNodeHash)

func (*RollupTesterSession) GenerateInvalidExecutionLeaf 

func (_RollupTester *RollupTesterSession) GenerateInvalidExecutionLeaf(gracePeriodTicks *big.Int, checkTimeTicks *big.Int, deadlineTicks *big.Int, fields [8][32]byte, fields2 [5]*big.Int, prevChildType uint32, numSteps uint64, numArbGas uint64, messageCount uint64, logCount uint64) ([32]byte, error)

GenerateInvalidExecutionLeaf is a free data retrieval call binding the contract method 0x5f2de795.

Solidity: function generateInvalidExecutionLeaf(uint256 gracePeriodTicks, uint256 checkTimeTicks, uint256 deadlineTicks, bytes32[8] fields, uint256[5] fields2, uint32 prevChildType, uint64 numSteps, uint64 numArbGas, uint64 messageCount, uint64 logCount) pure returns(bytes32)

func (*RollupTesterSession) GenerateInvalidInboxTopLeaf 

func (_RollupTester *RollupTesterSession) GenerateInvalidInboxTopLeaf(invalidInboxData [4]*big.Int, fields [8][32]byte, fields2 [5]*big.Int, prevChildType uint32, numSteps uint64, numArbGas uint64, messageCount uint64, logCount uint64) ([32]byte, error)

GenerateInvalidInboxTopLeaf is a free data retrieval call binding the contract method 0x65aee548.

Solidity: function generateInvalidInboxTopLeaf(uint256[4] invalidInboxData, bytes32[8] fields, uint256[5] fields2, uint32 prevChildType, uint64 numSteps, uint64 numArbGas, uint64 messageCount, uint64 logCount) pure returns(bytes32)

func (*RollupTesterSession) GenerateLastMessageHash 

func (_RollupTester *RollupTesterSession) GenerateLastMessageHash(messages []byte, startOffset *big.Int, length *big.Int) ([32]byte, *big.Int, error)

GenerateLastMessageHash is a free data retrieval call binding the contract method 0x02be0bd0.

Solidity: function generateLastMessageHash(bytes messages, uint256 startOffset, uint256 length) pure returns(bytes32, uint256)

func (*RollupTesterSession) GenerateValidLeaf 

func (_RollupTester *RollupTesterSession) GenerateValidLeaf(deadlineTicks *big.Int, fields [8][32]byte, fields2 [5]*big.Int, prevChildType uint32, numSteps uint64, numArbGas uint64, messageCount uint64, logCount uint64) ([32]byte, error)

GenerateValidLeaf is a free data retrieval call binding the contract method 0x785b5774.

Solidity: function generateValidLeaf(uint256 deadlineTicks, bytes32[8] fields, uint256[5] fields2, uint32 prevChildType, uint64 numSteps, uint64 numArbGas, uint64 messageCount, uint64 logCount) pure returns(bytes32)

func (*RollupTesterSession) ProcessValidNode 

func (_RollupTester *RollupTesterSession) ProcessValidNode(logsAcc [][32]byte, vmProtoStateHashes [][32]byte, messageCounts []*big.Int, messages []byte, validNum *big.Int, beforeSendCount *big.Int, startOffset *big.Int) (struct {
	AfterSendCount   *big.Int
	AfterOffset      *big.Int
	NodeDataHash     [32]byte
	VmProtoStateHash [32]byte
}, error)

ProcessValidNode is a free data retrieval call binding the contract method 0xb1fca916.

Solidity: function processValidNode(bytes32[] logsAcc, bytes32[] vmProtoStateHashes, uint256[] messageCounts, bytes messages, uint256 validNum, uint256 beforeSendCount, uint256 startOffset) pure returns(uint256 afterSendCount, uint256 afterOffset, bytes32 nodeDataHash, bytes32 vmProtoStateHash)

type RollupTesterTransactor 

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

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

func NewRollupTesterTransactor 

func NewRollupTesterTransactor(address common.Address, transactor bind.ContractTransactor) (*RollupTesterTransactor, error)

NewRollupTesterTransactor creates a new write-only instance of RollupTester, bound to a specific deployed contract.

type RollupTesterTransactorRaw 

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

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

func (*RollupTesterTransactorRaw) Transact 

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

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

func (*RollupTesterTransactorRaw) Transfer 

func (_RollupTester *RollupTesterTransactorRaw) 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 RollupTesterTransactorSession 

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

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

type RollupUtils 

type RollupUtils struct {
	RollupUtilsCaller     // Read-only binding to the contract
	RollupUtilsTransactor // Write-only binding to the contract
	RollupUtilsFilterer   // Log filterer for contract events
}

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

func DeployRollupUtils 

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

DeployRollupUtils deploys a new Ethereum contract, binding an instance of RollupUtils to it.

func NewRollupUtils 

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

NewRollupUtils creates a new instance of RollupUtils, bound to a specific deployed contract.

type RollupUtilsCaller 

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

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

func NewRollupUtilsCaller 

func NewRollupUtilsCaller(address common.Address, caller bind.ContractCaller) (*RollupUtilsCaller, error)

NewRollupUtilsCaller creates a new read-only instance of RollupUtils, bound to a specific deployed contract.

type RollupUtilsCallerRaw 

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

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

func (*RollupUtilsCallerRaw) Call 

func (_RollupUtils *RollupUtilsCallerRaw) 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 RollupUtilsCallerSession 

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

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

type RollupUtilsFilterer 

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

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

func NewRollupUtilsFilterer 

func NewRollupUtilsFilterer(address common.Address, filterer bind.ContractFilterer) (*RollupUtilsFilterer, error)

NewRollupUtilsFilterer creates a new log filterer instance of RollupUtils, bound to a specific deployed contract.

type RollupUtilsRaw 

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

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

func (*RollupUtilsRaw) Call 

func (_RollupUtils *RollupUtilsRaw) 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 (*RollupUtilsRaw) Transact 

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

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

func (*RollupUtilsRaw) Transfer 

func (_RollupUtils *RollupUtilsRaw) 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 RollupUtilsSession 

type RollupUtilsSession struct {
	Contract     *RollupUtils      // 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
}

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

type RollupUtilsTransactor 

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

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

func NewRollupUtilsTransactor 

func NewRollupUtilsTransactor(address common.Address, transactor bind.ContractTransactor) (*RollupUtilsTransactor, error)

NewRollupUtilsTransactor creates a new write-only instance of RollupUtils, bound to a specific deployed contract.

type RollupUtilsTransactorRaw 

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

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

func (*RollupUtilsTransactorRaw) Transact 

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

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

func (*RollupUtilsTransactorRaw) Transfer 

func (_RollupUtils *RollupUtilsTransactorRaw) 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 RollupUtilsTransactorSession 

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

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

type SafeMath 

type SafeMath struct {
	SafeMathCaller     // Read-only binding to the contract
	SafeMathTransactor // Write-only binding to the contract
	SafeMathFilterer   // Log filterer for contract events
}

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

func DeploySafeMath 

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

DeploySafeMath deploys a new Ethereum contract, binding an instance of SafeMath to it.

func NewSafeMath 

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

NewSafeMath creates a new instance of SafeMath, bound to a specific deployed contract.

type SafeMathCaller 

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

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

func NewSafeMathCaller 

func NewSafeMathCaller(address common.Address, caller bind.ContractCaller) (*SafeMathCaller, error)

NewSafeMathCaller creates a new read-only instance of SafeMath, bound to a specific deployed contract.

type SafeMathCallerRaw 

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

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

func (*SafeMathCallerRaw) Call 

func (_SafeMath *SafeMathCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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

type SafeMathCallerSession 

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

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

type SafeMathFilterer 

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

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

func NewSafeMathFilterer 

func NewSafeMathFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeMathFilterer, error)

NewSafeMathFilterer creates a new log filterer instance of SafeMath, bound to a specific deployed contract.

type SafeMathRaw 

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

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

func (*SafeMathRaw) Call 

func (_SafeMath *SafeMathRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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

func (*SafeMathRaw) Transact 

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

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

func (*SafeMathRaw) Transfer 

func (_SafeMath *SafeMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

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

type SafeMathSession 

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

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

type SafeMathTransactor 

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

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

func NewSafeMathTransactor 

func NewSafeMathTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeMathTransactor, error)

NewSafeMathTransactor creates a new write-only instance of SafeMath, bound to a specific deployed contract.

type SafeMathTransactorRaw 

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

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

func (*SafeMathTransactorRaw) Transact 

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

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

func (*SafeMathTransactorRaw) Transfer 

func (_SafeMath *SafeMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

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

type SafeMathTransactorSession 

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

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

type VM 

type VM struct {
	VMCaller     // Read-only binding to the contract
	VMTransactor // Write-only binding to the contract
	VMFilterer   // Log filterer for contract events
}

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

func DeployVM 

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

DeployVM deploys a new Ethereum contract, binding an instance of VM to it.

func NewVM 

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

NewVM creates a new instance of VM, bound to a specific deployed contract.

type VMCaller 

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

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

func NewVMCaller 

func NewVMCaller(address common.Address, caller bind.ContractCaller) (*VMCaller, error)

NewVMCaller creates a new read-only instance of VM, bound to a specific deployed contract.

type VMCallerRaw 

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

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

func (*VMCallerRaw) Call 

func (_VM *VMCallerRaw) 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 VMCallerSession 

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

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

type VMFilterer 

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

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

func NewVMFilterer 

func NewVMFilterer(address common.Address, filterer bind.ContractFilterer) (*VMFilterer, error)

NewVMFilterer creates a new log filterer instance of VM, bound to a specific deployed contract.

type VMRaw 

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

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

func (*VMRaw) Call 

func (_VM *VMRaw) 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 (*VMRaw) Transact 

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

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

func (*VMRaw) Transfer 

func (_VM *VMRaw) 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 VMSession 

type VMSession struct {
	Contract     *VM               // 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
}

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

type VMTransactor 

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

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

func NewVMTransactor 

func NewVMTransactor(address common.Address, transactor bind.ContractTransactor) (*VMTransactor, error)

NewVMTransactor creates a new write-only instance of VM, bound to a specific deployed contract.

type VMTransactorRaw 

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

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

func (*VMTransactorRaw) Transact 

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

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

func (*VMTransactorRaw) Transfer 

func (_VM *VMTransactorRaw) 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 VMTransactorSession 

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

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

type ValueTester 

type ValueTester struct {
	ValueTesterCaller     // Read-only binding to the contract
	ValueTesterTransactor // Write-only binding to the contract
	ValueTesterFilterer   // Log filterer for contract events
}

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

func DeployValueTester 

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

DeployValueTester deploys a new Ethereum contract, binding an instance of ValueTester to it.

func NewValueTester 

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

NewValueTester creates a new instance of ValueTester, bound to a specific deployed contract.

type ValueTesterCaller 

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

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

func NewValueTesterCaller 

func NewValueTesterCaller(address common.Address, caller bind.ContractCaller) (*ValueTesterCaller, error)

NewValueTesterCaller creates a new read-only instance of ValueTester, bound to a specific deployed contract.

func (*ValueTesterCaller) BytesToBytestackHash 

func (_ValueTester *ValueTesterCaller) BytesToBytestackHash(opts *bind.CallOpts, data []byte, startOffset *big.Int, dataLength *big.Int) ([32]byte, error)

BytesToBytestackHash is a free data retrieval call binding the contract method 0xb325b7d0.

Solidity: function bytesToBytestackHash(bytes data, uint256 startOffset, uint256 dataLength) pure returns(bytes32)

func (*ValueTesterCaller) BytestackToBytes 

func (_ValueTester *ValueTesterCaller) BytestackToBytes(opts *bind.CallOpts, data []byte, offset *big.Int) (bool, *big.Int, []byte, error)

BytestackToBytes is a free data retrieval call binding the contract method 0xe4d476f4.

Solidity: function bytestackToBytes(bytes data, uint256 offset) pure returns(bool, uint256, bytes)

func (*ValueTesterCaller) DeserializeHash 

func (_ValueTester *ValueTesterCaller) DeserializeHash(opts *bind.CallOpts, data []byte, startOffset *big.Int) (*big.Int, [32]byte, error)

DeserializeHash is a free data retrieval call binding the contract method 0x98206792.

Solidity: function deserializeHash(bytes data, uint256 startOffset) pure returns(uint256, bytes32)

func (*ValueTesterCaller) HashTestTuple 

func (_ValueTester *ValueTesterCaller) HashTestTuple(opts *bind.CallOpts) ([32]byte, error)

HashTestTuple is a free data retrieval call binding the contract method 0xfd5d0c8b.

Solidity: function hashTestTuple() pure returns(bytes32)

func (*ValueTesterCaller) HashTuplePreImage 

func (_ValueTester *ValueTesterCaller) HashTuplePreImage(opts *bind.CallOpts, innerHash [32]byte, valueSize *big.Int) ([32]byte, error)

HashTuplePreImage is a free data retrieval call binding the contract method 0xc6d25c8e.

Solidity: function hashTuplePreImage(bytes32 innerHash, uint256 valueSize) pure returns(bytes32)

type ValueTesterCallerRaw 

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

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

func (*ValueTesterCallerRaw) Call 

func (_ValueTester *ValueTesterCallerRaw) 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 ValueTesterCallerSession 

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

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

func (*ValueTesterCallerSession) BytesToBytestackHash 

func (_ValueTester *ValueTesterCallerSession) BytesToBytestackHash(data []byte, startOffset *big.Int, dataLength *big.Int) ([32]byte, error)

BytesToBytestackHash is a free data retrieval call binding the contract method 0xb325b7d0.

Solidity: function bytesToBytestackHash(bytes data, uint256 startOffset, uint256 dataLength) pure returns(bytes32)

func (*ValueTesterCallerSession) BytestackToBytes 

func (_ValueTester *ValueTesterCallerSession) BytestackToBytes(data []byte, offset *big.Int) (bool, *big.Int, []byte, error)

BytestackToBytes is a free data retrieval call binding the contract method 0xe4d476f4.

Solidity: function bytestackToBytes(bytes data, uint256 offset) pure returns(bool, uint256, bytes)

func (*ValueTesterCallerSession) DeserializeHash 

func (_ValueTester *ValueTesterCallerSession) DeserializeHash(data []byte, startOffset *big.Int) (*big.Int, [32]byte, error)

DeserializeHash is a free data retrieval call binding the contract method 0x98206792.

Solidity: function deserializeHash(bytes data, uint256 startOffset) pure returns(uint256, bytes32)

func (*ValueTesterCallerSession) HashTestTuple 

func (_ValueTester *ValueTesterCallerSession) HashTestTuple() ([32]byte, error)

HashTestTuple is a free data retrieval call binding the contract method 0xfd5d0c8b.

Solidity: function hashTestTuple() pure returns(bytes32)

func (*ValueTesterCallerSession) HashTuplePreImage 

func (_ValueTester *ValueTesterCallerSession) HashTuplePreImage(innerHash [32]byte, valueSize *big.Int) ([32]byte, error)

HashTuplePreImage is a free data retrieval call binding the contract method 0xc6d25c8e.

Solidity: function hashTuplePreImage(bytes32 innerHash, uint256 valueSize) pure returns(bytes32)

type ValueTesterFilterer 

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

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

func NewValueTesterFilterer 

func NewValueTesterFilterer(address common.Address, filterer bind.ContractFilterer) (*ValueTesterFilterer, error)

NewValueTesterFilterer creates a new log filterer instance of ValueTester, bound to a specific deployed contract.

type ValueTesterRaw 

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

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

func (*ValueTesterRaw) Call 

func (_ValueTester *ValueTesterRaw) 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 (*ValueTesterRaw) Transact 

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

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

func (*ValueTesterRaw) Transfer 

func (_ValueTester *ValueTesterRaw) 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 ValueTesterSession 

type ValueTesterSession struct {
	Contract     *ValueTester      // 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
}

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

func (*ValueTesterSession) BytesToBytestackHash 

func (_ValueTester *ValueTesterSession) BytesToBytestackHash(data []byte, startOffset *big.Int, dataLength *big.Int) ([32]byte, error)

BytesToBytestackHash is a free data retrieval call binding the contract method 0xb325b7d0.

Solidity: function bytesToBytestackHash(bytes data, uint256 startOffset, uint256 dataLength) pure returns(bytes32)

func (*ValueTesterSession) BytestackToBytes 

func (_ValueTester *ValueTesterSession) BytestackToBytes(data []byte, offset *big.Int) (bool, *big.Int, []byte, error)

BytestackToBytes is a free data retrieval call binding the contract method 0xe4d476f4.

Solidity: function bytestackToBytes(bytes data, uint256 offset) pure returns(bool, uint256, bytes)

func (*ValueTesterSession) DeserializeHash 

func (_ValueTester *ValueTesterSession) DeserializeHash(data []byte, startOffset *big.Int) (*big.Int, [32]byte, error)

DeserializeHash is a free data retrieval call binding the contract method 0x98206792.

Solidity: function deserializeHash(bytes data, uint256 startOffset) pure returns(uint256, bytes32)

func (*ValueTesterSession) HashTestTuple 

func (_ValueTester *ValueTesterSession) HashTestTuple() ([32]byte, error)

HashTestTuple is a free data retrieval call binding the contract method 0xfd5d0c8b.

Solidity: function hashTestTuple() pure returns(bytes32)

func (*ValueTesterSession) HashTuplePreImage 

func (_ValueTester *ValueTesterSession) HashTuplePreImage(innerHash [32]byte, valueSize *big.Int) ([32]byte, error)

HashTuplePreImage is a free data retrieval call binding the contract method 0xc6d25c8e.

Solidity: function hashTuplePreImage(bytes32 innerHash, uint256 valueSize) pure returns(bytes32)

type ValueTesterTransactor 

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

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

func NewValueTesterTransactor 

func NewValueTesterTransactor(address common.Address, transactor bind.ContractTransactor) (*ValueTesterTransactor, error)

NewValueTesterTransactor creates a new write-only instance of ValueTester, bound to a specific deployed contract.

type ValueTesterTransactorRaw 

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

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

func (*ValueTesterTransactorRaw) Transact 

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

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

func (*ValueTesterTransactorRaw) Transfer 

func (_ValueTester *ValueTesterTransactorRaw) 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 ValueTesterTransactorSession 

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

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.