ethbridgetestcontracts

package

Go to main page

Versions in this module

v0

v0.7.3

Nov 24, 2020

v0.7.2

Oct 12, 2020

Changes in this version

+ const PrecompilesTesterABI

+ var PrecompilesTesterFuncSigs = map[string]string

+ type PrecompilesTester struct

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

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

+ type PrecompilesTesterCaller struct

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

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

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

+ type PrecompilesTesterCallerRaw struct

+ Contract *PrecompilesTesterCaller

+ func (_PrecompilesTester *PrecompilesTesterCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type PrecompilesTesterCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *PrecompilesTesterCaller

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

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

+ type PrecompilesTesterFilterer struct

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

+ type PrecompilesTesterRaw struct

+ Contract *PrecompilesTester

+ func (_PrecompilesTester *PrecompilesTesterRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_PrecompilesTester *PrecompilesTesterRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type PrecompilesTesterSession struct

+ CallOpts bind.CallOpts

+ Contract *PrecompilesTester

+ TransactOpts bind.TransactOpts

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

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

+ type PrecompilesTesterTransactor struct

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

+ type PrecompilesTesterTransactorRaw struct

+ Contract *PrecompilesTesterTransactor

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

+ func (_PrecompilesTester *PrecompilesTesterTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type PrecompilesTesterTransactorSession struct

+ Contract *PrecompilesTesterTransactor

+ TransactOpts bind.TransactOpts

v0.7.1

Sep 4, 2020

v0.7.0

Aug 31, 2020

Changes in this version

+ const ChallengeTesterABI

+ const KeccakTesterABI

+ const MachineTesterABI

+ const MessageTesterABI

+ const NodeGraphUtilsABI

+ const ProtocolTesterABI

+ const RollupTesterABI

+ const RollupUtilsABI

+ const SafeMathABI

+ const VMABI

+ const ValueTesterABI

+ var ChallengeTesterBin = "0x608060405234801561001057600080fd5b506040516101fe3803806101fe8339818101604052602081101561003357600080fd5b5051600080546001600160a01b039092166001600160a01b0319909216919091179055610199806100656000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c8063396f51cf1461003b5780638f43ee321461006b575b600080fd5b6100696004803603604081101561005157600080fd5b506001600160a01b03813581169160200135166100b6565b005b610069600480360360a081101561008157600080fd5b506001600160a01b0381358116916020810135909116906001600160801b0360408201351690606081013590608001356100ba565b5050565b600080546040805163432ed0e160e11b81526001600160a01b03898116600483015288811660248301526001600160801b038816604483015260648201879052608482018690529151919092169263865da1c29260a480820193602093909283900390910190829087803b15801561013157600080fd5b505af1158015610145573d6000803e3d6000fd5b505050506040513d602081101561015b57600080fd5b5050505050505056fea265627a7a72315820a01815879b1caabcbb9040d6dcddee2189b506734b4a1d9b66a3bc7d20a025a164736f6c63430005110032"

+ var ChallengeTesterFuncSigs = map[string]string

+ var KeccakTesterFuncSigs = map[string]string

+ var MachineTesterFuncSigs = map[string]string

+ var MessageTesterFuncSigs = map[string]string

+ var NodeGraphUtilsBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a7231582086807d620e5b044209761928521ba376ee192b256394f44013a98801b9991bdd64736f6c63430005110032"

+ var ProtocolTesterBin = "0x608060405234801561001057600080fd5b506101b1806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c80639353b9b41461003b578063c21ef0fa14610070575b600080fd5b61005e6004803603604081101561005157600080fd5b50803590602001356100bd565b60408051918252519081900360200190f35b61005e600480360360e081101561008657600080fd5b50803590602081013515159067ffffffffffffffff6040820135169060608101359060808101359060a08101359060c001356100d0565b60006100c983836100ed565b9392505050565b60006100e188888888888888610119565b98975050505050505050565b604080516020808201949094528082019290925280518083038201815260609092019052805191012090565b6040805160208082019990995296151560f81b8782015260c09590951b6001600160c01b031916604187015260498601939093526069850191909152608984015260a9808401919091528151808403909101815260c9909201905280519101209056fea265627a7a72315820725e874cbcfa1fa7428f9d950b9e680c9c13fb514e1092c90c18afb44535826b64736f6c63430005110032"

+ var ProtocolTesterFuncSigs = map[string]string

+ var RollupTesterFuncSigs = map[string]string

+ var RollupUtilsBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a7231582093fcb3c9dda65c3c67a671d93b23253577198397382f277b4e69a39194ea4b2c64736f6c63430005110032"

+ var SafeMathBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a723158208779b99760723161ba40a9da7d8b060f33ca5d9edad455d784d6ef6d6e9e69dc64736f6c63430005110032"

+ var VMBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a723158207a2f4d76c7ac5af065616b74405a4a9f6a6aafe38708dfab7489b4acf3131b9864736f6c63430005110032"

+ var ValueTesterFuncSigs = map[string]string

+ type ChallengeTester struct

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

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

+ type ChallengeTesterCaller struct

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

+ type ChallengeTesterCallerRaw struct

+ Contract *ChallengeTesterCaller

+ func (_ChallengeTester *ChallengeTesterCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ChallengeTesterCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ChallengeTesterCaller

+ type ChallengeTesterFilterer struct

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

+ type ChallengeTesterRaw struct

+ Contract *ChallengeTester

+ func (_ChallengeTester *ChallengeTesterRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_ChallengeTester *ChallengeTesterRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ChallengeTesterSession struct

+ CallOpts bind.CallOpts

+ Contract *ChallengeTester

+ TransactOpts bind.TransactOpts

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

+ func (_ChallengeTester *ChallengeTesterSession) StartChallenge(asserterAddress common.Address, challengerAddress common.Address, ...) (*types.Transaction, error)

+ type ChallengeTesterTransactor struct

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

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

+ func (_ChallengeTester *ChallengeTesterTransactor) StartChallenge(opts *bind.TransactOpts, asserterAddress common.Address, ...) (*types.Transaction, error)

+ type ChallengeTesterTransactorRaw struct

+ Contract *ChallengeTesterTransactor

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

+ func (_ChallengeTester *ChallengeTesterTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ChallengeTesterTransactorSession struct

+ Contract *ChallengeTesterTransactor

+ TransactOpts bind.TransactOpts

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

+ func (_ChallengeTester *ChallengeTesterTransactorSession) StartChallenge(asserterAddress common.Address, challengerAddress common.Address, ...) (*types.Transaction, error)

+ type KeccakTester struct

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

+ func NewKeccakTester(address common.Address, backend bind.ContractBackend) (*KeccakTester, error)

+ type KeccakTesterCaller struct

+ func NewKeccakTesterCaller(address common.Address, caller bind.ContractCaller) (*KeccakTesterCaller, error)

+ func (_KeccakTester *KeccakTesterCaller) KeccakF(opts *bind.CallOpts, input [25]*big.Int) ([25]*big.Int, error)

+ type KeccakTesterCallerRaw struct

+ Contract *KeccakTesterCaller

+ func (_KeccakTester *KeccakTesterCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type KeccakTesterCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *KeccakTesterCaller

+ func (_KeccakTester *KeccakTesterCallerSession) KeccakF(input [25]*big.Int) ([25]*big.Int, error)

+ type KeccakTesterFilterer struct

+ func NewKeccakTesterFilterer(address common.Address, filterer bind.ContractFilterer) (*KeccakTesterFilterer, error)

+ type KeccakTesterRaw struct

+ Contract *KeccakTester

+ func (_KeccakTester *KeccakTesterRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_KeccakTester *KeccakTesterRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_KeccakTester *KeccakTesterRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type KeccakTesterSession struct

+ CallOpts bind.CallOpts

+ Contract *KeccakTester

+ TransactOpts bind.TransactOpts

+ func (_KeccakTester *KeccakTesterSession) KeccakF(input [25]*big.Int) ([25]*big.Int, error)

+ type KeccakTesterTransactor struct

+ func NewKeccakTesterTransactor(address common.Address, transactor bind.ContractTransactor) (*KeccakTesterTransactor, error)

+ type KeccakTesterTransactorRaw struct

+ Contract *KeccakTesterTransactor

+ func (_KeccakTester *KeccakTesterTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_KeccakTester *KeccakTesterTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type KeccakTesterTransactorSession struct

+ Contract *KeccakTesterTransactor

+ TransactOpts bind.TransactOpts

+ type MachineTester struct

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

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

+ type MachineTesterCaller struct

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

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

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

+ type MachineTesterCallerRaw struct

+ Contract *MachineTesterCaller

+ func (_MachineTester *MachineTesterCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type MachineTesterCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *MachineTesterCaller

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

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

+ type MachineTesterFilterer struct

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

+ type MachineTesterRaw struct

+ Contract *MachineTester

+ func (_MachineTester *MachineTesterRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_MachineTester *MachineTesterRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MachineTesterSession struct

+ CallOpts bind.CallOpts

+ Contract *MachineTester

+ TransactOpts bind.TransactOpts

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

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

+ type MachineTesterTransactor struct

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

+ type MachineTesterTransactorRaw struct

+ Contract *MachineTesterTransactor

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

+ func (_MachineTester *MachineTesterTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MachineTesterTransactorSession struct

+ Contract *MachineTesterTransactor

+ TransactOpts bind.TransactOpts

+ type MessageTester struct

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

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

+ type MessageTesterCaller struct

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

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

+ func (_MessageTester *MessageTesterCaller) MessageHash(opts *bind.CallOpts, messageType uint8, sender common.Address, ...) ([32]byte, error)

+ func (_MessageTester *MessageTesterCaller) MessageValueHash(opts *bind.CallOpts, messageType uint8, blockNumber *big.Int, ...) ([32]byte, error)

+ func (_MessageTester *MessageTesterCaller) ParseERC20Message(opts *bind.CallOpts, data []byte) (struct{ ... }, error)

+ func (_MessageTester *MessageTesterCaller) ParseERC721Message(opts *bind.CallOpts, data []byte) (struct{ ... }, error)

+ func (_MessageTester *MessageTesterCaller) ParseEthMessage(opts *bind.CallOpts, data []byte) (struct{ ... }, error)

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

+ type MessageTesterCallerRaw struct

+ Contract *MessageTesterCaller

+ func (_MessageTester *MessageTesterCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type MessageTesterCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *MessageTesterCaller

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

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

+ func (_MessageTester *MessageTesterCallerSession) MessageValueHash(messageType uint8, blockNumber *big.Int, timestamp *big.Int, ...) ([32]byte, error)

+ func (_MessageTester *MessageTesterCallerSession) ParseERC20Message(data []byte) (struct{ ... }, error)

+ func (_MessageTester *MessageTesterCallerSession) ParseERC721Message(data []byte) (struct{ ... }, error)

+ func (_MessageTester *MessageTesterCallerSession) ParseEthMessage(data []byte) (struct{ ... }, error)

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

+ type MessageTesterFilterer struct

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

+ type MessageTesterRaw struct

+ Contract *MessageTester

+ func (_MessageTester *MessageTesterRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_MessageTester *MessageTesterRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MessageTesterSession struct

+ CallOpts bind.CallOpts

+ Contract *MessageTester

+ TransactOpts bind.TransactOpts

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

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

+ func (_MessageTester *MessageTesterSession) MessageValueHash(messageType uint8, blockNumber *big.Int, timestamp *big.Int, ...) ([32]byte, error)

+ func (_MessageTester *MessageTesterSession) ParseERC20Message(data []byte) (struct{ ... }, error)

+ func (_MessageTester *MessageTesterSession) ParseERC721Message(data []byte) (struct{ ... }, error)

+ func (_MessageTester *MessageTesterSession) ParseEthMessage(data []byte) (struct{ ... }, error)

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

+ type MessageTesterTransactor struct

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

+ type MessageTesterTransactorRaw struct

+ Contract *MessageTesterTransactor

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

+ func (_MessageTester *MessageTesterTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MessageTesterTransactorSession struct

+ Contract *MessageTesterTransactor

+ TransactOpts bind.TransactOpts

+ type MessagesERC20Message struct

+ Dest common.Address

+ Token common.Address

+ Value *big.Int

+ type MessagesERC721Message struct

+ Dest common.Address

+ Id *big.Int

+ Token common.Address

+ type MessagesEthMessage struct

+ Dest common.Address

+ Value *big.Int

+ type NodeGraphUtils struct

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

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

+ type NodeGraphUtilsCaller struct

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

+ type NodeGraphUtilsCallerRaw struct

+ Contract *NodeGraphUtilsCaller

+ func (_NodeGraphUtils *NodeGraphUtilsCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type NodeGraphUtilsCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *NodeGraphUtilsCaller

+ type NodeGraphUtilsFilterer struct

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

+ type NodeGraphUtilsRaw struct

+ Contract *NodeGraphUtils

+ func (_NodeGraphUtils *NodeGraphUtilsRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_NodeGraphUtils *NodeGraphUtilsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type NodeGraphUtilsSession struct

+ CallOpts bind.CallOpts

+ Contract *NodeGraphUtils

+ TransactOpts bind.TransactOpts

+ type NodeGraphUtilsTransactor struct

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

+ type NodeGraphUtilsTransactorRaw struct

+ Contract *NodeGraphUtilsTransactor

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

+ func (_NodeGraphUtils *NodeGraphUtilsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type NodeGraphUtilsTransactorSession struct

+ Contract *NodeGraphUtilsTransactor

+ TransactOpts bind.TransactOpts

+ type ProtocolTester struct

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

+ func NewProtocolTester(address common.Address, backend bind.ContractBackend) (*ProtocolTester, error)

+ type ProtocolTesterCaller struct

+ func NewProtocolTesterCaller(address common.Address, caller bind.ContractCaller) (*ProtocolTesterCaller, error)

+ func (_ProtocolTester *ProtocolTesterCaller) GenerateAssertionHash(opts *bind.CallOpts, _afterHash [32]byte, _didInboxInsn bool, _numGas uint64, ...) ([32]byte, error)

+ func (_ProtocolTester *ProtocolTesterCaller) GeneratePreconditionHash(opts *bind.CallOpts, _beforeHash [32]byte, _beforeInboxHash [32]byte) ([32]byte, error)

+ type ProtocolTesterCallerRaw struct

+ Contract *ProtocolTesterCaller

+ func (_ProtocolTester *ProtocolTesterCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ProtocolTesterCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ProtocolTesterCaller

+ func (_ProtocolTester *ProtocolTesterCallerSession) GenerateAssertionHash(_afterHash [32]byte, _didInboxInsn bool, _numGas uint64, ...) ([32]byte, error)

+ func (_ProtocolTester *ProtocolTesterCallerSession) GeneratePreconditionHash(_beforeHash [32]byte, _beforeInboxHash [32]byte) ([32]byte, error)

+ type ProtocolTesterFilterer struct

+ func NewProtocolTesterFilterer(address common.Address, filterer bind.ContractFilterer) (*ProtocolTesterFilterer, error)

+ type ProtocolTesterRaw struct

+ Contract *ProtocolTester

+ func (_ProtocolTester *ProtocolTesterRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_ProtocolTester *ProtocolTesterRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ProtocolTester *ProtocolTesterRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ProtocolTesterSession struct

+ CallOpts bind.CallOpts

+ Contract *ProtocolTester

+ TransactOpts bind.TransactOpts

+ func (_ProtocolTester *ProtocolTesterSession) GenerateAssertionHash(_afterHash [32]byte, _didInboxInsn bool, _numGas uint64, ...) ([32]byte, error)

+ func (_ProtocolTester *ProtocolTesterSession) GeneratePreconditionHash(_beforeHash [32]byte, _beforeInboxHash [32]byte) ([32]byte, error)

+ type ProtocolTesterTransactor struct

+ func NewProtocolTesterTransactor(address common.Address, transactor bind.ContractTransactor) (*ProtocolTesterTransactor, error)

+ type ProtocolTesterTransactorRaw struct

+ Contract *ProtocolTesterTransactor

+ func (_ProtocolTester *ProtocolTesterTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ProtocolTester *ProtocolTesterTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ProtocolTesterTransactorSession struct

+ Contract *ProtocolTesterTransactor

+ TransactOpts bind.TransactOpts

+ type RollupTester struct

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

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

+ type RollupTesterCaller struct

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

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

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

+ func (_RollupTester *RollupTesterCaller) ComputePrevLeaf(opts *bind.CallOpts, fields [8][32]byte, fields2 [5]*big.Int, ...) (struct{ ... }, error)

+ func (_RollupTester *RollupTesterCaller) ComputeProtoHashBefore(opts *bind.CallOpts, machineHash [32]byte, inboxTop [32]byte, ...) ([32]byte, error)

+ func (_RollupTester *RollupTesterCaller) Confirm(opts *bind.CallOpts, confNode [32]byte, initalProtoStateHash [32]byte, ...) (struct{ ... }, error)

+ func (_RollupTester *RollupTesterCaller) GenerateInvalidExecutionLeaf(opts *bind.CallOpts, gracePeriodTicks *big.Int, checkTimeTicks *big.Int, ...) ([32]byte, error)

+ func (_RollupTester *RollupTesterCaller) GenerateInvalidInboxTopLeaf(opts *bind.CallOpts, invalidInboxData [4]*big.Int, fields [8][32]byte, ...) ([32]byte, error)

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

+ func (_RollupTester *RollupTesterCaller) GenerateValidLeaf(opts *bind.CallOpts, deadlineTicks *big.Int, fields [8][32]byte, ...) ([32]byte, error)

+ func (_RollupTester *RollupTesterCaller) ProcessValidNode(opts *bind.CallOpts, logsAcc [][32]byte, vmProtoStateHashes [][32]byte, ...) (struct{ ... }, error)

+ type RollupTesterCallerRaw struct

+ Contract *RollupTesterCaller

+ func (_RollupTester *RollupTesterCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type RollupTesterCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *RollupTesterCaller

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

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

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

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

+ func (_RollupTester *RollupTesterCallerSession) Confirm(confNode [32]byte, initalProtoStateHash [32]byte, beforeSendCount *big.Int, ...) (struct{ ... }, error)

+ func (_RollupTester *RollupTesterCallerSession) GenerateInvalidExecutionLeaf(gracePeriodTicks *big.Int, checkTimeTicks *big.Int, deadlineTicks *big.Int, ...) ([32]byte, error)

+ func (_RollupTester *RollupTesterCallerSession) GenerateInvalidInboxTopLeaf(invalidInboxData [4]*big.Int, fields [8][32]byte, fields2 [5]*big.Int, ...) ([32]byte, error)

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

+ func (_RollupTester *RollupTesterCallerSession) GenerateValidLeaf(deadlineTicks *big.Int, fields [8][32]byte, fields2 [5]*big.Int, ...) ([32]byte, error)

+ func (_RollupTester *RollupTesterCallerSession) ProcessValidNode(logsAcc [][32]byte, vmProtoStateHashes [][32]byte, messageCounts []*big.Int, ...) (struct{ ... }, error)

+ type RollupTesterFilterer struct

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

+ type RollupTesterRaw struct

+ Contract *RollupTester

+ func (_RollupTester *RollupTesterRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_RollupTester *RollupTesterRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type RollupTesterSession struct

+ CallOpts bind.CallOpts

+ Contract *RollupTester

+ TransactOpts bind.TransactOpts

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

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

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

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

+ func (_RollupTester *RollupTesterSession) Confirm(confNode [32]byte, initalProtoStateHash [32]byte, beforeSendCount *big.Int, ...) (struct{ ... }, error)

+ func (_RollupTester *RollupTesterSession) GenerateInvalidExecutionLeaf(gracePeriodTicks *big.Int, checkTimeTicks *big.Int, deadlineTicks *big.Int, ...) ([32]byte, error)

+ func (_RollupTester *RollupTesterSession) GenerateInvalidInboxTopLeaf(invalidInboxData [4]*big.Int, fields [8][32]byte, fields2 [5]*big.Int, ...) ([32]byte, error)

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

+ func (_RollupTester *RollupTesterSession) GenerateValidLeaf(deadlineTicks *big.Int, fields [8][32]byte, fields2 [5]*big.Int, ...) ([32]byte, error)

+ func (_RollupTester *RollupTesterSession) ProcessValidNode(logsAcc [][32]byte, vmProtoStateHashes [][32]byte, messageCounts []*big.Int, ...) (struct{ ... }, error)

+ type RollupTesterTransactor struct

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

+ type RollupTesterTransactorRaw struct

+ Contract *RollupTesterTransactor

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

+ func (_RollupTester *RollupTesterTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type RollupTesterTransactorSession struct

+ Contract *RollupTesterTransactor

+ TransactOpts bind.TransactOpts

+ type RollupUtils struct

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

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

+ type RollupUtilsCaller struct

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

+ type RollupUtilsCallerRaw struct

+ Contract *RollupUtilsCaller

+ func (_RollupUtils *RollupUtilsCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type RollupUtilsCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *RollupUtilsCaller

+ type RollupUtilsFilterer struct

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

+ type RollupUtilsRaw struct

+ Contract *RollupUtils

+ func (_RollupUtils *RollupUtilsRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_RollupUtils *RollupUtilsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type RollupUtilsSession struct

+ CallOpts bind.CallOpts

+ Contract *RollupUtils

+ TransactOpts bind.TransactOpts

+ type RollupUtilsTransactor struct

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

+ type RollupUtilsTransactorRaw struct

+ Contract *RollupUtilsTransactor

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

+ func (_RollupUtils *RollupUtilsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type RollupUtilsTransactorSession struct

+ Contract *RollupUtilsTransactor

+ TransactOpts bind.TransactOpts

+ type SafeMath struct

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

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

+ type SafeMathCaller struct

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

+ type SafeMathCallerRaw struct

+ Contract *SafeMathCaller

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

+ type SafeMathCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SafeMathCaller

+ type SafeMathFilterer struct

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

+ type SafeMathRaw struct

+ Contract *SafeMath

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

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

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

+ type SafeMathSession struct

+ CallOpts bind.CallOpts

+ Contract *SafeMath

+ TransactOpts bind.TransactOpts

+ type SafeMathTransactor struct

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

+ type SafeMathTransactorRaw struct

+ Contract *SafeMathTransactor

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

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

+ type SafeMathTransactorSession struct

+ Contract *SafeMathTransactor

+ TransactOpts bind.TransactOpts

+ type VM struct

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

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

+ type VMCaller struct

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

+ type VMCallerRaw struct

+ Contract *VMCaller

+ func (_VM *VMCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type VMCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *VMCaller

+ type VMFilterer struct

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

+ type VMRaw struct

+ Contract *VM

+ func (_VM *VMRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_VM *VMRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type VMSession struct

+ CallOpts bind.CallOpts

+ Contract *VM

+ TransactOpts bind.TransactOpts

+ type VMTransactor struct

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

+ type VMTransactorRaw struct

+ Contract *VMTransactor

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

+ func (_VM *VMTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type VMTransactorSession struct

+ Contract *VMTransactor

+ TransactOpts bind.TransactOpts

+ type ValueTester struct

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

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

+ type ValueTesterCaller struct

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

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

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

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

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

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

+ type ValueTesterCallerRaw struct

+ Contract *ValueTesterCaller

+ func (_ValueTester *ValueTesterCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ValueTesterCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ValueTesterCaller

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

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

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

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

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

+ type ValueTesterFilterer struct

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

+ type ValueTesterRaw struct

+ Contract *ValueTester

+ func (_ValueTester *ValueTesterRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_ValueTester *ValueTesterRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ValueTesterSession struct

+ CallOpts bind.CallOpts

+ Contract *ValueTester

+ TransactOpts bind.TransactOpts

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

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

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

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

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

+ type ValueTesterTransactor struct

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

+ type ValueTesterTransactorRaw struct

+ Contract *ValueTesterTransactor

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

+ func (_ValueTester *ValueTesterTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ValueTesterTransactorSession struct

+ Contract *ValueTesterTransactor

+ TransactOpts bind.TransactOpts

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL