ethbridgecontracts

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 PrecompilesABI

+ var PrecompilesBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a7231582089a25ee4d0917faa75d52d337f832f58e8fef2b903c6259ee110daea7c41f21264736f6c63430005110032"

+ type Precompiles struct

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

+ func NewPrecompiles(address common.Address, backend bind.ContractBackend) (*Precompiles, error)

+ type PrecompilesCaller struct

+ func NewPrecompilesCaller(address common.Address, caller bind.ContractCaller) (*PrecompilesCaller, error)

+ type PrecompilesCallerRaw struct

+ Contract *PrecompilesCaller

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

+ type PrecompilesCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *PrecompilesCaller

+ type PrecompilesFilterer struct

+ func NewPrecompilesFilterer(address common.Address, filterer bind.ContractFilterer) (*PrecompilesFilterer, error)

+ type PrecompilesRaw struct

+ Contract *Precompiles

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

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

+ func (_Precompiles *PrecompilesRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type PrecompilesSession struct

+ CallOpts bind.CallOpts

+ Contract *Precompiles

+ TransactOpts bind.TransactOpts

+ type PrecompilesTransactor struct

+ func NewPrecompilesTransactor(address common.Address, transactor bind.ContractTransactor) (*PrecompilesTransactor, error)

+ type PrecompilesTransactorRaw struct

+ Contract *PrecompilesTransactor

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

+ func (_Precompiles *PrecompilesTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type PrecompilesTransactorSession struct

+ Contract *PrecompilesTransactor

+ TransactOpts bind.TransactOpts

v0.7.1

Sep 4, 2020

v0.7.0

Aug 31, 2020

Changes in this version

+ const ArbFactoryABI

+ const ArbRollupABI

+ const BisectionChallengeABI

+ const ChallengeABI

+ const ChallengeFactoryABI

+ const ExecutionChallengeABI

+ const GlobalEthWalletABI

+ const GlobalFTWalletABI

+ const GlobalInboxABI

+ const GlobalNFTWalletABI

+ const IERC165ABI

+ const IERC20ABI

+ const IERC721ABI

+ const IPairedErc20ABI

+ const InboxTopChallengeABI

+ const KeccakABI

+ const NodeGraphABI

+ const NodeGraphUtilsABI

+ const OneStepProofABI

+ const PaymentRecordsABI

+ const RollupUtilsABI

+ const SafeMathABI

+ const StakingABI

+ const VMABI

+ var ArbFactoryBin = "0x608060405234801561001057600080fd5b5060405161058c38038061058c8339818101604052606081101561003357600080fd5b5080516020820151604090920151600080546001600160a01b039384166001600160a01b03199182161790915560018054948416948216949094179093556002805492909116919092161790556104fd8061008f6000396000f3fe608060405234801561001057600080fd5b506004361061004c5760003560e01c80632b0563f814610051578063582923c71461011357806362e3c0b1146101375780638689d9961461013f575b600080fd5b610111600480360361010081101561006857600080fd5b8135916001600160801b036020820135811692604083013582169267ffffffffffffffff60608201351692608082013516916001600160a01b0360a083013581169260c081013590911691810190610100810160e08201356401000000008111156100d257600080fd5b8201836020820111156100e457600080fd5b8035906020019184600183028401116401000000008311171561010657600080fd5b509092509050610147565b005b61011b610336565b604080516001600160a01b039092168252519081900360200190f35b61011b610345565b61011b610354565b6000805461015d906001600160a01b0316610363565b9050806001600160a01b0316631dceffe78b8b8b8b8b8b8b600260009054906101000a90046001600160a01b0316600160009054906101000a90046001600160a01b03168d8d6040518c63ffffffff1660e01b8152600401808c81526020018b6001600160801b03166001600160801b031681526020018a6001600160801b03166001600160801b031681526020018967ffffffffffffffff1667ffffffffffffffff168152602001886001600160801b03166001600160801b03168152602001876001600160a01b03166001600160a01b03168152602001866001600160a01b03166001600160a01b03168152602001856001600160a01b03166001600160a01b03168152602001846001600160a01b03166001600160a01b03168152602001806020018281038252848482818152602001925080828437600081840152601f19601f8201169050808301925050509c50505050505050505050505050600060405180830381600087803b1580156102d557600080fd5b505af11580156102e9573d6000803e3d6000fd5b5050604080516001600160a01b038516815290517f84c162f1396badc29f9c932c79d7495db699b615e2c0da163ae26bd5dbe71d7c9350908190036020019150a150505050505050505050565b6001546001600160a01b031681565b6002546001600160a01b031681565b6000546001600160a01b031681565b6000816001600160a01b0316636f791d296040518163ffffffff1660e01b815260040160206040518083038186803b15801561039e57600080fd5b505afa1580156103b2573d6000803e3d6000fd5b505050506040513d60208110156103c857600080fd5b505160408051808201909152600c81526b21a627a722afa6a0a9aa22a960a11b6020820152906104765760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b8381101561043b578181015183820152602001610423565b50505050905090810190601f1680156104685780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b5060008260601b9050604051733d602d80600a3d3981f3363d3d373d3d3d363d7360601b81528160148201526e5af43d82803e903d91602b57fd5bf360881b60288201526037816000f094935050505056fea265627a7a723158209a2608c63c8dfee5c245c243a21eeb16953e02adc1268b990c422e59f2ff1d0664736f6c63430005110032"

+ var ArbFactoryFuncSigs = map[string]string

+ var ArbRollupFuncSigs = map[string]string

+ var BisectionChallengeBin = "0x60806040526000805460ff19166001179055610951806100206000396000f3fe608060405234801561001057600080fd5b506004361061004c5760003560e01c806302ad1e4e146100515780636f791d291461009557806379a9ad85146100b1578063ced5c1bf14610163575b600080fd5b610093600480360360a081101561006757600080fd5b506001600160a01b0381358116916020810135821691604082013516906060810135906080013561016b565b005b61009d610180565b604080519115158252519081900360200190f35b610093600480360360808110156100c757600080fd5b813591908101906040810160208201356401000000008111156100e957600080fd5b8201836020820111156100fb57600080fd5b8035906020019184600183028401116401000000008311171561011d57600080fd5b91908080601f0160208091040260200160405190810160405280939291908181526020018383808284376000920191909152509295505082359350505060200135610189565b610093610487565b61017785858585610567565b60065550505050565b60005460ff1690565b60055460ff16600281111561019a57fe5b60021460405180604001604052806009815260200168434f4e5f535441544560b81b815250906102485760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b8381101561020d5781810151838201526020016101f5565b50505050905090810190601f16801561023a5780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b5060035461025543610694565b11156040518060400160405280600c81526020016b434f4e5f444541444c494e4560a01b815250906102c85760405162461bcd60e51b815260206004820181815283516024840152835190928392604490910191908501908083836000831561020d5781810151838201526020016101f5565b5060025460408051808201909152600a81526921a7a72fa9a2a72222a960b11b6020820152906001600160a01b031633146103445760405162461bcd60e51b815260206004820181815283516024840152835190928392604490910191908501908083836000831561020d5781810151838201526020016101f5565b5060065482146040518060400160405280600881526020016721a7a72fa82922ab60c11b815250906103b75760405162461bcd60e51b815260206004820181815283516024840152835190928392604490910191908501908083836000831561020d5781810151838201526020016101f5565b506103c78383838760010161069b565b6040518060400160405280600981526020016821a7a72fa82927a7a360b91b815250906104355760405162461bcd60e51b815260206004820181815283516024840152835190928392604490910191908501908083836000831561020d5781810151838201526020016101f5565b50600681905561044361079c565b60035460408051868152602081019290925280517f1e1c1e4e68a25c69a078a396e73975691c071d69ef789015dc16a562957804e49281900390910190a150505050565b60035461049343610694565b116104e5576040805162461bcd60e51b815260206004820152601760248201527f446561646c696e65206861736e27742065787069726564000000000000000000604482015290519081900360640190fd5b600160055460ff1660028111156104f857fe5b1415610534576040517f2b92a4b014281aa2424baba9ea60bf4f26833d1c1fbd873e51cd1a6caeef48f090600090a161052f6107b1565b610565565b6040517f4e1f1f06cf69d199fcdb4d87a5a92d5248ca6b540e9fc2d3698927c5002a236a90600090a161056561082e565b565b600060055460ff16600281111561057a57fe5b146040518060400160405280600f81526020016e4348414c5f494e49545f535441544560881b815250906105ef5760405162461bcd60e51b815260206004820181815283516024840152835190928392604490910191908501908083836000831561020d5781810151838201526020016101f5565b5060008054610100600160a81b0319166101006001600160a01b038781169190910291909117909155600180546001600160a01b0319908116868416178255600280549091169285169290921790915560048290556005805460ff1916909117905561065961088a565b60035460408051918252517fe070f23072cbc6c0fc7253b8d0120649d5f9d6e19a8aeab79eb50aa6360bcc679181900360200190a150505050565b6103e80290565b600080838160205b8851811161078e578089015193506020818a5103602001816106c157fe5b0491505b6000821180156106d85750600286066001145b80156106e657508160020a86115b156106f9576002860460010195506106c5565b6002860661074457838360405160200180838152602001828152602001925050506040516020818303038152906040528051906020012092506002868161073c57fe5b049550610786565b828460405160200180838152602001828152602001925050506040516020818303038152906040528051906020012092506002868161077f57fe5b0460010195505b6020016106a3565b505090941495945050505050565b6005805460ff1916600117905561056561088a565b600080546002546001546040805163396f51cf60e01b81526001600160a01b0393841660048201529183166024830152516101009093049091169263396f51cf9260448084019382900301818387803b15801561080d57600080fd5b505af1158015610821573d6000803e3d6000fd5b505050506105653361089c565b600080546001546002546040805163396f51cf60e01b81526001600160a01b0393841660048201529183166024830152516101009093049091169263396f51cf9260448084019382900301818387803b15801561080d57600080fd5b60045461089643610694565b01600355565b6000546040805180820190915260098152684e4f545f434c4f4e4560b81b60208201529060ff161561090f5760405162461bcd60e51b815260206004820181815283516024840152835190928392604490910191908501908083836000831561020d5781810151838201526020016101f5565b50806001600160a01b0316fffea265627a7a723158202ba36eb65cf3da81860f1e04b6261d9e3ce80ba1295fc21cdc4fa05a4015179e64736f6c63430005110032"

+ var BisectionChallengeFuncSigs = map[string]string

+ var ChallengeBin = "0x60806040526000805460ff1916600117905561031c806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c80636f791d291461003b578063ced5c1bf14610057575b600080fd5b610043610061565b604080519115158252519081900360200190f35b61005f61006a565b005b60005460ff1690565b6003546100764361014a565b116100c8576040805162461bcd60e51b815260206004820152601760248201527f446561646c696e65206861736e27742065787069726564000000000000000000604482015290519081900360640190fd5b600160055460ff1660028111156100db57fe5b1415610117576040517f2b92a4b014281aa2424baba9ea60bf4f26833d1c1fbd873e51cd1a6caeef48f090600090a1610112610151565b610148565b6040517f4e1f1f06cf69d199fcdb4d87a5a92d5248ca6b540e9fc2d3698927c5002a236a90600090a16101486101ce565b565b6103e80290565b600080546002546001546040805163396f51cf60e01b81526001600160a01b0393841660048201529183166024830152516101009093049091169263396f51cf9260448084019382900301818387803b1580156101ad57600080fd5b505af11580156101c1573d6000803e3d6000fd5b505050506101483361022a565b600080546001546002546040805163396f51cf60e01b81526001600160a01b0393841660048201529183166024830152516101009093049091169263396f51cf9260448084019382900301818387803b1580156101ad57600080fd5b6000546040805180820190915260098152684e4f545f434c4f4e4560b81b60208201529060ff16156102da5760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b8381101561029f578181015183820152602001610287565b50505050905090810190601f1680156102cc5780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b50806001600160a01b0316fffea265627a7a72315820c700c63e5fc1f6a70f76536f2160b2a1f3062b8e7a8ca7554651acebeb715fbd64736f6c63430005110032"

+ var ChallengeFactoryBin = "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"

+ var ChallengeFactoryFuncSigs = map[string]string

+ var ChallengeFuncSigs = map[string]string

+ var ExecutionChallengeFuncSigs = map[string]string

+ var GlobalEthWalletBin = "0x608060405234801561001057600080fd5b50610110806100206000396000f3fe6080604052348015600f57600080fd5b506004361060325760003560e01c80634d2301cc146037578063a0ef91df14606c575b600080fd5b605a60048036036020811015604b57600080fd5b50356001600160a01b03166074565b60408051918252519081900360200190f35b6072608f565b005b6001600160a01b031660009081526020819052604090205490565b60006098336074565b3360008181526020819052604080822082905551929350909183156108fc0291849190818181858888f1935050505015801560d7573d6000803e3d6000fd5b505056fea265627a7a723158207f7c22f12286eac205117065b03e1b4b3eee79a5ac0cefe05583191116e7701164736f6c63430005110032"

+ var GlobalEthWalletFuncSigs = map[string]string

+ var GlobalFTWalletBin = "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"

+ var GlobalFTWalletFuncSigs = map[string]string

+ var GlobalInboxFuncSigs = map[string]string

+ var GlobalNFTWalletBin = "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"

+ var GlobalNFTWalletFuncSigs = map[string]string

+ var IERC165FuncSigs = map[string]string

+ var IERC20FuncSigs = map[string]string

+ var IERC721FuncSigs = map[string]string

+ var IPairedErc20FuncSigs = map[string]string

+ var InboxTopChallengeFuncSigs = map[string]string

+ var KeccakBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a723158202e57e6e0832add6e6a32723247ebe405deb98e21efa474e47e7e7d7b6b1f09fc64736f6c63430005110032"

+ var NodeGraphBin = "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"

+ var NodeGraphFuncSigs = map[string]string

+ var NodeGraphUtilsBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a7231582086807d620e5b044209761928521ba376ee192b256394f44013a98801b9991bdd64736f6c63430005110032"

+ var OneStepProofFuncSigs = map[string]string

+ var PaymentRecordsBin = "0x608060405234801561001057600080fd5b50610272806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c80630547e1b41461003b578063e628c91c14610083575b600080fd5b6100676004803603604081101561005157600080fd5b506001600160a01b0381351690602001356100bb565b604080516001600160a01b039092168252519081900360200190f35b6100b96004803603606081101561009957600080fd5b506001600160a01b03813581169160208101359091169060400135610126565b005b6040805160208082018490526bffffffffffffffffffffffff19606086901b16828401528251603481840301815260549092018352815191810191909120600090815290819052908120546001600160a01b03168061011d5783915050610120565b90505b92915050565b600061013284836100bb565b9050336001600160a01b0382161461018a576040805162461bcd60e51b815260206004820152601660248201527526bab9ba103132903830bcb6b2b73a1037bbb732b91760511b604482015290519081900360640190fd5b6040805160208082018590526bffffffffffffffffffffffff19606088901b168284015282516034818403018152605483018085528151918301919091206000908152918290529083902080546001600160a01b038089166001600160a01b031990921682179092559186905280881660748401528416609483015260b482015290517f56e2b14cbe3f09b8a7337ab17e6ce5da744339e435db498d5ba53655695c03e59181900360d40190a15050505056fea265627a7a72315820a2beb2d79241b65fa56bafe45686c5214b1a1245461af8289d58a73de082435664736f6c63430005110032"

+ var PaymentRecordsFuncSigs = map[string]string

+ var RollupUtilsBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a7231582093fcb3c9dda65c3c67a671d93b23253577198397382f277b4e69a39194ea4b2c64736f6c63430005110032"

+ var SafeMathBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a723158208779b99760723161ba40a9da7d8b060f33ca5d9edad455d784d6ef6d6e9e69dc64736f6c63430005110032"

+ var StakingFuncSigs = map[string]string

+ var VMBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a723158207a2f4d76c7ac5af065616b74405a4a9f6a6aafe38708dfab7489b4acf3131b9864736f6c63430005110032"

+ type ArbFactory struct

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

+ func NewArbFactory(address common.Address, backend bind.ContractBackend) (*ArbFactory, error)

+ type ArbFactoryCaller struct

+ func NewArbFactoryCaller(address common.Address, caller bind.ContractCaller) (*ArbFactoryCaller, error)

+ func (_ArbFactory *ArbFactoryCaller) ChallengeFactoryAddress(opts *bind.CallOpts) (common.Address, error)

+ func (_ArbFactory *ArbFactoryCaller) GlobalInboxAddress(opts *bind.CallOpts) (common.Address, error)

+ func (_ArbFactory *ArbFactoryCaller) RollupTemplate(opts *bind.CallOpts) (common.Address, error)

+ type ArbFactoryCallerRaw struct

+ Contract *ArbFactoryCaller

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

+ type ArbFactoryCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ArbFactoryCaller

+ func (_ArbFactory *ArbFactoryCallerSession) ChallengeFactoryAddress() (common.Address, error)

+ func (_ArbFactory *ArbFactoryCallerSession) GlobalInboxAddress() (common.Address, error)

+ func (_ArbFactory *ArbFactoryCallerSession) RollupTemplate() (common.Address, error)

+ type ArbFactoryFilterer struct

+ func NewArbFactoryFilterer(address common.Address, filterer bind.ContractFilterer) (*ArbFactoryFilterer, error)

+ func (_ArbFactory *ArbFactoryFilterer) FilterRollupCreated(opts *bind.FilterOpts) (*ArbFactoryRollupCreatedIterator, error)

+ func (_ArbFactory *ArbFactoryFilterer) ParseRollupCreated(log types.Log) (*ArbFactoryRollupCreated, error)

+ func (_ArbFactory *ArbFactoryFilterer) WatchRollupCreated(opts *bind.WatchOpts, sink chan<- *ArbFactoryRollupCreated) (event.Subscription, error)

+ type ArbFactoryRaw struct

+ Contract *ArbFactory

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

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

+ func (_ArbFactory *ArbFactoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ArbFactoryRollupCreated struct

+ Raw types.Log

+ RollupAddress common.Address

+ type ArbFactoryRollupCreatedIterator struct

+ Event *ArbFactoryRollupCreated

+ func (it *ArbFactoryRollupCreatedIterator) Close() error

+ func (it *ArbFactoryRollupCreatedIterator) Error() error

+ func (it *ArbFactoryRollupCreatedIterator) Next() bool

+ type ArbFactorySession struct

+ CallOpts bind.CallOpts

+ Contract *ArbFactory

+ TransactOpts bind.TransactOpts

+ func (_ArbFactory *ArbFactorySession) ChallengeFactoryAddress() (common.Address, error)

+ func (_ArbFactory *ArbFactorySession) CreateRollup(_vmState [32]byte, _gracePeriodTicks *big.Int, ...) (*types.Transaction, error)

+ func (_ArbFactory *ArbFactorySession) GlobalInboxAddress() (common.Address, error)

+ func (_ArbFactory *ArbFactorySession) RollupTemplate() (common.Address, error)

+ type ArbFactoryTransactor struct

+ func NewArbFactoryTransactor(address common.Address, transactor bind.ContractTransactor) (*ArbFactoryTransactor, error)

+ func (_ArbFactory *ArbFactoryTransactor) CreateRollup(opts *bind.TransactOpts, _vmState [32]byte, _gracePeriodTicks *big.Int, ...) (*types.Transaction, error)

+ type ArbFactoryTransactorRaw struct

+ Contract *ArbFactoryTransactor

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

+ func (_ArbFactory *ArbFactoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ArbFactoryTransactorSession struct

+ Contract *ArbFactoryTransactor

+ TransactOpts bind.TransactOpts

+ func (_ArbFactory *ArbFactoryTransactorSession) CreateRollup(_vmState [32]byte, _gracePeriodTicks *big.Int, ...) (*types.Transaction, error)

+ type ArbRollup struct

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

+ func NewArbRollup(address common.Address, backend bind.ContractBackend) (*ArbRollup, error)

+ type ArbRollupCaller struct

+ func NewArbRollupCaller(address common.Address, caller bind.ContractCaller) (*ArbRollupCaller, error)

+ func (_ArbRollup *ArbRollupCaller) ChallengeFactory(opts *bind.CallOpts) (common.Address, error)

+ func (_ArbRollup *ArbRollupCaller) GetStakeRequired(opts *bind.CallOpts) (*big.Int, error)

+ func (_ArbRollup *ArbRollupCaller) GetStakeToken(opts *bind.CallOpts) (common.Address, error)

+ func (_ArbRollup *ArbRollupCaller) GlobalInbox(opts *bind.CallOpts) (common.Address, error)

+ func (_ArbRollup *ArbRollupCaller) IsMaster(opts *bind.CallOpts) (bool, error)

+ func (_ArbRollup *ArbRollupCaller) IsStaked(opts *bind.CallOpts, _stakerAddress common.Address) (bool, error)

+ func (_ArbRollup *ArbRollupCaller) IsValidLeaf(opts *bind.CallOpts, leaf [32]byte) (bool, error)

+ func (_ArbRollup *ArbRollupCaller) LatestConfirmed(opts *bind.CallOpts) ([32]byte, error)

+ func (_ArbRollup *ArbRollupCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_ArbRollup *ArbRollupCaller) VERSION(opts *bind.CallOpts) (string, error)

+ func (_ArbRollup *ArbRollupCaller) VmParams(opts *bind.CallOpts) (struct{ ... }, error)

+ type ArbRollupCallerRaw struct

+ Contract *ArbRollupCaller

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

+ type ArbRollupCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ArbRollupCaller

+ func (_ArbRollup *ArbRollupCallerSession) ChallengeFactory() (common.Address, error)

+ func (_ArbRollup *ArbRollupCallerSession) GetStakeRequired() (*big.Int, error)

+ func (_ArbRollup *ArbRollupCallerSession) GetStakeToken() (common.Address, error)

+ func (_ArbRollup *ArbRollupCallerSession) GlobalInbox() (common.Address, error)

+ func (_ArbRollup *ArbRollupCallerSession) IsMaster() (bool, error)

+ func (_ArbRollup *ArbRollupCallerSession) IsStaked(_stakerAddress common.Address) (bool, error)

+ func (_ArbRollup *ArbRollupCallerSession) IsValidLeaf(leaf [32]byte) (bool, error)

+ func (_ArbRollup *ArbRollupCallerSession) LatestConfirmed() ([32]byte, error)

+ func (_ArbRollup *ArbRollupCallerSession) Owner() (common.Address, error)

+ func (_ArbRollup *ArbRollupCallerSession) VERSION() (string, error)

+ func (_ArbRollup *ArbRollupCallerSession) VmParams() (struct{ ... }, error)

+ type ArbRollupConfirmedAssertion struct

+ LogsAccHash [][32]byte

+ Raw types.Log

+ type ArbRollupConfirmedAssertionIterator struct

+ Event *ArbRollupConfirmedAssertion

+ func (it *ArbRollupConfirmedAssertionIterator) Close() error

+ func (it *ArbRollupConfirmedAssertionIterator) Error() error

+ func (it *ArbRollupConfirmedAssertionIterator) Next() bool

+ type ArbRollupConfirmedValidAssertion struct

+ NodeHash [32]byte

+ Raw types.Log

+ type ArbRollupConfirmedValidAssertionIterator struct

+ Event *ArbRollupConfirmedValidAssertion

+ func (it *ArbRollupConfirmedValidAssertionIterator) Close() error

+ func (it *ArbRollupConfirmedValidAssertionIterator) Error() error

+ func (it *ArbRollupConfirmedValidAssertionIterator) Next() bool

+ type ArbRollupFilterer struct

+ func NewArbRollupFilterer(address common.Address, filterer bind.ContractFilterer) (*ArbRollupFilterer, error)

+ func (_ArbRollup *ArbRollupFilterer) FilterConfirmedAssertion(opts *bind.FilterOpts) (*ArbRollupConfirmedAssertionIterator, error)

+ func (_ArbRollup *ArbRollupFilterer) FilterConfirmedValidAssertion(opts *bind.FilterOpts, nodeHash [][32]byte) (*ArbRollupConfirmedValidAssertionIterator, error)

+ func (_ArbRollup *ArbRollupFilterer) FilterRollupAsserted(opts *bind.FilterOpts) (*ArbRollupRollupAssertedIterator, error)

+ func (_ArbRollup *ArbRollupFilterer) FilterRollupChallengeCompleted(opts *bind.FilterOpts) (*ArbRollupRollupChallengeCompletedIterator, error)

+ func (_ArbRollup *ArbRollupFilterer) FilterRollupChallengeStarted(opts *bind.FilterOpts) (*ArbRollupRollupChallengeStartedIterator, error)

+ func (_ArbRollup *ArbRollupFilterer) FilterRollupConfirmed(opts *bind.FilterOpts) (*ArbRollupRollupConfirmedIterator, error)

+ func (_ArbRollup *ArbRollupFilterer) FilterRollupCreated(opts *bind.FilterOpts) (*ArbRollupRollupCreatedIterator, error)

+ func (_ArbRollup *ArbRollupFilterer) FilterRollupPruned(opts *bind.FilterOpts) (*ArbRollupRollupPrunedIterator, error)

+ func (_ArbRollup *ArbRollupFilterer) FilterRollupStakeCreated(opts *bind.FilterOpts) (*ArbRollupRollupStakeCreatedIterator, error)

+ func (_ArbRollup *ArbRollupFilterer) FilterRollupStakeMoved(opts *bind.FilterOpts) (*ArbRollupRollupStakeMovedIterator, error)

+ func (_ArbRollup *ArbRollupFilterer) FilterRollupStakeRefunded(opts *bind.FilterOpts) (*ArbRollupRollupStakeRefundedIterator, error)

+ func (_ArbRollup *ArbRollupFilterer) ParseConfirmedAssertion(log types.Log) (*ArbRollupConfirmedAssertion, error)

+ func (_ArbRollup *ArbRollupFilterer) ParseConfirmedValidAssertion(log types.Log) (*ArbRollupConfirmedValidAssertion, error)

+ func (_ArbRollup *ArbRollupFilterer) ParseRollupAsserted(log types.Log) (*ArbRollupRollupAsserted, error)

+ func (_ArbRollup *ArbRollupFilterer) ParseRollupChallengeCompleted(log types.Log) (*ArbRollupRollupChallengeCompleted, error)

+ func (_ArbRollup *ArbRollupFilterer) ParseRollupChallengeStarted(log types.Log) (*ArbRollupRollupChallengeStarted, error)

+ func (_ArbRollup *ArbRollupFilterer) ParseRollupConfirmed(log types.Log) (*ArbRollupRollupConfirmed, error)

+ func (_ArbRollup *ArbRollupFilterer) ParseRollupCreated(log types.Log) (*ArbRollupRollupCreated, error)

+ func (_ArbRollup *ArbRollupFilterer) ParseRollupPruned(log types.Log) (*ArbRollupRollupPruned, error)

+ func (_ArbRollup *ArbRollupFilterer) ParseRollupStakeCreated(log types.Log) (*ArbRollupRollupStakeCreated, error)

+ func (_ArbRollup *ArbRollupFilterer) ParseRollupStakeMoved(log types.Log) (*ArbRollupRollupStakeMoved, error)

+ func (_ArbRollup *ArbRollupFilterer) ParseRollupStakeRefunded(log types.Log) (*ArbRollupRollupStakeRefunded, error)

+ func (_ArbRollup *ArbRollupFilterer) WatchConfirmedAssertion(opts *bind.WatchOpts, sink chan<- *ArbRollupConfirmedAssertion) (event.Subscription, error)

+ func (_ArbRollup *ArbRollupFilterer) WatchConfirmedValidAssertion(opts *bind.WatchOpts, sink chan<- *ArbRollupConfirmedValidAssertion, ...) (event.Subscription, error)

+ func (_ArbRollup *ArbRollupFilterer) WatchRollupAsserted(opts *bind.WatchOpts, sink chan<- *ArbRollupRollupAsserted) (event.Subscription, error)

+ func (_ArbRollup *ArbRollupFilterer) WatchRollupChallengeCompleted(opts *bind.WatchOpts, sink chan<- *ArbRollupRollupChallengeCompleted) (event.Subscription, error)

+ func (_ArbRollup *ArbRollupFilterer) WatchRollupChallengeStarted(opts *bind.WatchOpts, sink chan<- *ArbRollupRollupChallengeStarted) (event.Subscription, error)

+ func (_ArbRollup *ArbRollupFilterer) WatchRollupConfirmed(opts *bind.WatchOpts, sink chan<- *ArbRollupRollupConfirmed) (event.Subscription, error)

+ func (_ArbRollup *ArbRollupFilterer) WatchRollupCreated(opts *bind.WatchOpts, sink chan<- *ArbRollupRollupCreated) (event.Subscription, error)

+ func (_ArbRollup *ArbRollupFilterer) WatchRollupPruned(opts *bind.WatchOpts, sink chan<- *ArbRollupRollupPruned) (event.Subscription, error)

+ func (_ArbRollup *ArbRollupFilterer) WatchRollupStakeCreated(opts *bind.WatchOpts, sink chan<- *ArbRollupRollupStakeCreated) (event.Subscription, error)

+ func (_ArbRollup *ArbRollupFilterer) WatchRollupStakeMoved(opts *bind.WatchOpts, sink chan<- *ArbRollupRollupStakeMoved) (event.Subscription, error)

+ func (_ArbRollup *ArbRollupFilterer) WatchRollupStakeRefunded(opts *bind.WatchOpts, sink chan<- *ArbRollupRollupStakeRefunded) (event.Subscription, error)

+ type ArbRollupRaw struct

+ Contract *ArbRollup

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

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

+ func (_ArbRollup *ArbRollupRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ArbRollupRollupAsserted struct

+ BeforeLogCount *big.Int

+ BeforeMessageCount *big.Int

+ Fields [7][32]byte

+ ImportedMessageCount *big.Int

+ InboxCount *big.Int

+ LogCount uint64

+ MessageCount uint64

+ NumArbGas uint64

+ NumSteps uint64

+ Raw types.Log

+ type ArbRollupRollupAssertedIterator struct

+ Event *ArbRollupRollupAsserted

+ func (it *ArbRollupRollupAssertedIterator) Close() error

+ func (it *ArbRollupRollupAssertedIterator) Error() error

+ func (it *ArbRollupRollupAssertedIterator) Next() bool

+ type ArbRollupRollupChallengeCompleted struct

+ ChallengeContract common.Address

+ Loser common.Address

+ Raw types.Log

+ Winner common.Address

+ type ArbRollupRollupChallengeCompletedIterator struct

+ Event *ArbRollupRollupChallengeCompleted

+ func (it *ArbRollupRollupChallengeCompletedIterator) Close() error

+ func (it *ArbRollupRollupChallengeCompletedIterator) Error() error

+ func (it *ArbRollupRollupChallengeCompletedIterator) Next() bool

+ type ArbRollupRollupChallengeStarted struct

+ Asserter common.Address

+ ChallengeContract common.Address

+ ChallengeType *big.Int

+ Challenger common.Address

+ Raw types.Log

+ type ArbRollupRollupChallengeStartedIterator struct

+ Event *ArbRollupRollupChallengeStarted

+ func (it *ArbRollupRollupChallengeStartedIterator) Close() error

+ func (it *ArbRollupRollupChallengeStartedIterator) Error() error

+ func (it *ArbRollupRollupChallengeStartedIterator) Next() bool

+ type ArbRollupRollupConfirmed struct

+ NodeHash [32]byte

+ Raw types.Log

+ type ArbRollupRollupConfirmedIterator struct

+ Event *ArbRollupRollupConfirmed

+ func (it *ArbRollupRollupConfirmedIterator) Close() error

+ func (it *ArbRollupRollupConfirmedIterator) Error() error

+ func (it *ArbRollupRollupConfirmedIterator) Next() bool

+ type ArbRollupRollupCreated struct

+ ArbGasSpeedLimitPerTick *big.Int

+ ExtraConfig []byte

+ GracePeriodTicks *big.Int

+ InitVMHash [32]byte

+ MaxExecutionSteps uint64

+ Owner common.Address

+ Raw types.Log

+ StakeRequirement *big.Int

+ type ArbRollupRollupCreatedIterator struct

+ Event *ArbRollupRollupCreated

+ func (it *ArbRollupRollupCreatedIterator) Close() error

+ func (it *ArbRollupRollupCreatedIterator) Error() error

+ func (it *ArbRollupRollupCreatedIterator) Next() bool

+ type ArbRollupRollupPruned struct

+ Leaf [32]byte

+ Raw types.Log

+ type ArbRollupRollupPrunedIterator struct

+ Event *ArbRollupRollupPruned

+ func (it *ArbRollupRollupPrunedIterator) Close() error

+ func (it *ArbRollupRollupPrunedIterator) Error() error

+ func (it *ArbRollupRollupPrunedIterator) Next() bool

+ type ArbRollupRollupStakeCreated struct

+ NodeHash [32]byte

+ Raw types.Log

+ Staker common.Address

+ type ArbRollupRollupStakeCreatedIterator struct

+ Event *ArbRollupRollupStakeCreated

+ func (it *ArbRollupRollupStakeCreatedIterator) Close() error

+ func (it *ArbRollupRollupStakeCreatedIterator) Error() error

+ func (it *ArbRollupRollupStakeCreatedIterator) Next() bool

+ type ArbRollupRollupStakeMoved struct

+ Raw types.Log

+ Staker common.Address

+ ToNodeHash [32]byte

+ type ArbRollupRollupStakeMovedIterator struct

+ Event *ArbRollupRollupStakeMoved

+ func (it *ArbRollupRollupStakeMovedIterator) Close() error

+ func (it *ArbRollupRollupStakeMovedIterator) Error() error

+ func (it *ArbRollupRollupStakeMovedIterator) Next() bool

+ type ArbRollupRollupStakeRefunded struct

+ Raw types.Log

+ Staker common.Address

+ type ArbRollupRollupStakeRefundedIterator struct

+ Event *ArbRollupRollupStakeRefunded

+ func (it *ArbRollupRollupStakeRefundedIterator) Close() error

+ func (it *ArbRollupRollupStakeRefundedIterator) Error() error

+ func (it *ArbRollupRollupStakeRefundedIterator) Next() bool

+ type ArbRollupSession struct

+ CallOpts bind.CallOpts

+ Contract *ArbRollup

+ TransactOpts bind.TransactOpts

+ func (_ArbRollup *ArbRollupSession) ChallengeFactory() (common.Address, error)

+ func (_ArbRollup *ArbRollupSession) Confirm(initalProtoStateHash [32]byte, beforeSendCount *big.Int, branches []*big.Int, ...) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupSession) GetStakeRequired() (*big.Int, error)

+ func (_ArbRollup *ArbRollupSession) GetStakeToken() (common.Address, error)

+ func (_ArbRollup *ArbRollupSession) GetWithdrawnStake(_staker common.Address) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupSession) GlobalInbox() (common.Address, error)

+ func (_ArbRollup *ArbRollupSession) Init(_vmState [32]byte, _gracePeriodTicks *big.Int, ...) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupSession) IsMaster() (bool, error)

+ func (_ArbRollup *ArbRollupSession) IsStaked(_stakerAddress common.Address) (bool, error)

+ func (_ArbRollup *ArbRollupSession) IsValidLeaf(leaf [32]byte) (bool, error)

+ func (_ArbRollup *ArbRollupSession) LatestConfirmed() ([32]byte, error)

+ func (_ArbRollup *ArbRollupSession) MakeAssertion(fields [8][32]byte, fields2 [5]*big.Int, validBlockHashPrecondition [32]byte, ...) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupSession) MoveStake(proof1 [][32]byte, proof2 [][32]byte) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupSession) Owner() (common.Address, error)

+ func (_ArbRollup *ArbRollupSession) OwnerShutdown() (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupSession) PlaceStake(proof1 [][32]byte, proof2 [][32]byte) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupSession) PruneLeaves(fromNodes [][32]byte, leafProofs [][32]byte, leafProofLengths []*big.Int, ...) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupSession) RecoverStakeConfirmed(proof [][32]byte) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupSession) RecoverStakeMooted(stakerAddress common.Address, node [32]byte, latestConfirmedProof [][32]byte, ...) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupSession) RecoverStakeOld(stakerAddress common.Address, proof [][32]byte) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupSession) RecoverStakePassedDeadline(stakerAddress common.Address, deadlineTicks *big.Int, ...) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupSession) ResolveChallenge(winner common.Address, loser common.Address) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupSession) StartChallenge(asserterAddress common.Address, challengerAddress common.Address, ...) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupSession) VERSION() (string, error)

+ func (_ArbRollup *ArbRollupSession) VmParams() (struct{ ... }, error)

+ type ArbRollupTransactor struct

+ func NewArbRollupTransactor(address common.Address, transactor bind.ContractTransactor) (*ArbRollupTransactor, error)

+ func (_ArbRollup *ArbRollupTransactor) Confirm(opts *bind.TransactOpts, initalProtoStateHash [32]byte, ...) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactor) ConfirmCall(ctx context.Context, client ethutils.EthClient, from common.Address, ...) error

+ func (_ArbRollup *ArbRollupTransactor) GetWithdrawnStake(opts *bind.TransactOpts, _staker common.Address) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactor) Init(opts *bind.TransactOpts, _vmState [32]byte, _gracePeriodTicks *big.Int, ...) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactor) MakeAssertion(opts *bind.TransactOpts, fields [8][32]byte, fields2 [5]*big.Int, ...) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactor) MakeAssertionCall(ctx context.Context, client ethutils.EthClient, from common.Address, ...) error

+ func (_ArbRollup *ArbRollupTransactor) MoveStake(opts *bind.TransactOpts, proof1 [][32]byte, proof2 [][32]byte) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactor) OwnerShutdown(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactor) PlaceStake(opts *bind.TransactOpts, proof1 [][32]byte, proof2 [][32]byte) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactor) PruneLeaves(opts *bind.TransactOpts, fromNodes [][32]byte, leafProofs [][32]byte, ...) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactor) RecoverStakeConfirmed(opts *bind.TransactOpts, proof [][32]byte) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactor) RecoverStakeMooted(opts *bind.TransactOpts, stakerAddress common.Address, node [32]byte, ...) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactor) RecoverStakeOld(opts *bind.TransactOpts, stakerAddress common.Address, proof [][32]byte) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactor) RecoverStakePassedDeadline(opts *bind.TransactOpts, stakerAddress common.Address, deadlineTicks *big.Int, ...) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactor) ResolveChallenge(opts *bind.TransactOpts, winner common.Address, loser common.Address) (*types.Transaction, error)

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

+ type ArbRollupTransactorRaw struct

+ Contract *ArbRollupTransactor

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

+ func (_ArbRollup *ArbRollupTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ArbRollupTransactorSession struct

+ Contract *ArbRollupTransactor

+ TransactOpts bind.TransactOpts

+ func (_ArbRollup *ArbRollupTransactorSession) Confirm(initalProtoStateHash [32]byte, beforeSendCount *big.Int, branches []*big.Int, ...) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactorSession) GetWithdrawnStake(_staker common.Address) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactorSession) Init(_vmState [32]byte, _gracePeriodTicks *big.Int, ...) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactorSession) MakeAssertion(fields [8][32]byte, fields2 [5]*big.Int, validBlockHashPrecondition [32]byte, ...) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactorSession) MoveStake(proof1 [][32]byte, proof2 [][32]byte) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactorSession) OwnerShutdown() (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactorSession) PlaceStake(proof1 [][32]byte, proof2 [][32]byte) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactorSession) PruneLeaves(fromNodes [][32]byte, leafProofs [][32]byte, leafProofLengths []*big.Int, ...) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactorSession) RecoverStakeConfirmed(proof [][32]byte) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactorSession) RecoverStakeMooted(stakerAddress common.Address, node [32]byte, latestConfirmedProof [][32]byte, ...) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactorSession) RecoverStakeOld(stakerAddress common.Address, proof [][32]byte) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactorSession) RecoverStakePassedDeadline(stakerAddress common.Address, deadlineTicks *big.Int, ...) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactorSession) ResolveChallenge(winner common.Address, loser common.Address) (*types.Transaction, error)

+ func (_ArbRollup *ArbRollupTransactorSession) StartChallenge(asserterAddress common.Address, challengerAddress common.Address, ...) (*types.Transaction, error)

+ type BisectionChallenge struct

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

+ func NewBisectionChallenge(address common.Address, backend bind.ContractBackend) (*BisectionChallenge, error)

+ type BisectionChallengeAsserterTimedOut struct

+ Raw types.Log

+ type BisectionChallengeAsserterTimedOutIterator struct

+ Event *BisectionChallengeAsserterTimedOut

+ func (it *BisectionChallengeAsserterTimedOutIterator) Close() error

+ func (it *BisectionChallengeAsserterTimedOutIterator) Error() error

+ func (it *BisectionChallengeAsserterTimedOutIterator) Next() bool

+ type BisectionChallengeCaller struct

+ func NewBisectionChallengeCaller(address common.Address, caller bind.ContractCaller) (*BisectionChallengeCaller, error)

+ func (_BisectionChallenge *BisectionChallengeCaller) IsMaster(opts *bind.CallOpts) (bool, error)

+ type BisectionChallengeCallerRaw struct

+ Contract *BisectionChallengeCaller

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

+ type BisectionChallengeCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *BisectionChallengeCaller

+ func (_BisectionChallenge *BisectionChallengeCallerSession) IsMaster() (bool, error)

+ type BisectionChallengeChallengerTimedOut struct

+ Raw types.Log

+ type BisectionChallengeChallengerTimedOutIterator struct

+ Event *BisectionChallengeChallengerTimedOut

+ func (it *BisectionChallengeChallengerTimedOutIterator) Close() error

+ func (it *BisectionChallengeChallengerTimedOutIterator) Error() error

+ func (it *BisectionChallengeChallengerTimedOutIterator) Next() bool

+ type BisectionChallengeContinued struct

+ DeadlineTicks *big.Int

+ Raw types.Log

+ SegmentIndex *big.Int

+ type BisectionChallengeContinuedIterator struct

+ Event *BisectionChallengeContinued

+ func (it *BisectionChallengeContinuedIterator) Close() error

+ func (it *BisectionChallengeContinuedIterator) Error() error

+ func (it *BisectionChallengeContinuedIterator) Next() bool

+ type BisectionChallengeFilterer struct

+ func NewBisectionChallengeFilterer(address common.Address, filterer bind.ContractFilterer) (*BisectionChallengeFilterer, error)

+ func (_BisectionChallenge *BisectionChallengeFilterer) FilterAsserterTimedOut(opts *bind.FilterOpts) (*BisectionChallengeAsserterTimedOutIterator, error)

+ func (_BisectionChallenge *BisectionChallengeFilterer) FilterChallengerTimedOut(opts *bind.FilterOpts) (*BisectionChallengeChallengerTimedOutIterator, error)

+ func (_BisectionChallenge *BisectionChallengeFilterer) FilterContinued(opts *bind.FilterOpts) (*BisectionChallengeContinuedIterator, error)

+ func (_BisectionChallenge *BisectionChallengeFilterer) FilterInitiatedChallenge(opts *bind.FilterOpts) (*BisectionChallengeInitiatedChallengeIterator, error)

+ func (_BisectionChallenge *BisectionChallengeFilterer) ParseAsserterTimedOut(log types.Log) (*BisectionChallengeAsserterTimedOut, error)

+ func (_BisectionChallenge *BisectionChallengeFilterer) ParseChallengerTimedOut(log types.Log) (*BisectionChallengeChallengerTimedOut, error)

+ func (_BisectionChallenge *BisectionChallengeFilterer) ParseContinued(log types.Log) (*BisectionChallengeContinued, error)

+ func (_BisectionChallenge *BisectionChallengeFilterer) ParseInitiatedChallenge(log types.Log) (*BisectionChallengeInitiatedChallenge, error)

+ func (_BisectionChallenge *BisectionChallengeFilterer) WatchAsserterTimedOut(opts *bind.WatchOpts, sink chan<- *BisectionChallengeAsserterTimedOut) (event.Subscription, error)

+ func (_BisectionChallenge *BisectionChallengeFilterer) WatchChallengerTimedOut(opts *bind.WatchOpts, sink chan<- *BisectionChallengeChallengerTimedOut) (event.Subscription, error)

+ func (_BisectionChallenge *BisectionChallengeFilterer) WatchContinued(opts *bind.WatchOpts, sink chan<- *BisectionChallengeContinued) (event.Subscription, error)

+ func (_BisectionChallenge *BisectionChallengeFilterer) WatchInitiatedChallenge(opts *bind.WatchOpts, sink chan<- *BisectionChallengeInitiatedChallenge) (event.Subscription, error)

+ type BisectionChallengeInitiatedChallenge struct

+ DeadlineTicks *big.Int

+ Raw types.Log

+ type BisectionChallengeInitiatedChallengeIterator struct

+ Event *BisectionChallengeInitiatedChallenge

+ func (it *BisectionChallengeInitiatedChallengeIterator) Close() error

+ func (it *BisectionChallengeInitiatedChallengeIterator) Error() error

+ func (it *BisectionChallengeInitiatedChallengeIterator) Next() bool

+ type BisectionChallengeRaw struct

+ Contract *BisectionChallenge

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

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

+ func (_BisectionChallenge *BisectionChallengeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BisectionChallengeSession struct

+ CallOpts bind.CallOpts

+ Contract *BisectionChallenge

+ TransactOpts bind.TransactOpts

+ func (_BisectionChallenge *BisectionChallengeSession) ChooseSegment(_segmentToChallenge *big.Int, _proof []byte, _bisectionRoot [32]byte, ...) (*types.Transaction, error)

+ func (_BisectionChallenge *BisectionChallengeSession) InitializeBisection(_rollupAddress common.Address, _asserter common.Address, ...) (*types.Transaction, error)

+ func (_BisectionChallenge *BisectionChallengeSession) IsMaster() (bool, error)

+ func (_BisectionChallenge *BisectionChallengeSession) TimeoutChallenge() (*types.Transaction, error)

+ type BisectionChallengeTransactor struct

+ func NewBisectionChallengeTransactor(address common.Address, transactor bind.ContractTransactor) (*BisectionChallengeTransactor, error)

+ func (_BisectionChallenge *BisectionChallengeTransactor) ChooseSegment(opts *bind.TransactOpts, _segmentToChallenge *big.Int, _proof []byte, ...) (*types.Transaction, error)

+ func (_BisectionChallenge *BisectionChallengeTransactor) ChooseSegmentCall(ctx context.Context, client ethutils.EthClient, from common.Address, ...) error

+ func (_BisectionChallenge *BisectionChallengeTransactor) InitializeBisection(opts *bind.TransactOpts, _rollupAddress common.Address, ...) (*types.Transaction, error)

+ func (_BisectionChallenge *BisectionChallengeTransactor) TimeoutChallenge(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BisectionChallengeTransactorRaw struct

+ Contract *BisectionChallengeTransactor

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

+ func (_BisectionChallenge *BisectionChallengeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BisectionChallengeTransactorSession struct

+ Contract *BisectionChallengeTransactor

+ TransactOpts bind.TransactOpts

+ func (_BisectionChallenge *BisectionChallengeTransactorSession) ChooseSegment(_segmentToChallenge *big.Int, _proof []byte, _bisectionRoot [32]byte, ...) (*types.Transaction, error)

+ func (_BisectionChallenge *BisectionChallengeTransactorSession) InitializeBisection(_rollupAddress common.Address, _asserter common.Address, ...) (*types.Transaction, error)

+ func (_BisectionChallenge *BisectionChallengeTransactorSession) TimeoutChallenge() (*types.Transaction, error)

+ type Challenge struct

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

+ func NewChallenge(address common.Address, backend bind.ContractBackend) (*Challenge, error)

+ type ChallengeAsserterTimedOut struct

+ Raw types.Log

+ type ChallengeAsserterTimedOutIterator struct

+ Event *ChallengeAsserterTimedOut

+ func (it *ChallengeAsserterTimedOutIterator) Close() error

+ func (it *ChallengeAsserterTimedOutIterator) Error() error

+ func (it *ChallengeAsserterTimedOutIterator) Next() bool

+ type ChallengeCaller struct

+ func NewChallengeCaller(address common.Address, caller bind.ContractCaller) (*ChallengeCaller, error)

+ func (_Challenge *ChallengeCaller) IsMaster(opts *bind.CallOpts) (bool, error)

+ type ChallengeCallerRaw struct

+ Contract *ChallengeCaller

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

+ type ChallengeCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ChallengeCaller

+ func (_Challenge *ChallengeCallerSession) IsMaster() (bool, error)

+ type ChallengeChallengerTimedOut struct

+ Raw types.Log

+ type ChallengeChallengerTimedOutIterator struct

+ Event *ChallengeChallengerTimedOut

+ func (it *ChallengeChallengerTimedOutIterator) Close() error

+ func (it *ChallengeChallengerTimedOutIterator) Error() error

+ func (it *ChallengeChallengerTimedOutIterator) Next() bool

+ type ChallengeFactory struct

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

+ func NewChallengeFactory(address common.Address, backend bind.ContractBackend) (*ChallengeFactory, error)

+ type ChallengeFactoryCaller struct

+ func NewChallengeFactoryCaller(address common.Address, caller bind.ContractCaller) (*ChallengeFactoryCaller, error)

+ func (_ChallengeFactory *ChallengeFactoryCaller) ExecutionChallengeTemplate(opts *bind.CallOpts) (common.Address, error)

+ func (_ChallengeFactory *ChallengeFactoryCaller) GenerateCloneAddress(opts *bind.CallOpts, asserter common.Address, challenger common.Address, ...) (common.Address, error)

+ func (_ChallengeFactory *ChallengeFactoryCaller) INVALIDTYPESTR(opts *bind.CallOpts) (string, error)

+ func (_ChallengeFactory *ChallengeFactoryCaller) InboxTopChallengeTemplate(opts *bind.CallOpts) (common.Address, error)

+ func (_ChallengeFactory *ChallengeFactoryCaller) OneStepProofAddress(opts *bind.CallOpts) (common.Address, error)

+ type ChallengeFactoryCallerRaw struct

+ Contract *ChallengeFactoryCaller

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

+ type ChallengeFactoryCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ChallengeFactoryCaller

+ func (_ChallengeFactory *ChallengeFactoryCallerSession) ExecutionChallengeTemplate() (common.Address, error)

+ func (_ChallengeFactory *ChallengeFactoryCallerSession) GenerateCloneAddress(asserter common.Address, challenger common.Address, challengeType *big.Int) (common.Address, error)

+ func (_ChallengeFactory *ChallengeFactoryCallerSession) INVALIDTYPESTR() (string, error)

+ func (_ChallengeFactory *ChallengeFactoryCallerSession) InboxTopChallengeTemplate() (common.Address, error)

+ func (_ChallengeFactory *ChallengeFactoryCallerSession) OneStepProofAddress() (common.Address, error)

+ type ChallengeFactoryFilterer struct

+ func NewChallengeFactoryFilterer(address common.Address, filterer bind.ContractFilterer) (*ChallengeFactoryFilterer, error)

+ type ChallengeFactoryRaw struct

+ Contract *ChallengeFactory

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

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

+ func (_ChallengeFactory *ChallengeFactoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ChallengeFactorySession struct

+ CallOpts bind.CallOpts

+ Contract *ChallengeFactory

+ TransactOpts bind.TransactOpts

+ func (_ChallengeFactory *ChallengeFactorySession) CreateChallenge(_asserter common.Address, _challenger common.Address, ...) (*types.Transaction, error)

+ func (_ChallengeFactory *ChallengeFactorySession) ExecutionChallengeTemplate() (common.Address, error)

+ func (_ChallengeFactory *ChallengeFactorySession) GenerateCloneAddress(asserter common.Address, challenger common.Address, challengeType *big.Int) (common.Address, error)

+ func (_ChallengeFactory *ChallengeFactorySession) INVALIDTYPESTR() (string, error)

+ func (_ChallengeFactory *ChallengeFactorySession) InboxTopChallengeTemplate() (common.Address, error)

+ func (_ChallengeFactory *ChallengeFactorySession) OneStepProofAddress() (common.Address, error)

+ type ChallengeFactoryTransactor struct

+ func NewChallengeFactoryTransactor(address common.Address, transactor bind.ContractTransactor) (*ChallengeFactoryTransactor, error)

+ func (_ChallengeFactory *ChallengeFactoryTransactor) CreateChallenge(opts *bind.TransactOpts, _asserter common.Address, _challenger common.Address, ...) (*types.Transaction, error)

+ type ChallengeFactoryTransactorRaw struct

+ Contract *ChallengeFactoryTransactor

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

+ func (_ChallengeFactory *ChallengeFactoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ChallengeFactoryTransactorSession struct

+ Contract *ChallengeFactoryTransactor

+ TransactOpts bind.TransactOpts

+ func (_ChallengeFactory *ChallengeFactoryTransactorSession) CreateChallenge(_asserter common.Address, _challenger common.Address, ...) (*types.Transaction, error)

+ type ChallengeFilterer struct

+ func NewChallengeFilterer(address common.Address, filterer bind.ContractFilterer) (*ChallengeFilterer, error)

+ func (_Challenge *ChallengeFilterer) FilterAsserterTimedOut(opts *bind.FilterOpts) (*ChallengeAsserterTimedOutIterator, error)

+ func (_Challenge *ChallengeFilterer) FilterChallengerTimedOut(opts *bind.FilterOpts) (*ChallengeChallengerTimedOutIterator, error)

+ func (_Challenge *ChallengeFilterer) FilterInitiatedChallenge(opts *bind.FilterOpts) (*ChallengeInitiatedChallengeIterator, error)

+ func (_Challenge *ChallengeFilterer) ParseAsserterTimedOut(log types.Log) (*ChallengeAsserterTimedOut, error)

+ func (_Challenge *ChallengeFilterer) ParseChallengerTimedOut(log types.Log) (*ChallengeChallengerTimedOut, error)

+ func (_Challenge *ChallengeFilterer) ParseInitiatedChallenge(log types.Log) (*ChallengeInitiatedChallenge, error)

+ func (_Challenge *ChallengeFilterer) WatchAsserterTimedOut(opts *bind.WatchOpts, sink chan<- *ChallengeAsserterTimedOut) (event.Subscription, error)

+ func (_Challenge *ChallengeFilterer) WatchChallengerTimedOut(opts *bind.WatchOpts, sink chan<- *ChallengeChallengerTimedOut) (event.Subscription, error)

+ func (_Challenge *ChallengeFilterer) WatchInitiatedChallenge(opts *bind.WatchOpts, sink chan<- *ChallengeInitiatedChallenge) (event.Subscription, error)

+ type ChallengeInitiatedChallenge struct

+ DeadlineTicks *big.Int

+ Raw types.Log

+ type ChallengeInitiatedChallengeIterator struct

+ Event *ChallengeInitiatedChallenge

+ func (it *ChallengeInitiatedChallengeIterator) Close() error

+ func (it *ChallengeInitiatedChallengeIterator) Error() error

+ func (it *ChallengeInitiatedChallengeIterator) Next() bool

+ type ChallengeRaw struct

+ Contract *Challenge

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

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

+ func (_Challenge *ChallengeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ChallengeSession struct

+ CallOpts bind.CallOpts

+ Contract *Challenge

+ TransactOpts bind.TransactOpts

+ func (_Challenge *ChallengeSession) IsMaster() (bool, error)

+ func (_Challenge *ChallengeSession) TimeoutChallenge() (*types.Transaction, error)

+ type ChallengeTransactor struct

+ func NewChallengeTransactor(address common.Address, transactor bind.ContractTransactor) (*ChallengeTransactor, error)

+ func (_Challenge *ChallengeTransactor) TimeoutChallenge(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Challenge *ChallengeTransactor) TimeoutChallengeCall(ctx context.Context, client ethutils.EthClient, from common.Address, ...) error

+ type ChallengeTransactorRaw struct

+ Contract *ChallengeTransactor

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

+ func (_Challenge *ChallengeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ChallengeTransactorSession struct

+ Contract *ChallengeTransactor

+ TransactOpts bind.TransactOpts

+ func (_Challenge *ChallengeTransactorSession) TimeoutChallenge() (*types.Transaction, error)

+ type ExecutionChallenge struct

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

+ func NewExecutionChallenge(address common.Address, backend bind.ContractBackend) (*ExecutionChallenge, error)

+ type ExecutionChallengeAsserterTimedOut struct

+ Raw types.Log

+ type ExecutionChallengeAsserterTimedOutIterator struct

+ Event *ExecutionChallengeAsserterTimedOut

+ func (it *ExecutionChallengeAsserterTimedOutIterator) Close() error

+ func (it *ExecutionChallengeAsserterTimedOutIterator) Error() error

+ func (it *ExecutionChallengeAsserterTimedOutIterator) Next() bool

+ type ExecutionChallengeBisectedAssertion struct

+ AssertionHashes [][32]byte

+ DeadlineTicks *big.Int

+ Raw types.Log

+ type ExecutionChallengeBisectedAssertionIterator struct

+ Event *ExecutionChallengeBisectedAssertion

+ func (it *ExecutionChallengeBisectedAssertionIterator) Close() error

+ func (it *ExecutionChallengeBisectedAssertionIterator) Error() error

+ func (it *ExecutionChallengeBisectedAssertionIterator) Next() bool

+ type ExecutionChallengeCaller struct

+ func NewExecutionChallengeCaller(address common.Address, caller bind.ContractCaller) (*ExecutionChallengeCaller, error)

+ func (_ExecutionChallenge *ExecutionChallengeCaller) IsMaster(opts *bind.CallOpts) (bool, error)

+ type ExecutionChallengeCallerRaw struct

+ Contract *ExecutionChallengeCaller

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

+ type ExecutionChallengeCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ExecutionChallengeCaller

+ func (_ExecutionChallenge *ExecutionChallengeCallerSession) IsMaster() (bool, error)

+ type ExecutionChallengeChallengerTimedOut struct

+ Raw types.Log

+ type ExecutionChallengeChallengerTimedOutIterator struct

+ Event *ExecutionChallengeChallengerTimedOut

+ func (it *ExecutionChallengeChallengerTimedOutIterator) Close() error

+ func (it *ExecutionChallengeChallengerTimedOutIterator) Error() error

+ func (it *ExecutionChallengeChallengerTimedOutIterator) Next() bool

+ type ExecutionChallengeContinued struct

+ DeadlineTicks *big.Int

+ Raw types.Log

+ SegmentIndex *big.Int

+ type ExecutionChallengeContinuedIterator struct

+ Event *ExecutionChallengeContinued

+ func (it *ExecutionChallengeContinuedIterator) Close() error

+ func (it *ExecutionChallengeContinuedIterator) Error() error

+ func (it *ExecutionChallengeContinuedIterator) Next() bool

+ type ExecutionChallengeFilterer struct

+ func NewExecutionChallengeFilterer(address common.Address, filterer bind.ContractFilterer) (*ExecutionChallengeFilterer, error)

+ func (_ExecutionChallenge *ExecutionChallengeFilterer) FilterAsserterTimedOut(opts *bind.FilterOpts) (*ExecutionChallengeAsserterTimedOutIterator, error)

+ func (_ExecutionChallenge *ExecutionChallengeFilterer) FilterBisectedAssertion(opts *bind.FilterOpts) (*ExecutionChallengeBisectedAssertionIterator, error)

+ func (_ExecutionChallenge *ExecutionChallengeFilterer) FilterChallengerTimedOut(opts *bind.FilterOpts) (*ExecutionChallengeChallengerTimedOutIterator, error)

+ func (_ExecutionChallenge *ExecutionChallengeFilterer) FilterContinued(opts *bind.FilterOpts) (*ExecutionChallengeContinuedIterator, error)

+ func (_ExecutionChallenge *ExecutionChallengeFilterer) FilterInitiatedChallenge(opts *bind.FilterOpts) (*ExecutionChallengeInitiatedChallengeIterator, error)

+ func (_ExecutionChallenge *ExecutionChallengeFilterer) FilterOneStepProofCompleted(opts *bind.FilterOpts) (*ExecutionChallengeOneStepProofCompletedIterator, error)

+ func (_ExecutionChallenge *ExecutionChallengeFilterer) ParseAsserterTimedOut(log types.Log) (*ExecutionChallengeAsserterTimedOut, error)

+ func (_ExecutionChallenge *ExecutionChallengeFilterer) ParseBisectedAssertion(log types.Log) (*ExecutionChallengeBisectedAssertion, error)

+ func (_ExecutionChallenge *ExecutionChallengeFilterer) ParseChallengerTimedOut(log types.Log) (*ExecutionChallengeChallengerTimedOut, error)

+ func (_ExecutionChallenge *ExecutionChallengeFilterer) ParseContinued(log types.Log) (*ExecutionChallengeContinued, error)

+ func (_ExecutionChallenge *ExecutionChallengeFilterer) ParseInitiatedChallenge(log types.Log) (*ExecutionChallengeInitiatedChallenge, error)

+ func (_ExecutionChallenge *ExecutionChallengeFilterer) ParseOneStepProofCompleted(log types.Log) (*ExecutionChallengeOneStepProofCompleted, error)

+ func (_ExecutionChallenge *ExecutionChallengeFilterer) WatchAsserterTimedOut(opts *bind.WatchOpts, sink chan<- *ExecutionChallengeAsserterTimedOut) (event.Subscription, error)

+ func (_ExecutionChallenge *ExecutionChallengeFilterer) WatchBisectedAssertion(opts *bind.WatchOpts, sink chan<- *ExecutionChallengeBisectedAssertion) (event.Subscription, error)

+ func (_ExecutionChallenge *ExecutionChallengeFilterer) WatchChallengerTimedOut(opts *bind.WatchOpts, sink chan<- *ExecutionChallengeChallengerTimedOut) (event.Subscription, error)

+ func (_ExecutionChallenge *ExecutionChallengeFilterer) WatchContinued(opts *bind.WatchOpts, sink chan<- *ExecutionChallengeContinued) (event.Subscription, error)

+ func (_ExecutionChallenge *ExecutionChallengeFilterer) WatchInitiatedChallenge(opts *bind.WatchOpts, sink chan<- *ExecutionChallengeInitiatedChallenge) (event.Subscription, error)

+ func (_ExecutionChallenge *ExecutionChallengeFilterer) WatchOneStepProofCompleted(opts *bind.WatchOpts, sink chan<- *ExecutionChallengeOneStepProofCompleted) (event.Subscription, error)

+ type ExecutionChallengeInitiatedChallenge struct

+ DeadlineTicks *big.Int

+ Raw types.Log

+ type ExecutionChallengeInitiatedChallengeIterator struct

+ Event *ExecutionChallengeInitiatedChallenge

+ func (it *ExecutionChallengeInitiatedChallengeIterator) Close() error

+ func (it *ExecutionChallengeInitiatedChallengeIterator) Error() error

+ func (it *ExecutionChallengeInitiatedChallengeIterator) Next() bool

+ type ExecutionChallengeOneStepProofCompleted struct

+ Raw types.Log

+ type ExecutionChallengeOneStepProofCompletedIterator struct

+ Event *ExecutionChallengeOneStepProofCompleted

+ func (it *ExecutionChallengeOneStepProofCompletedIterator) Close() error

+ func (it *ExecutionChallengeOneStepProofCompletedIterator) Error() error

+ func (it *ExecutionChallengeOneStepProofCompletedIterator) Next() bool

+ type ExecutionChallengeRaw struct

+ Contract *ExecutionChallenge

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

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

+ func (_ExecutionChallenge *ExecutionChallengeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ExecutionChallengeSession struct

+ CallOpts bind.CallOpts

+ Contract *ExecutionChallenge

+ TransactOpts bind.TransactOpts

+ func (_ExecutionChallenge *ExecutionChallengeSession) BisectAssertion(_machineHashes [][32]byte, _inboxAccs [][32]byte, _messageAccs [][32]byte, ...) (*types.Transaction, error)

+ func (_ExecutionChallenge *ExecutionChallengeSession) ChooseSegment(_segmentToChallenge *big.Int, _proof []byte, _bisectionRoot [32]byte, ...) (*types.Transaction, error)

+ func (_ExecutionChallenge *ExecutionChallengeSession) ConnectOneStepProof(oneStepProof common.Address) (*types.Transaction, error)

+ func (_ExecutionChallenge *ExecutionChallengeSession) InitializeBisection(_rollupAddress common.Address, _asserter common.Address, ...) (*types.Transaction, error)

+ func (_ExecutionChallenge *ExecutionChallengeSession) IsMaster() (bool, error)

+ func (_ExecutionChallenge *ExecutionChallengeSession) OneStepProof(_firstInbox [32]byte, _firstMessage [32]byte, _firstLog [32]byte, ...) (*types.Transaction, error)

+ func (_ExecutionChallenge *ExecutionChallengeSession) OneStepProofWithMessage(_firstInbox [32]byte, _firstMessage [32]byte, _firstLog [32]byte, ...) (*types.Transaction, error)

+ func (_ExecutionChallenge *ExecutionChallengeSession) TimeoutChallenge() (*types.Transaction, error)

+ type ExecutionChallengeTransactor struct

+ func NewExecutionChallengeTransactor(address common.Address, transactor bind.ContractTransactor) (*ExecutionChallengeTransactor, error)

+ func (_ExecutionChallenge *ExecutionChallengeTransactor) BisectAssertion(opts *bind.TransactOpts, _machineHashes [][32]byte, _inboxAccs [][32]byte, ...) (*types.Transaction, error)

+ func (_ExecutionChallenge *ExecutionChallengeTransactor) BisectAssertionCall(ctx context.Context, client ethutils.EthClient, from common.Address, ...) error

+ func (_ExecutionChallenge *ExecutionChallengeTransactor) ChooseSegment(opts *bind.TransactOpts, _segmentToChallenge *big.Int, _proof []byte, ...) (*types.Transaction, error)

+ func (_ExecutionChallenge *ExecutionChallengeTransactor) ConnectOneStepProof(opts *bind.TransactOpts, oneStepProof common.Address) (*types.Transaction, error)

+ func (_ExecutionChallenge *ExecutionChallengeTransactor) InitializeBisection(opts *bind.TransactOpts, _rollupAddress common.Address, ...) (*types.Transaction, error)

+ func (_ExecutionChallenge *ExecutionChallengeTransactor) OneStepProof(opts *bind.TransactOpts, _firstInbox [32]byte, _firstMessage [32]byte, ...) (*types.Transaction, error)

+ func (_ExecutionChallenge *ExecutionChallengeTransactor) OneStepProofCall(ctx context.Context, client ethutils.EthClient, from common.Address, ...) error

+ func (_ExecutionChallenge *ExecutionChallengeTransactor) OneStepProofInboxCall(ctx context.Context, client ethutils.EthClient, from common.Address, ...) error

+ func (_ExecutionChallenge *ExecutionChallengeTransactor) OneStepProofWithMessage(opts *bind.TransactOpts, _firstInbox [32]byte, _firstMessage [32]byte, ...) (*types.Transaction, error)

+ func (_ExecutionChallenge *ExecutionChallengeTransactor) TimeoutChallenge(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ExecutionChallengeTransactorRaw struct

+ Contract *ExecutionChallengeTransactor

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

+ func (_ExecutionChallenge *ExecutionChallengeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ExecutionChallengeTransactorSession struct

+ Contract *ExecutionChallengeTransactor

+ TransactOpts bind.TransactOpts

+ func (_ExecutionChallenge *ExecutionChallengeTransactorSession) BisectAssertion(_machineHashes [][32]byte, _inboxAccs [][32]byte, _messageAccs [][32]byte, ...) (*types.Transaction, error)

+ func (_ExecutionChallenge *ExecutionChallengeTransactorSession) ChooseSegment(_segmentToChallenge *big.Int, _proof []byte, _bisectionRoot [32]byte, ...) (*types.Transaction, error)

+ func (_ExecutionChallenge *ExecutionChallengeTransactorSession) ConnectOneStepProof(oneStepProof common.Address) (*types.Transaction, error)

+ func (_ExecutionChallenge *ExecutionChallengeTransactorSession) InitializeBisection(_rollupAddress common.Address, _asserter common.Address, ...) (*types.Transaction, error)

+ func (_ExecutionChallenge *ExecutionChallengeTransactorSession) OneStepProof(_firstInbox [32]byte, _firstMessage [32]byte, _firstLog [32]byte, ...) (*types.Transaction, error)

+ func (_ExecutionChallenge *ExecutionChallengeTransactorSession) OneStepProofWithMessage(_firstInbox [32]byte, _firstMessage [32]byte, _firstLog [32]byte, ...) (*types.Transaction, error)

+ func (_ExecutionChallenge *ExecutionChallengeTransactorSession) TimeoutChallenge() (*types.Transaction, error)

+ type GlobalEthWallet struct

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

+ func NewGlobalEthWallet(address common.Address, backend bind.ContractBackend) (*GlobalEthWallet, error)

+ type GlobalEthWalletCaller struct

+ func NewGlobalEthWalletCaller(address common.Address, caller bind.ContractCaller) (*GlobalEthWalletCaller, error)

+ func (_GlobalEthWallet *GlobalEthWalletCaller) GetEthBalance(opts *bind.CallOpts, _owner common.Address) (*big.Int, error)

+ type GlobalEthWalletCallerRaw struct

+ Contract *GlobalEthWalletCaller

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

+ type GlobalEthWalletCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *GlobalEthWalletCaller

+ func (_GlobalEthWallet *GlobalEthWalletCallerSession) GetEthBalance(_owner common.Address) (*big.Int, error)

+ type GlobalEthWalletFilterer struct

+ func NewGlobalEthWalletFilterer(address common.Address, filterer bind.ContractFilterer) (*GlobalEthWalletFilterer, error)

+ type GlobalEthWalletRaw struct

+ Contract *GlobalEthWallet

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

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

+ func (_GlobalEthWallet *GlobalEthWalletRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type GlobalEthWalletSession struct

+ CallOpts bind.CallOpts

+ Contract *GlobalEthWallet

+ TransactOpts bind.TransactOpts

+ func (_GlobalEthWallet *GlobalEthWalletSession) GetEthBalance(_owner common.Address) (*big.Int, error)

+ func (_GlobalEthWallet *GlobalEthWalletSession) WithdrawEth() (*types.Transaction, error)

+ type GlobalEthWalletTransactor struct

+ func NewGlobalEthWalletTransactor(address common.Address, transactor bind.ContractTransactor) (*GlobalEthWalletTransactor, error)

+ func (_GlobalEthWallet *GlobalEthWalletTransactor) WithdrawEth(opts *bind.TransactOpts) (*types.Transaction, error)

+ type GlobalEthWalletTransactorRaw struct

+ Contract *GlobalEthWalletTransactor

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

+ func (_GlobalEthWallet *GlobalEthWalletTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type GlobalEthWalletTransactorSession struct

+ Contract *GlobalEthWalletTransactor

+ TransactOpts bind.TransactOpts

+ func (_GlobalEthWallet *GlobalEthWalletTransactorSession) WithdrawEth() (*types.Transaction, error)

+ type GlobalFTWallet struct

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

+ func NewGlobalFTWallet(address common.Address, backend bind.ContractBackend) (*GlobalFTWallet, error)

+ type GlobalFTWalletCaller struct

+ func NewGlobalFTWalletCaller(address common.Address, caller bind.ContractCaller) (*GlobalFTWalletCaller, error)

+ func (_GlobalFTWallet *GlobalFTWalletCaller) FAILEDTRANSFER(opts *bind.CallOpts) (string, error)

+ func (_GlobalFTWallet *GlobalFTWalletCaller) GetERC20Balance(opts *bind.CallOpts, _tokenContract common.Address, _owner common.Address) (*big.Int, error)

+ func (_GlobalFTWallet *GlobalFTWalletCaller) IsPairedContract(opts *bind.CallOpts, _tokenContract common.Address, _chain common.Address) (uint8, error)

+ func (_GlobalFTWallet *GlobalFTWalletCaller) OwnedERC20s(opts *bind.CallOpts, _owner common.Address) ([]common.Address, error)

+ type GlobalFTWalletCallerRaw struct

+ Contract *GlobalFTWalletCaller

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

+ type GlobalFTWalletCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *GlobalFTWalletCaller

+ func (_GlobalFTWallet *GlobalFTWalletCallerSession) FAILEDTRANSFER() (string, error)

+ func (_GlobalFTWallet *GlobalFTWalletCallerSession) GetERC20Balance(_tokenContract common.Address, _owner common.Address) (*big.Int, error)

+ func (_GlobalFTWallet *GlobalFTWalletCallerSession) IsPairedContract(_tokenContract common.Address, _chain common.Address) (uint8, error)

+ func (_GlobalFTWallet *GlobalFTWalletCallerSession) OwnedERC20s(_owner common.Address) ([]common.Address, error)

+ type GlobalFTWalletFilterer struct

+ func NewGlobalFTWalletFilterer(address common.Address, filterer bind.ContractFilterer) (*GlobalFTWalletFilterer, error)

+ type GlobalFTWalletRaw struct

+ Contract *GlobalFTWallet

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

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

+ func (_GlobalFTWallet *GlobalFTWalletRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type GlobalFTWalletSession struct

+ CallOpts bind.CallOpts

+ Contract *GlobalFTWallet

+ TransactOpts bind.TransactOpts

+ func (_GlobalFTWallet *GlobalFTWalletSession) FAILEDTRANSFER() (string, error)

+ func (_GlobalFTWallet *GlobalFTWalletSession) GetERC20Balance(_tokenContract common.Address, _owner common.Address) (*big.Int, error)

+ func (_GlobalFTWallet *GlobalFTWalletSession) IsPairedContract(_tokenContract common.Address, _chain common.Address) (uint8, error)

+ func (_GlobalFTWallet *GlobalFTWalletSession) OwnedERC20s(_owner common.Address) ([]common.Address, error)

+ func (_GlobalFTWallet *GlobalFTWalletSession) WithdrawERC20(_tokenContract common.Address) (*types.Transaction, error)

+ type GlobalFTWalletTransactor struct

+ func NewGlobalFTWalletTransactor(address common.Address, transactor bind.ContractTransactor) (*GlobalFTWalletTransactor, error)

+ func (_GlobalFTWallet *GlobalFTWalletTransactor) WithdrawERC20(opts *bind.TransactOpts, _tokenContract common.Address) (*types.Transaction, error)

+ type GlobalFTWalletTransactorRaw struct

+ Contract *GlobalFTWalletTransactor

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

+ func (_GlobalFTWallet *GlobalFTWalletTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type GlobalFTWalletTransactorSession struct

+ Contract *GlobalFTWalletTransactor

+ TransactOpts bind.TransactOpts

+ func (_GlobalFTWallet *GlobalFTWalletTransactorSession) WithdrawERC20(_tokenContract common.Address) (*types.Transaction, error)

+ type GlobalInbox struct

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

+ func NewGlobalInbox(address common.Address, backend bind.ContractBackend) (*GlobalInbox, error)

+ type GlobalInboxBuddyContractDeployed struct

+ Data []byte

+ Raw types.Log

+ Sender common.Address

+ type GlobalInboxBuddyContractDeployedIterator struct

+ Event *GlobalInboxBuddyContractDeployed

+ func (it *GlobalInboxBuddyContractDeployedIterator) Close() error

+ func (it *GlobalInboxBuddyContractDeployedIterator) Error() error

+ func (it *GlobalInboxBuddyContractDeployedIterator) Next() bool

+ type GlobalInboxBuddyContractPair struct

+ Data common.Address

+ Raw types.Log

+ Sender common.Address

+ type GlobalInboxBuddyContractPairIterator struct

+ Event *GlobalInboxBuddyContractPair

+ func (it *GlobalInboxBuddyContractPairIterator) Close() error

+ func (it *GlobalInboxBuddyContractPairIterator) Error() error

+ func (it *GlobalInboxBuddyContractPairIterator) Next() bool

+ type GlobalInboxCaller struct

+ func NewGlobalInboxCaller(address common.Address, caller bind.ContractCaller) (*GlobalInboxCaller, error)

+ func (_GlobalInbox *GlobalInboxCaller) FAILEDTRANSFER(opts *bind.CallOpts) (string, error)

+ func (_GlobalInbox *GlobalInboxCaller) GetERC20Balance(opts *bind.CallOpts, _tokenContract common.Address, _owner common.Address) (*big.Int, error)

+ func (_GlobalInbox *GlobalInboxCaller) GetERC721Tokens(opts *bind.CallOpts, _erc721 common.Address, _owner common.Address) ([]*big.Int, error)

+ func (_GlobalInbox *GlobalInboxCaller) GetEthBalance(opts *bind.CallOpts, _owner common.Address) (*big.Int, error)

+ func (_GlobalInbox *GlobalInboxCaller) GetInbox(opts *bind.CallOpts, account common.Address) ([32]byte, *big.Int, error)

+ func (_GlobalInbox *GlobalInboxCaller) GetPaymentOwner(opts *bind.CallOpts, originalOwner common.Address, messageIndex *big.Int) (common.Address, error)

+ func (_GlobalInbox *GlobalInboxCaller) HasERC721(opts *bind.CallOpts, _erc721 common.Address, _owner common.Address, ...) (bool, error)

+ func (_GlobalInbox *GlobalInboxCaller) IsPairedContract(opts *bind.CallOpts, _tokenContract common.Address, _chain common.Address) (uint8, error)

+ func (_GlobalInbox *GlobalInboxCaller) OwnedERC20s(opts *bind.CallOpts, _owner common.Address) ([]common.Address, error)

+ func (_GlobalInbox *GlobalInboxCaller) OwnedERC721s(opts *bind.CallOpts, _owner common.Address) ([]common.Address, error)

+ type GlobalInboxCallerRaw struct

+ Contract *GlobalInboxCaller

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

+ type GlobalInboxCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *GlobalInboxCaller

+ func (_GlobalInbox *GlobalInboxCallerSession) FAILEDTRANSFER() (string, error)

+ func (_GlobalInbox *GlobalInboxCallerSession) GetERC20Balance(_tokenContract common.Address, _owner common.Address) (*big.Int, error)

+ func (_GlobalInbox *GlobalInboxCallerSession) GetERC721Tokens(_erc721 common.Address, _owner common.Address) ([]*big.Int, error)

+ func (_GlobalInbox *GlobalInboxCallerSession) GetEthBalance(_owner common.Address) (*big.Int, error)

+ func (_GlobalInbox *GlobalInboxCallerSession) GetInbox(account common.Address) ([32]byte, *big.Int, error)

+ func (_GlobalInbox *GlobalInboxCallerSession) GetPaymentOwner(originalOwner common.Address, messageIndex *big.Int) (common.Address, error)

+ func (_GlobalInbox *GlobalInboxCallerSession) HasERC721(_erc721 common.Address, _owner common.Address, _tokenId *big.Int) (bool, error)

+ func (_GlobalInbox *GlobalInboxCallerSession) IsPairedContract(_tokenContract common.Address, _chain common.Address) (uint8, error)

+ func (_GlobalInbox *GlobalInboxCallerSession) OwnedERC20s(_owner common.Address) ([]common.Address, error)

+ func (_GlobalInbox *GlobalInboxCallerSession) OwnedERC721s(_owner common.Address) ([]common.Address, error)

+ type GlobalInboxFilterer struct

+ func NewGlobalInboxFilterer(address common.Address, filterer bind.ContractFilterer) (*GlobalInboxFilterer, error)

+ func (_GlobalInbox *GlobalInboxFilterer) FilterBuddyContractDeployed(opts *bind.FilterOpts, sender []common.Address) (*GlobalInboxBuddyContractDeployedIterator, error)

+ func (_GlobalInbox *GlobalInboxFilterer) FilterBuddyContractPair(opts *bind.FilterOpts, sender []common.Address) (*GlobalInboxBuddyContractPairIterator, error)

+ func (_GlobalInbox *GlobalInboxFilterer) FilterMessageDelivered(opts *bind.FilterOpts, chain []common.Address, kind []uint8, ...) (*GlobalInboxMessageDeliveredIterator, error)

+ func (_GlobalInbox *GlobalInboxFilterer) FilterMessageDeliveredFromOrigin(opts *bind.FilterOpts, chain []common.Address, kind []uint8, ...) (*GlobalInboxMessageDeliveredFromOriginIterator, error)

+ func (_GlobalInbox *GlobalInboxFilterer) FilterPaymentTransfer(opts *bind.FilterOpts) (*GlobalInboxPaymentTransferIterator, error)

+ func (_GlobalInbox *GlobalInboxFilterer) ParseBuddyContractDeployed(log types.Log) (*GlobalInboxBuddyContractDeployed, error)

+ func (_GlobalInbox *GlobalInboxFilterer) ParseBuddyContractPair(log types.Log) (*GlobalInboxBuddyContractPair, error)

+ func (_GlobalInbox *GlobalInboxFilterer) ParseMessageDelivered(log types.Log) (*GlobalInboxMessageDelivered, error)

+ func (_GlobalInbox *GlobalInboxFilterer) ParseMessageDeliveredFromOrigin(log types.Log) (*GlobalInboxMessageDeliveredFromOrigin, error)

+ func (_GlobalInbox *GlobalInboxFilterer) ParsePaymentTransfer(log types.Log) (*GlobalInboxPaymentTransfer, error)

+ func (_GlobalInbox *GlobalInboxFilterer) WatchBuddyContractDeployed(opts *bind.WatchOpts, sink chan<- *GlobalInboxBuddyContractDeployed, ...) (event.Subscription, error)

+ func (_GlobalInbox *GlobalInboxFilterer) WatchBuddyContractPair(opts *bind.WatchOpts, sink chan<- *GlobalInboxBuddyContractPair, ...) (event.Subscription, error)

+ func (_GlobalInbox *GlobalInboxFilterer) WatchMessageDelivered(opts *bind.WatchOpts, sink chan<- *GlobalInboxMessageDelivered, ...) (event.Subscription, error)

+ func (_GlobalInbox *GlobalInboxFilterer) WatchMessageDeliveredFromOrigin(opts *bind.WatchOpts, sink chan<- *GlobalInboxMessageDeliveredFromOrigin, ...) (event.Subscription, error)

+ func (_GlobalInbox *GlobalInboxFilterer) WatchPaymentTransfer(opts *bind.WatchOpts, sink chan<- *GlobalInboxPaymentTransfer) (event.Subscription, error)

+ type GlobalInboxMessageDelivered struct

+ Chain common.Address

+ Data []byte

+ InboxSeqNum *big.Int

+ Kind uint8

+ Raw types.Log

+ Sender common.Address

+ type GlobalInboxMessageDeliveredFromOrigin struct

+ Chain common.Address

+ InboxSeqNum *big.Int

+ Kind uint8

+ Raw types.Log

+ Sender common.Address

+ type GlobalInboxMessageDeliveredFromOriginIterator struct

+ Event *GlobalInboxMessageDeliveredFromOrigin

+ func (it *GlobalInboxMessageDeliveredFromOriginIterator) Close() error

+ func (it *GlobalInboxMessageDeliveredFromOriginIterator) Error() error

+ func (it *GlobalInboxMessageDeliveredFromOriginIterator) Next() bool

+ type GlobalInboxMessageDeliveredIterator struct

+ Event *GlobalInboxMessageDelivered

+ func (it *GlobalInboxMessageDeliveredIterator) Close() error

+ func (it *GlobalInboxMessageDeliveredIterator) Error() error

+ func (it *GlobalInboxMessageDeliveredIterator) Next() bool

+ type GlobalInboxPaymentTransfer struct

+ MessageIndex *big.Int

+ NewOwner common.Address

+ OriginalOwner common.Address

+ PrevOwner common.Address

+ Raw types.Log

+ type GlobalInboxPaymentTransferIterator struct

+ Event *GlobalInboxPaymentTransfer

+ func (it *GlobalInboxPaymentTransferIterator) Close() error

+ func (it *GlobalInboxPaymentTransferIterator) Error() error

+ func (it *GlobalInboxPaymentTransferIterator) Next() bool

+ type GlobalInboxRaw struct

+ Contract *GlobalInbox

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

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

+ func (_GlobalInbox *GlobalInboxRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type GlobalInboxSession struct

+ CallOpts bind.CallOpts

+ Contract *GlobalInbox

+ TransactOpts bind.TransactOpts

+ func (_GlobalInbox *GlobalInboxSession) DeployL2ContractPair(chain common.Address, maxGas *big.Int, gasPriceBid *big.Int, payment *big.Int, ...) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxSession) DepositERC20Message(chain common.Address, erc20 common.Address, to common.Address, value *big.Int) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxSession) DepositERC721Message(chain common.Address, erc721 common.Address, to common.Address, id *big.Int) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxSession) DepositEthMessage(chain common.Address, to common.Address) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxSession) FAILEDTRANSFER() (string, error)

+ func (_GlobalInbox *GlobalInboxSession) GetERC20Balance(_tokenContract common.Address, _owner common.Address) (*big.Int, error)

+ func (_GlobalInbox *GlobalInboxSession) GetERC721Tokens(_erc721 common.Address, _owner common.Address) ([]*big.Int, error)

+ func (_GlobalInbox *GlobalInboxSession) GetEthBalance(_owner common.Address) (*big.Int, error)

+ func (_GlobalInbox *GlobalInboxSession) GetInbox(account common.Address) ([32]byte, *big.Int, error)

+ func (_GlobalInbox *GlobalInboxSession) GetPaymentOwner(originalOwner common.Address, messageIndex *big.Int) (common.Address, error)

+ func (_GlobalInbox *GlobalInboxSession) HasERC721(_erc721 common.Address, _owner common.Address, _tokenId *big.Int) (bool, error)

+ func (_GlobalInbox *GlobalInboxSession) IsPairedContract(_tokenContract common.Address, _chain common.Address) (uint8, error)

+ func (_GlobalInbox *GlobalInboxSession) OwnedERC20s(_owner common.Address) ([]common.Address, error)

+ func (_GlobalInbox *GlobalInboxSession) OwnedERC721s(_owner common.Address) ([]common.Address, error)

+ func (_GlobalInbox *GlobalInboxSession) SendInitializationMessage(messageData []byte) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxSession) SendL2Message(chain common.Address, messageData []byte) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxSession) SendL2MessageFromOrigin(chain common.Address, messageData []byte) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxSession) SendMessages(messages []byte, initialMaxSendCount *big.Int, finalMaxSendCount *big.Int) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxSession) TransferPayment(originalOwner common.Address, newOwner common.Address, messageIndex *big.Int) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxSession) WithdrawERC20(_tokenContract common.Address) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxSession) WithdrawERC721(_erc721 common.Address, _tokenId *big.Int) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxSession) WithdrawEth() (*types.Transaction, error)

+ type GlobalInboxTransactor struct

+ func NewGlobalInboxTransactor(address common.Address, transactor bind.ContractTransactor) (*GlobalInboxTransactor, error)

+ func (_GlobalInbox *GlobalInboxTransactor) DeployL2ContractPair(opts *bind.TransactOpts, chain common.Address, maxGas *big.Int, ...) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactor) DepositERC20Message(opts *bind.TransactOpts, chain common.Address, erc20 common.Address, ...) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactor) DepositERC721Message(opts *bind.TransactOpts, chain common.Address, erc721 common.Address, ...) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactor) DepositEthMessage(opts *bind.TransactOpts, chain common.Address, to common.Address) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactor) SendInitializationMessage(opts *bind.TransactOpts, messageData []byte) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactor) SendL2Message(opts *bind.TransactOpts, chain common.Address, messageData []byte) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactor) SendL2MessageFromOrigin(opts *bind.TransactOpts, chain common.Address, messageData []byte) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactor) SendMessages(opts *bind.TransactOpts, messages []byte, initialMaxSendCount *big.Int, ...) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactor) TransferPayment(opts *bind.TransactOpts, originalOwner common.Address, newOwner common.Address, ...) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactor) WithdrawERC20(opts *bind.TransactOpts, _tokenContract common.Address) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactor) WithdrawERC721(opts *bind.TransactOpts, _erc721 common.Address, _tokenId *big.Int) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactor) WithdrawEth(opts *bind.TransactOpts) (*types.Transaction, error)

+ type GlobalInboxTransactorRaw struct

+ Contract *GlobalInboxTransactor

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

+ func (_GlobalInbox *GlobalInboxTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type GlobalInboxTransactorSession struct

+ Contract *GlobalInboxTransactor

+ TransactOpts bind.TransactOpts

+ func (_GlobalInbox *GlobalInboxTransactorSession) DeployL2ContractPair(chain common.Address, maxGas *big.Int, gasPriceBid *big.Int, payment *big.Int, ...) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactorSession) DepositERC20Message(chain common.Address, erc20 common.Address, to common.Address, value *big.Int) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactorSession) DepositERC721Message(chain common.Address, erc721 common.Address, to common.Address, id *big.Int) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactorSession) DepositEthMessage(chain common.Address, to common.Address) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactorSession) SendInitializationMessage(messageData []byte) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactorSession) SendL2Message(chain common.Address, messageData []byte) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactorSession) SendL2MessageFromOrigin(chain common.Address, messageData []byte) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactorSession) SendMessages(messages []byte, initialMaxSendCount *big.Int, finalMaxSendCount *big.Int) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactorSession) TransferPayment(originalOwner common.Address, newOwner common.Address, messageIndex *big.Int) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactorSession) WithdrawERC20(_tokenContract common.Address) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactorSession) WithdrawERC721(_erc721 common.Address, _tokenId *big.Int) (*types.Transaction, error)

+ func (_GlobalInbox *GlobalInboxTransactorSession) WithdrawEth() (*types.Transaction, error)

+ type GlobalNFTWallet struct

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

+ func NewGlobalNFTWallet(address common.Address, backend bind.ContractBackend) (*GlobalNFTWallet, error)

+ type GlobalNFTWalletCaller struct

+ func NewGlobalNFTWalletCaller(address common.Address, caller bind.ContractCaller) (*GlobalNFTWalletCaller, error)

+ func (_GlobalNFTWallet *GlobalNFTWalletCaller) GetERC721Tokens(opts *bind.CallOpts, _erc721 common.Address, _owner common.Address) ([]*big.Int, error)

+ func (_GlobalNFTWallet *GlobalNFTWalletCaller) HasERC721(opts *bind.CallOpts, _erc721 common.Address, _owner common.Address, ...) (bool, error)

+ func (_GlobalNFTWallet *GlobalNFTWalletCaller) OwnedERC721s(opts *bind.CallOpts, _owner common.Address) ([]common.Address, error)

+ type GlobalNFTWalletCallerRaw struct

+ Contract *GlobalNFTWalletCaller

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

+ type GlobalNFTWalletCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *GlobalNFTWalletCaller

+ func (_GlobalNFTWallet *GlobalNFTWalletCallerSession) GetERC721Tokens(_erc721 common.Address, _owner common.Address) ([]*big.Int, error)

+ func (_GlobalNFTWallet *GlobalNFTWalletCallerSession) HasERC721(_erc721 common.Address, _owner common.Address, _tokenId *big.Int) (bool, error)

+ func (_GlobalNFTWallet *GlobalNFTWalletCallerSession) OwnedERC721s(_owner common.Address) ([]common.Address, error)

+ type GlobalNFTWalletFilterer struct

+ func NewGlobalNFTWalletFilterer(address common.Address, filterer bind.ContractFilterer) (*GlobalNFTWalletFilterer, error)

+ type GlobalNFTWalletRaw struct

+ Contract *GlobalNFTWallet

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

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

+ func (_GlobalNFTWallet *GlobalNFTWalletRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type GlobalNFTWalletSession struct

+ CallOpts bind.CallOpts

+ Contract *GlobalNFTWallet

+ TransactOpts bind.TransactOpts

+ func (_GlobalNFTWallet *GlobalNFTWalletSession) GetERC721Tokens(_erc721 common.Address, _owner common.Address) ([]*big.Int, error)

+ func (_GlobalNFTWallet *GlobalNFTWalletSession) HasERC721(_erc721 common.Address, _owner common.Address, _tokenId *big.Int) (bool, error)

+ func (_GlobalNFTWallet *GlobalNFTWalletSession) OwnedERC721s(_owner common.Address) ([]common.Address, error)

+ func (_GlobalNFTWallet *GlobalNFTWalletSession) WithdrawERC721(_erc721 common.Address, _tokenId *big.Int) (*types.Transaction, error)

+ type GlobalNFTWalletTransactor struct

+ func NewGlobalNFTWalletTransactor(address common.Address, transactor bind.ContractTransactor) (*GlobalNFTWalletTransactor, error)

+ func (_GlobalNFTWallet *GlobalNFTWalletTransactor) WithdrawERC721(opts *bind.TransactOpts, _erc721 common.Address, _tokenId *big.Int) (*types.Transaction, error)

+ type GlobalNFTWalletTransactorRaw struct

+ Contract *GlobalNFTWalletTransactor

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

+ func (_GlobalNFTWallet *GlobalNFTWalletTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type GlobalNFTWalletTransactorSession struct

+ Contract *GlobalNFTWalletTransactor

+ TransactOpts bind.TransactOpts

+ func (_GlobalNFTWallet *GlobalNFTWalletTransactorSession) WithdrawERC721(_erc721 common.Address, _tokenId *big.Int) (*types.Transaction, error)

+ type IERC165 struct

+ func NewIERC165(address common.Address, backend bind.ContractBackend) (*IERC165, error)

+ type IERC165Caller struct

+ func NewIERC165Caller(address common.Address, caller bind.ContractCaller) (*IERC165Caller, error)

+ func (_IERC165 *IERC165Caller) SupportsInterface(opts *bind.CallOpts, interfaceID [4]byte) (bool, error)

+ type IERC165CallerRaw struct

+ Contract *IERC165Caller

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

+ type IERC165CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC165Caller

+ func (_IERC165 *IERC165CallerSession) SupportsInterface(interfaceID [4]byte) (bool, error)

+ type IERC165Filterer struct

+ func NewIERC165Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC165Filterer, error)

+ type IERC165Raw struct

+ Contract *IERC165

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

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

+ func (_IERC165 *IERC165Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC165Session struct

+ CallOpts bind.CallOpts

+ Contract *IERC165

+ TransactOpts bind.TransactOpts

+ func (_IERC165 *IERC165Session) SupportsInterface(interfaceID [4]byte) (bool, error)

+ type IERC165Transactor struct

+ func NewIERC165Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC165Transactor, error)

+ type IERC165TransactorRaw struct

+ Contract *IERC165Transactor

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

+ func (_IERC165 *IERC165TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC165TransactorSession struct

+ Contract *IERC165Transactor

+ TransactOpts bind.TransactOpts

+ type IERC20 struct

+ func NewIERC20(address common.Address, backend bind.ContractBackend) (*IERC20, error)

+ type IERC20Approval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type IERC20ApprovalIterator struct

+ Event *IERC20Approval

+ func (it *IERC20ApprovalIterator) Close() error

+ func (it *IERC20ApprovalIterator) Error() error

+ func (it *IERC20ApprovalIterator) Next() bool

+ type IERC20Caller struct

+ func NewIERC20Caller(address common.Address, caller bind.ContractCaller) (*IERC20Caller, error)

+ func (_IERC20 *IERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error)

+ func (_IERC20 *IERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error)

+ func (_IERC20 *IERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type IERC20CallerRaw struct

+ Contract *IERC20Caller

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

+ type IERC20CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC20Caller

+ func (_IERC20 *IERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_IERC20 *IERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_IERC20 *IERC20CallerSession) TotalSupply() (*big.Int, error)

+ type IERC20Filterer struct

+ func NewIERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC20Filterer, error)

+ func (_IERC20 *IERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*IERC20ApprovalIterator, error)

+ func (_IERC20 *IERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*IERC20TransferIterator, error)

+ func (_IERC20 *IERC20Filterer) ParseApproval(log types.Log) (*IERC20Approval, error)

+ func (_IERC20 *IERC20Filterer) ParseTransfer(log types.Log) (*IERC20Transfer, error)

+ func (_IERC20 *IERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC20Approval, owner []common.Address, ...) (event.Subscription, error)

+ func (_IERC20 *IERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC20Transfer, from []common.Address, ...) (event.Subscription, error)

+ type IERC20Raw struct

+ Contract *IERC20

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

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

+ func (_IERC20 *IERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC20Session struct

+ CallOpts bind.CallOpts

+ Contract *IERC20

+ TransactOpts bind.TransactOpts

+ func (_IERC20 *IERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_IERC20 *IERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20Session) BalanceOf(account common.Address) (*big.Int, error)

+ func (_IERC20 *IERC20Session) TotalSupply() (*big.Int, error)

+ func (_IERC20 *IERC20Session) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20Session) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ type IERC20Transactor struct

+ func NewIERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC20Transactor, error)

+ func (_IERC20 *IERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20Transactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20Transactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, ...) (*types.Transaction, error)

+ type IERC20TransactorRaw struct

+ Contract *IERC20Transactor

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

+ func (_IERC20 *IERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC20TransactorSession struct

+ Contract *IERC20Transactor

+ TransactOpts bind.TransactOpts

+ func (_IERC20 *IERC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20TransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20TransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ type IERC20Transfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type IERC20TransferIterator struct

+ Event *IERC20Transfer

+ func (it *IERC20TransferIterator) Close() error

+ func (it *IERC20TransferIterator) Error() error

+ func (it *IERC20TransferIterator) Next() bool

+ type IERC721 struct

+ func NewIERC721(address common.Address, backend bind.ContractBackend) (*IERC721, error)

+ type IERC721Approval struct

+ Approved common.Address

+ Owner common.Address

+ Raw types.Log

+ TokenId *big.Int

+ type IERC721ApprovalForAll struct

+ Approved bool

+ Operator common.Address

+ Owner common.Address

+ Raw types.Log

+ type IERC721ApprovalForAllIterator struct

+ Event *IERC721ApprovalForAll

+ func (it *IERC721ApprovalForAllIterator) Close() error

+ func (it *IERC721ApprovalForAllIterator) Error() error

+ func (it *IERC721ApprovalForAllIterator) Next() bool

+ type IERC721ApprovalIterator struct

+ Event *IERC721Approval

+ func (it *IERC721ApprovalIterator) Close() error

+ func (it *IERC721ApprovalIterator) Error() error

+ func (it *IERC721ApprovalIterator) Next() bool

+ type IERC721Caller struct

+ func NewIERC721Caller(address common.Address, caller bind.ContractCaller) (*IERC721Caller, error)

+ func (_IERC721 *IERC721Caller) BalanceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error)

+ func (_IERC721 *IERC721Caller) GetApproved(opts *bind.CallOpts, _tokenId *big.Int) (common.Address, error)

+ func (_IERC721 *IERC721Caller) IsApprovedForAll(opts *bind.CallOpts, _owner common.Address, _operator common.Address) (bool, error)

+ func (_IERC721 *IERC721Caller) OwnerOf(opts *bind.CallOpts, _tokenId *big.Int) (common.Address, error)

+ type IERC721CallerRaw struct

+ Contract *IERC721Caller

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

+ type IERC721CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC721Caller

+ func (_IERC721 *IERC721CallerSession) BalanceOf(_owner common.Address) (*big.Int, error)

+ func (_IERC721 *IERC721CallerSession) GetApproved(_tokenId *big.Int) (common.Address, error)

+ func (_IERC721 *IERC721CallerSession) IsApprovedForAll(_owner common.Address, _operator common.Address) (bool, error)

+ func (_IERC721 *IERC721CallerSession) OwnerOf(_tokenId *big.Int) (common.Address, error)

+ type IERC721Filterer struct

+ func NewIERC721Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC721Filterer, error)

+ func (_IERC721 *IERC721Filterer) FilterApproval(opts *bind.FilterOpts, _owner []common.Address, _approved []common.Address, ...) (*IERC721ApprovalIterator, error)

+ func (_IERC721 *IERC721Filterer) FilterApprovalForAll(opts *bind.FilterOpts, _owner []common.Address, _operator []common.Address) (*IERC721ApprovalForAllIterator, error)

+ func (_IERC721 *IERC721Filterer) FilterTransfer(opts *bind.FilterOpts, _from []common.Address, _to []common.Address, ...) (*IERC721TransferIterator, error)

+ func (_IERC721 *IERC721Filterer) ParseApproval(log types.Log) (*IERC721Approval, error)

+ func (_IERC721 *IERC721Filterer) ParseApprovalForAll(log types.Log) (*IERC721ApprovalForAll, error)

+ func (_IERC721 *IERC721Filterer) ParseTransfer(log types.Log) (*IERC721Transfer, error)

+ func (_IERC721 *IERC721Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC721Approval, _owner []common.Address, ...) (event.Subscription, error)

+ func (_IERC721 *IERC721Filterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *IERC721ApprovalForAll, ...) (event.Subscription, error)

+ func (_IERC721 *IERC721Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC721Transfer, _from []common.Address, ...) (event.Subscription, error)

+ type IERC721Raw struct

+ Contract *IERC721

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

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

+ func (_IERC721 *IERC721Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC721Session struct

+ CallOpts bind.CallOpts

+ Contract *IERC721

+ TransactOpts bind.TransactOpts

+ func (_IERC721 *IERC721Session) Approve(_approved common.Address, _tokenId *big.Int) (*types.Transaction, error)

+ func (_IERC721 *IERC721Session) BalanceOf(_owner common.Address) (*big.Int, error)

+ func (_IERC721 *IERC721Session) GetApproved(_tokenId *big.Int) (common.Address, error)

+ func (_IERC721 *IERC721Session) IsApprovedForAll(_owner common.Address, _operator common.Address) (bool, error)

+ func (_IERC721 *IERC721Session) OwnerOf(_tokenId *big.Int) (common.Address, error)

+ func (_IERC721 *IERC721Session) SafeTransferFrom(_from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error)

+ func (_IERC721 *IERC721Session) SafeTransferFrom0(_from common.Address, _to common.Address, _tokenId *big.Int, data []byte) (*types.Transaction, error)

+ func (_IERC721 *IERC721Session) SetApprovalForAll(_operator common.Address, _approved bool) (*types.Transaction, error)

+ func (_IERC721 *IERC721Session) TransferFrom(_from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error)

+ type IERC721Transactor struct

+ func NewIERC721Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC721Transactor, error)

+ func (_IERC721 *IERC721Transactor) Approve(opts *bind.TransactOpts, _approved common.Address, _tokenId *big.Int) (*types.Transaction, error)

+ func (_IERC721 *IERC721Transactor) SafeTransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_IERC721 *IERC721Transactor) SafeTransferFrom0(opts *bind.TransactOpts, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_IERC721 *IERC721Transactor) SetApprovalForAll(opts *bind.TransactOpts, _operator common.Address, _approved bool) (*types.Transaction, error)

+ func (_IERC721 *IERC721Transactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ type IERC721TransactorRaw struct

+ Contract *IERC721Transactor

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

+ func (_IERC721 *IERC721TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC721TransactorSession struct

+ Contract *IERC721Transactor

+ TransactOpts bind.TransactOpts

+ func (_IERC721 *IERC721TransactorSession) Approve(_approved common.Address, _tokenId *big.Int) (*types.Transaction, error)

+ func (_IERC721 *IERC721TransactorSession) SafeTransferFrom(_from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error)

+ func (_IERC721 *IERC721TransactorSession) SafeTransferFrom0(_from common.Address, _to common.Address, _tokenId *big.Int, data []byte) (*types.Transaction, error)

+ func (_IERC721 *IERC721TransactorSession) SetApprovalForAll(_operator common.Address, _approved bool) (*types.Transaction, error)

+ func (_IERC721 *IERC721TransactorSession) TransferFrom(_from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error)

+ type IERC721Transfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ TokenId *big.Int

+ type IERC721TransferIterator struct

+ Event *IERC721Transfer

+ func (it *IERC721TransferIterator) Close() error

+ func (it *IERC721TransferIterator) Error() error

+ func (it *IERC721TransferIterator) Next() bool

+ type IPairedErc20 struct

+ func NewIPairedErc20(address common.Address, backend bind.ContractBackend) (*IPairedErc20, error)

+ type IPairedErc20Caller struct

+ func NewIPairedErc20Caller(address common.Address, caller bind.ContractCaller) (*IPairedErc20Caller, error)

+ func (_IPairedErc20 *IPairedErc20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error)

+ type IPairedErc20CallerRaw struct

+ Contract *IPairedErc20Caller

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

+ type IPairedErc20CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IPairedErc20Caller

+ func (_IPairedErc20 *IPairedErc20CallerSession) BalanceOf(account common.Address) (*big.Int, error)

+ type IPairedErc20Filterer struct

+ func NewIPairedErc20Filterer(address common.Address, filterer bind.ContractFilterer) (*IPairedErc20Filterer, error)

+ type IPairedErc20Raw struct

+ Contract *IPairedErc20

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

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

+ func (_IPairedErc20 *IPairedErc20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IPairedErc20Session struct

+ CallOpts bind.CallOpts

+ Contract *IPairedErc20

+ TransactOpts bind.TransactOpts

+ func (_IPairedErc20 *IPairedErc20Session) BalanceOf(account common.Address) (*big.Int, error)

+ func (_IPairedErc20 *IPairedErc20Session) Burn(account common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IPairedErc20 *IPairedErc20Session) Mint(account common.Address, amount *big.Int) (*types.Transaction, error)

+ type IPairedErc20Transactor struct

+ func NewIPairedErc20Transactor(address common.Address, transactor bind.ContractTransactor) (*IPairedErc20Transactor, error)

+ func (_IPairedErc20 *IPairedErc20Transactor) Burn(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IPairedErc20 *IPairedErc20Transactor) Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error)

+ type IPairedErc20TransactorRaw struct

+ Contract *IPairedErc20Transactor

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

+ func (_IPairedErc20 *IPairedErc20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IPairedErc20TransactorSession struct

+ Contract *IPairedErc20Transactor

+ TransactOpts bind.TransactOpts

+ func (_IPairedErc20 *IPairedErc20TransactorSession) Burn(account common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IPairedErc20 *IPairedErc20TransactorSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error)

+ type InboxTopChallenge struct

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

+ func NewInboxTopChallenge(address common.Address, backend bind.ContractBackend) (*InboxTopChallenge, error)

+ type InboxTopChallengeAsserterTimedOut struct

+ Raw types.Log

+ type InboxTopChallengeAsserterTimedOutIterator struct

+ Event *InboxTopChallengeAsserterTimedOut

+ func (it *InboxTopChallengeAsserterTimedOutIterator) Close() error

+ func (it *InboxTopChallengeAsserterTimedOutIterator) Error() error

+ func (it *InboxTopChallengeAsserterTimedOutIterator) Next() bool

+ type InboxTopChallengeBisected struct

+ ChainHashes [][32]byte

+ DeadlineTicks *big.Int

+ Raw types.Log

+ TotalLength *big.Int

+ type InboxTopChallengeBisectedIterator struct

+ Event *InboxTopChallengeBisected

+ func (it *InboxTopChallengeBisectedIterator) Close() error

+ func (it *InboxTopChallengeBisectedIterator) Error() error

+ func (it *InboxTopChallengeBisectedIterator) Next() bool

+ type InboxTopChallengeCaller struct

+ func NewInboxTopChallengeCaller(address common.Address, caller bind.ContractCaller) (*InboxTopChallengeCaller, error)

+ func (_InboxTopChallenge *InboxTopChallengeCaller) IsMaster(opts *bind.CallOpts) (bool, error)

+ type InboxTopChallengeCallerRaw struct

+ Contract *InboxTopChallengeCaller

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

+ type InboxTopChallengeCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *InboxTopChallengeCaller

+ func (_InboxTopChallenge *InboxTopChallengeCallerSession) IsMaster() (bool, error)

+ type InboxTopChallengeChallengerTimedOut struct

+ Raw types.Log

+ type InboxTopChallengeChallengerTimedOutIterator struct

+ Event *InboxTopChallengeChallengerTimedOut

+ func (it *InboxTopChallengeChallengerTimedOutIterator) Close() error

+ func (it *InboxTopChallengeChallengerTimedOutIterator) Error() error

+ func (it *InboxTopChallengeChallengerTimedOutIterator) Next() bool

+ type InboxTopChallengeContinued struct

+ DeadlineTicks *big.Int

+ Raw types.Log

+ SegmentIndex *big.Int

+ type InboxTopChallengeContinuedIterator struct

+ Event *InboxTopChallengeContinued

+ func (it *InboxTopChallengeContinuedIterator) Close() error

+ func (it *InboxTopChallengeContinuedIterator) Error() error

+ func (it *InboxTopChallengeContinuedIterator) Next() bool

+ type InboxTopChallengeFilterer struct

+ func NewInboxTopChallengeFilterer(address common.Address, filterer bind.ContractFilterer) (*InboxTopChallengeFilterer, error)

+ func (_InboxTopChallenge *InboxTopChallengeFilterer) FilterAsserterTimedOut(opts *bind.FilterOpts) (*InboxTopChallengeAsserterTimedOutIterator, error)

+ func (_InboxTopChallenge *InboxTopChallengeFilterer) FilterBisected(opts *bind.FilterOpts) (*InboxTopChallengeBisectedIterator, error)

+ func (_InboxTopChallenge *InboxTopChallengeFilterer) FilterChallengerTimedOut(opts *bind.FilterOpts) (*InboxTopChallengeChallengerTimedOutIterator, error)

+ func (_InboxTopChallenge *InboxTopChallengeFilterer) FilterContinued(opts *bind.FilterOpts) (*InboxTopChallengeContinuedIterator, error)

+ func (_InboxTopChallenge *InboxTopChallengeFilterer) FilterInitiatedChallenge(opts *bind.FilterOpts) (*InboxTopChallengeInitiatedChallengeIterator, error)

+ func (_InboxTopChallenge *InboxTopChallengeFilterer) FilterOneStepProofCompleted(opts *bind.FilterOpts) (*InboxTopChallengeOneStepProofCompletedIterator, error)

+ func (_InboxTopChallenge *InboxTopChallengeFilterer) ParseAsserterTimedOut(log types.Log) (*InboxTopChallengeAsserterTimedOut, error)

+ func (_InboxTopChallenge *InboxTopChallengeFilterer) ParseBisected(log types.Log) (*InboxTopChallengeBisected, error)

+ func (_InboxTopChallenge *InboxTopChallengeFilterer) ParseChallengerTimedOut(log types.Log) (*InboxTopChallengeChallengerTimedOut, error)

+ func (_InboxTopChallenge *InboxTopChallengeFilterer) ParseContinued(log types.Log) (*InboxTopChallengeContinued, error)

+ func (_InboxTopChallenge *InboxTopChallengeFilterer) ParseInitiatedChallenge(log types.Log) (*InboxTopChallengeInitiatedChallenge, error)

+ func (_InboxTopChallenge *InboxTopChallengeFilterer) ParseOneStepProofCompleted(log types.Log) (*InboxTopChallengeOneStepProofCompleted, error)

+ func (_InboxTopChallenge *InboxTopChallengeFilterer) WatchAsserterTimedOut(opts *bind.WatchOpts, sink chan<- *InboxTopChallengeAsserterTimedOut) (event.Subscription, error)

+ func (_InboxTopChallenge *InboxTopChallengeFilterer) WatchBisected(opts *bind.WatchOpts, sink chan<- *InboxTopChallengeBisected) (event.Subscription, error)

+ func (_InboxTopChallenge *InboxTopChallengeFilterer) WatchChallengerTimedOut(opts *bind.WatchOpts, sink chan<- *InboxTopChallengeChallengerTimedOut) (event.Subscription, error)

+ func (_InboxTopChallenge *InboxTopChallengeFilterer) WatchContinued(opts *bind.WatchOpts, sink chan<- *InboxTopChallengeContinued) (event.Subscription, error)

+ func (_InboxTopChallenge *InboxTopChallengeFilterer) WatchInitiatedChallenge(opts *bind.WatchOpts, sink chan<- *InboxTopChallengeInitiatedChallenge) (event.Subscription, error)

+ func (_InboxTopChallenge *InboxTopChallengeFilterer) WatchOneStepProofCompleted(opts *bind.WatchOpts, sink chan<- *InboxTopChallengeOneStepProofCompleted) (event.Subscription, error)

+ type InboxTopChallengeInitiatedChallenge struct

+ DeadlineTicks *big.Int

+ Raw types.Log

+ type InboxTopChallengeInitiatedChallengeIterator struct

+ Event *InboxTopChallengeInitiatedChallenge

+ func (it *InboxTopChallengeInitiatedChallengeIterator) Close() error

+ func (it *InboxTopChallengeInitiatedChallengeIterator) Error() error

+ func (it *InboxTopChallengeInitiatedChallengeIterator) Next() bool

+ type InboxTopChallengeOneStepProofCompleted struct

+ Raw types.Log

+ type InboxTopChallengeOneStepProofCompletedIterator struct

+ Event *InboxTopChallengeOneStepProofCompleted

+ func (it *InboxTopChallengeOneStepProofCompletedIterator) Close() error

+ func (it *InboxTopChallengeOneStepProofCompletedIterator) Error() error

+ func (it *InboxTopChallengeOneStepProofCompletedIterator) Next() bool

+ type InboxTopChallengeRaw struct

+ Contract *InboxTopChallenge

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

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

+ func (_InboxTopChallenge *InboxTopChallengeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type InboxTopChallengeSession struct

+ CallOpts bind.CallOpts

+ Contract *InboxTopChallenge

+ TransactOpts bind.TransactOpts

+ func (_InboxTopChallenge *InboxTopChallengeSession) Bisect(_chainHashes [][32]byte, _chainLength *big.Int) (*types.Transaction, error)

+ func (_InboxTopChallenge *InboxTopChallengeSession) ChooseSegment(_segmentToChallenge *big.Int, _proof []byte, _bisectionRoot [32]byte, ...) (*types.Transaction, error)

+ func (_InboxTopChallenge *InboxTopChallengeSession) InitializeBisection(_rollupAddress common.Address, _asserter common.Address, ...) (*types.Transaction, error)

+ func (_InboxTopChallenge *InboxTopChallengeSession) IsMaster() (bool, error)

+ func (_InboxTopChallenge *InboxTopChallengeSession) OneStepProof(_lowerHash [32]byte, _value [32]byte) (*types.Transaction, error)

+ func (_InboxTopChallenge *InboxTopChallengeSession) TimeoutChallenge() (*types.Transaction, error)

+ type InboxTopChallengeTransactor struct

+ func NewInboxTopChallengeTransactor(address common.Address, transactor bind.ContractTransactor) (*InboxTopChallengeTransactor, error)

+ func (_InboxTopChallenge *InboxTopChallengeTransactor) Bisect(opts *bind.TransactOpts, _chainHashes [][32]byte, _chainLength *big.Int) (*types.Transaction, error)

+ func (_InboxTopChallenge *InboxTopChallengeTransactor) BisectCall(ctx context.Context, client ethutils.EthClient, from common.Address, ...) error

+ func (_InboxTopChallenge *InboxTopChallengeTransactor) ChooseSegment(opts *bind.TransactOpts, _segmentToChallenge *big.Int, _proof []byte, ...) (*types.Transaction, error)

+ func (_InboxTopChallenge *InboxTopChallengeTransactor) InitializeBisection(opts *bind.TransactOpts, _rollupAddress common.Address, ...) (*types.Transaction, error)

+ func (_InboxTopChallenge *InboxTopChallengeTransactor) OneStepProof(opts *bind.TransactOpts, _lowerHash [32]byte, _value [32]byte) (*types.Transaction, error)

+ func (_InboxTopChallenge *InboxTopChallengeTransactor) TimeoutChallenge(opts *bind.TransactOpts) (*types.Transaction, error)

+ type InboxTopChallengeTransactorRaw struct

+ Contract *InboxTopChallengeTransactor

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

+ func (_InboxTopChallenge *InboxTopChallengeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type InboxTopChallengeTransactorSession struct

+ Contract *InboxTopChallengeTransactor

+ TransactOpts bind.TransactOpts

+ func (_InboxTopChallenge *InboxTopChallengeTransactorSession) Bisect(_chainHashes [][32]byte, _chainLength *big.Int) (*types.Transaction, error)

+ func (_InboxTopChallenge *InboxTopChallengeTransactorSession) ChooseSegment(_segmentToChallenge *big.Int, _proof []byte, _bisectionRoot [32]byte, ...) (*types.Transaction, error)

+ func (_InboxTopChallenge *InboxTopChallengeTransactorSession) InitializeBisection(_rollupAddress common.Address, _asserter common.Address, ...) (*types.Transaction, error)

+ func (_InboxTopChallenge *InboxTopChallengeTransactorSession) OneStepProof(_lowerHash [32]byte, _value [32]byte) (*types.Transaction, error)

+ func (_InboxTopChallenge *InboxTopChallengeTransactorSession) TimeoutChallenge() (*types.Transaction, error)

+ type Keccak struct

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

+ func NewKeccak(address common.Address, backend bind.ContractBackend) (*Keccak, error)

+ type KeccakCaller struct

+ func NewKeccakCaller(address common.Address, caller bind.ContractCaller) (*KeccakCaller, error)

+ type KeccakCallerRaw struct

+ Contract *KeccakCaller

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

+ type KeccakCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *KeccakCaller

+ type KeccakFilterer struct

+ func NewKeccakFilterer(address common.Address, filterer bind.ContractFilterer) (*KeccakFilterer, error)

+ type KeccakRaw struct

+ Contract *Keccak

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

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

+ func (_Keccak *KeccakRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type KeccakSession struct

+ CallOpts bind.CallOpts

+ Contract *Keccak

+ TransactOpts bind.TransactOpts

+ type KeccakTransactor struct

+ func NewKeccakTransactor(address common.Address, transactor bind.ContractTransactor) (*KeccakTransactor, error)

+ type KeccakTransactorRaw struct

+ Contract *KeccakTransactor

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

+ func (_Keccak *KeccakTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type KeccakTransactorSession struct

+ Contract *KeccakTransactor

+ TransactOpts bind.TransactOpts

+ type NodeGraph struct

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

+ func NewNodeGraph(address common.Address, backend bind.ContractBackend) (*NodeGraph, error)

+ type NodeGraphCaller struct

+ func NewNodeGraphCaller(address common.Address, caller bind.ContractCaller) (*NodeGraphCaller, error)

+ func (_NodeGraph *NodeGraphCaller) IsValidLeaf(opts *bind.CallOpts, leaf [32]byte) (bool, error)

+ func (_NodeGraph *NodeGraphCaller) LatestConfirmed(opts *bind.CallOpts) ([32]byte, error)

+ func (_NodeGraph *NodeGraphCaller) VmParams(opts *bind.CallOpts) (struct{ ... }, error)

+ type NodeGraphCallerRaw struct

+ Contract *NodeGraphCaller

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

+ type NodeGraphCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *NodeGraphCaller

+ func (_NodeGraph *NodeGraphCallerSession) IsValidLeaf(leaf [32]byte) (bool, error)

+ func (_NodeGraph *NodeGraphCallerSession) LatestConfirmed() ([32]byte, error)

+ func (_NodeGraph *NodeGraphCallerSession) VmParams() (struct{ ... }, error)

+ type NodeGraphFilterer struct

+ func NewNodeGraphFilterer(address common.Address, filterer bind.ContractFilterer) (*NodeGraphFilterer, error)

+ func (_NodeGraph *NodeGraphFilterer) FilterRollupAsserted(opts *bind.FilterOpts) (*NodeGraphRollupAssertedIterator, error)

+ func (_NodeGraph *NodeGraphFilterer) FilterRollupConfirmed(opts *bind.FilterOpts) (*NodeGraphRollupConfirmedIterator, error)

+ func (_NodeGraph *NodeGraphFilterer) FilterRollupPruned(opts *bind.FilterOpts) (*NodeGraphRollupPrunedIterator, error)

+ func (_NodeGraph *NodeGraphFilterer) ParseRollupAsserted(log types.Log) (*NodeGraphRollupAsserted, error)

+ func (_NodeGraph *NodeGraphFilterer) ParseRollupConfirmed(log types.Log) (*NodeGraphRollupConfirmed, error)

+ func (_NodeGraph *NodeGraphFilterer) ParseRollupPruned(log types.Log) (*NodeGraphRollupPruned, error)

+ func (_NodeGraph *NodeGraphFilterer) WatchRollupAsserted(opts *bind.WatchOpts, sink chan<- *NodeGraphRollupAsserted) (event.Subscription, error)

+ func (_NodeGraph *NodeGraphFilterer) WatchRollupConfirmed(opts *bind.WatchOpts, sink chan<- *NodeGraphRollupConfirmed) (event.Subscription, error)

+ func (_NodeGraph *NodeGraphFilterer) WatchRollupPruned(opts *bind.WatchOpts, sink chan<- *NodeGraphRollupPruned) (event.Subscription, error)

+ type NodeGraphRaw struct

+ Contract *NodeGraph

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

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

+ func (_NodeGraph *NodeGraphRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type NodeGraphRollupAsserted struct

+ BeforeLogCount *big.Int

+ BeforeMessageCount *big.Int

+ Fields [7][32]byte

+ ImportedMessageCount *big.Int

+ InboxCount *big.Int

+ LogCount uint64

+ MessageCount uint64

+ NumArbGas uint64

+ NumSteps uint64

+ Raw types.Log

+ type NodeGraphRollupAssertedIterator struct

+ Event *NodeGraphRollupAsserted

+ func (it *NodeGraphRollupAssertedIterator) Close() error

+ func (it *NodeGraphRollupAssertedIterator) Error() error

+ func (it *NodeGraphRollupAssertedIterator) Next() bool

+ type NodeGraphRollupConfirmed struct

+ NodeHash [32]byte

+ Raw types.Log

+ type NodeGraphRollupConfirmedIterator struct

+ Event *NodeGraphRollupConfirmed

+ func (it *NodeGraphRollupConfirmedIterator) Close() error

+ func (it *NodeGraphRollupConfirmedIterator) Error() error

+ func (it *NodeGraphRollupConfirmedIterator) Next() bool

+ type NodeGraphRollupPruned struct

+ Leaf [32]byte

+ Raw types.Log

+ type NodeGraphRollupPrunedIterator struct

+ Event *NodeGraphRollupPruned

+ func (it *NodeGraphRollupPrunedIterator) Close() error

+ func (it *NodeGraphRollupPrunedIterator) Error() error

+ func (it *NodeGraphRollupPrunedIterator) Next() bool

+ type NodeGraphSession struct

+ CallOpts bind.CallOpts

+ Contract *NodeGraph

+ TransactOpts bind.TransactOpts

+ func (_NodeGraph *NodeGraphSession) IsValidLeaf(leaf [32]byte) (bool, error)

+ func (_NodeGraph *NodeGraphSession) LatestConfirmed() ([32]byte, error)

+ func (_NodeGraph *NodeGraphSession) PruneLeaves(fromNodes [][32]byte, leafProofs [][32]byte, leafProofLengths []*big.Int, ...) (*types.Transaction, error)

+ func (_NodeGraph *NodeGraphSession) VmParams() (struct{ ... }, error)

+ type NodeGraphTransactor struct

+ func NewNodeGraphTransactor(address common.Address, transactor bind.ContractTransactor) (*NodeGraphTransactor, error)

+ func (_NodeGraph *NodeGraphTransactor) PruneLeaves(opts *bind.TransactOpts, fromNodes [][32]byte, leafProofs [][32]byte, ...) (*types.Transaction, error)

+ type NodeGraphTransactorRaw struct

+ Contract *NodeGraphTransactor

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

+ func (_NodeGraph *NodeGraphTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type NodeGraphTransactorSession struct

+ Contract *NodeGraphTransactor

+ TransactOpts bind.TransactOpts

+ func (_NodeGraph *NodeGraphTransactorSession) PruneLeaves(fromNodes [][32]byte, leafProofs [][32]byte, leafProofLengths []*big.Int, ...) (*types.Transaction, error)

+ 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 OneStepProof struct

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

+ func NewOneStepProof(address common.Address, backend bind.ContractBackend) (*OneStepProof, error)

+ type OneStepProofCaller struct

+ func NewOneStepProofCaller(address common.Address, caller bind.ContractCaller) (*OneStepProofCaller, error)

+ func (_OneStepProof *OneStepProofCaller) ExecuteStep(opts *bind.CallOpts, inboxAcc [32]byte, messagesAcc [32]byte, logsAcc [32]byte, ...) (struct{ ... }, error)

+ func (_OneStepProof *OneStepProofCaller) ExecuteStepWithMessage(opts *bind.CallOpts, inboxAcc [32]byte, messagesAcc [32]byte, logsAcc [32]byte, ...) (struct{ ... }, error)

+ type OneStepProofCallerRaw struct

+ Contract *OneStepProofCaller

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

+ type OneStepProofCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OneStepProofCaller

+ func (_OneStepProof *OneStepProofCallerSession) ExecuteStep(inboxAcc [32]byte, messagesAcc [32]byte, logsAcc [32]byte, proof []byte) (struct{ ... }, error)

+ func (_OneStepProof *OneStepProofCallerSession) ExecuteStepWithMessage(inboxAcc [32]byte, messagesAcc [32]byte, logsAcc [32]byte, proof []byte, ...) (struct{ ... }, error)

+ type OneStepProofFilterer struct

+ func NewOneStepProofFilterer(address common.Address, filterer bind.ContractFilterer) (*OneStepProofFilterer, error)

+ type OneStepProofRaw struct

+ Contract *OneStepProof

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

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

+ func (_OneStepProof *OneStepProofRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OneStepProofSession struct

+ CallOpts bind.CallOpts

+ Contract *OneStepProof

+ TransactOpts bind.TransactOpts

+ func (_OneStepProof *OneStepProofSession) ExecuteStep(inboxAcc [32]byte, messagesAcc [32]byte, logsAcc [32]byte, proof []byte) (struct{ ... }, error)

+ func (_OneStepProof *OneStepProofSession) ExecuteStepWithMessage(inboxAcc [32]byte, messagesAcc [32]byte, logsAcc [32]byte, proof []byte, ...) (struct{ ... }, error)

+ type OneStepProofTransactor struct

+ func NewOneStepProofTransactor(address common.Address, transactor bind.ContractTransactor) (*OneStepProofTransactor, error)

+ type OneStepProofTransactorRaw struct

+ Contract *OneStepProofTransactor

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

+ func (_OneStepProof *OneStepProofTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OneStepProofTransactorSession struct

+ Contract *OneStepProofTransactor

+ TransactOpts bind.TransactOpts

+ type PaymentRecords struct

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

+ func NewPaymentRecords(address common.Address, backend bind.ContractBackend) (*PaymentRecords, error)

+ type PaymentRecordsCaller struct

+ func NewPaymentRecordsCaller(address common.Address, caller bind.ContractCaller) (*PaymentRecordsCaller, error)

+ func (_PaymentRecords *PaymentRecordsCaller) GetPaymentOwner(opts *bind.CallOpts, originalOwner common.Address, messageIndex *big.Int) (common.Address, error)

+ type PaymentRecordsCallerRaw struct

+ Contract *PaymentRecordsCaller

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

+ type PaymentRecordsCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *PaymentRecordsCaller

+ func (_PaymentRecords *PaymentRecordsCallerSession) GetPaymentOwner(originalOwner common.Address, messageIndex *big.Int) (common.Address, error)

+ type PaymentRecordsFilterer struct

+ func NewPaymentRecordsFilterer(address common.Address, filterer bind.ContractFilterer) (*PaymentRecordsFilterer, error)

+ func (_PaymentRecords *PaymentRecordsFilterer) FilterPaymentTransfer(opts *bind.FilterOpts) (*PaymentRecordsPaymentTransferIterator, error)

+ func (_PaymentRecords *PaymentRecordsFilterer) ParsePaymentTransfer(log types.Log) (*PaymentRecordsPaymentTransfer, error)

+ func (_PaymentRecords *PaymentRecordsFilterer) WatchPaymentTransfer(opts *bind.WatchOpts, sink chan<- *PaymentRecordsPaymentTransfer) (event.Subscription, error)

+ type PaymentRecordsPaymentTransfer struct

+ MessageIndex *big.Int

+ NewOwner common.Address

+ OriginalOwner common.Address

+ PrevOwner common.Address

+ Raw types.Log

+ type PaymentRecordsPaymentTransferIterator struct

+ Event *PaymentRecordsPaymentTransfer

+ func (it *PaymentRecordsPaymentTransferIterator) Close() error

+ func (it *PaymentRecordsPaymentTransferIterator) Error() error

+ func (it *PaymentRecordsPaymentTransferIterator) Next() bool

+ type PaymentRecordsRaw struct

+ Contract *PaymentRecords

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

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

+ func (_PaymentRecords *PaymentRecordsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type PaymentRecordsSession struct

+ CallOpts bind.CallOpts

+ Contract *PaymentRecords

+ TransactOpts bind.TransactOpts

+ func (_PaymentRecords *PaymentRecordsSession) GetPaymentOwner(originalOwner common.Address, messageIndex *big.Int) (common.Address, error)

+ func (_PaymentRecords *PaymentRecordsSession) TransferPayment(originalOwner common.Address, newOwner common.Address, messageIndex *big.Int) (*types.Transaction, error)

+ type PaymentRecordsTransactor struct

+ func NewPaymentRecordsTransactor(address common.Address, transactor bind.ContractTransactor) (*PaymentRecordsTransactor, error)

+ func (_PaymentRecords *PaymentRecordsTransactor) TransferPayment(opts *bind.TransactOpts, originalOwner common.Address, newOwner common.Address, ...) (*types.Transaction, error)

+ type PaymentRecordsTransactorRaw struct

+ Contract *PaymentRecordsTransactor

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

+ func (_PaymentRecords *PaymentRecordsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type PaymentRecordsTransactorSession struct

+ Contract *PaymentRecordsTransactor

+ TransactOpts bind.TransactOpts

+ func (_PaymentRecords *PaymentRecordsTransactorSession) TransferPayment(originalOwner common.Address, newOwner common.Address, messageIndex *big.Int) (*types.Transaction, error)

+ 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 Staking struct

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

+ func NewStaking(address common.Address, backend bind.ContractBackend) (*Staking, error)

+ type StakingCaller struct

+ func NewStakingCaller(address common.Address, caller bind.ContractCaller) (*StakingCaller, error)

+ func (_Staking *StakingCaller) ChallengeFactory(opts *bind.CallOpts) (common.Address, error)

+ func (_Staking *StakingCaller) GetStakeRequired(opts *bind.CallOpts) (*big.Int, error)

+ func (_Staking *StakingCaller) GetStakeToken(opts *bind.CallOpts) (common.Address, error)

+ func (_Staking *StakingCaller) IsStaked(opts *bind.CallOpts, _stakerAddress common.Address) (bool, error)

+ type StakingCallerRaw struct

+ Contract *StakingCaller

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

+ type StakingCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *StakingCaller

+ func (_Staking *StakingCallerSession) ChallengeFactory() (common.Address, error)

+ func (_Staking *StakingCallerSession) GetStakeRequired() (*big.Int, error)

+ func (_Staking *StakingCallerSession) GetStakeToken() (common.Address, error)

+ func (_Staking *StakingCallerSession) IsStaked(_stakerAddress common.Address) (bool, error)

+ type StakingFilterer struct

+ func NewStakingFilterer(address common.Address, filterer bind.ContractFilterer) (*StakingFilterer, error)

+ func (_Staking *StakingFilterer) FilterRollupChallengeCompleted(opts *bind.FilterOpts) (*StakingRollupChallengeCompletedIterator, error)

+ func (_Staking *StakingFilterer) FilterRollupChallengeStarted(opts *bind.FilterOpts) (*StakingRollupChallengeStartedIterator, error)

+ func (_Staking *StakingFilterer) FilterRollupStakeCreated(opts *bind.FilterOpts) (*StakingRollupStakeCreatedIterator, error)

+ func (_Staking *StakingFilterer) FilterRollupStakeMoved(opts *bind.FilterOpts) (*StakingRollupStakeMovedIterator, error)

+ func (_Staking *StakingFilterer) FilterRollupStakeRefunded(opts *bind.FilterOpts) (*StakingRollupStakeRefundedIterator, error)

+ func (_Staking *StakingFilterer) ParseRollupChallengeCompleted(log types.Log) (*StakingRollupChallengeCompleted, error)

+ func (_Staking *StakingFilterer) ParseRollupChallengeStarted(log types.Log) (*StakingRollupChallengeStarted, error)

+ func (_Staking *StakingFilterer) ParseRollupStakeCreated(log types.Log) (*StakingRollupStakeCreated, error)

+ func (_Staking *StakingFilterer) ParseRollupStakeMoved(log types.Log) (*StakingRollupStakeMoved, error)

+ func (_Staking *StakingFilterer) ParseRollupStakeRefunded(log types.Log) (*StakingRollupStakeRefunded, error)

+ func (_Staking *StakingFilterer) WatchRollupChallengeCompleted(opts *bind.WatchOpts, sink chan<- *StakingRollupChallengeCompleted) (event.Subscription, error)

+ func (_Staking *StakingFilterer) WatchRollupChallengeStarted(opts *bind.WatchOpts, sink chan<- *StakingRollupChallengeStarted) (event.Subscription, error)

+ func (_Staking *StakingFilterer) WatchRollupStakeCreated(opts *bind.WatchOpts, sink chan<- *StakingRollupStakeCreated) (event.Subscription, error)

+ func (_Staking *StakingFilterer) WatchRollupStakeMoved(opts *bind.WatchOpts, sink chan<- *StakingRollupStakeMoved) (event.Subscription, error)

+ func (_Staking *StakingFilterer) WatchRollupStakeRefunded(opts *bind.WatchOpts, sink chan<- *StakingRollupStakeRefunded) (event.Subscription, error)

+ type StakingRaw struct

+ Contract *Staking

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

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

+ func (_Staking *StakingRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type StakingRollupChallengeCompleted struct

+ ChallengeContract common.Address

+ Loser common.Address

+ Raw types.Log

+ Winner common.Address

+ type StakingRollupChallengeCompletedIterator struct

+ Event *StakingRollupChallengeCompleted

+ func (it *StakingRollupChallengeCompletedIterator) Close() error

+ func (it *StakingRollupChallengeCompletedIterator) Error() error

+ func (it *StakingRollupChallengeCompletedIterator) Next() bool

+ type StakingRollupChallengeStarted struct

+ Asserter common.Address

+ ChallengeContract common.Address

+ ChallengeType *big.Int

+ Challenger common.Address

+ Raw types.Log

+ type StakingRollupChallengeStartedIterator struct

+ Event *StakingRollupChallengeStarted

+ func (it *StakingRollupChallengeStartedIterator) Close() error

+ func (it *StakingRollupChallengeStartedIterator) Error() error

+ func (it *StakingRollupChallengeStartedIterator) Next() bool

+ type StakingRollupStakeCreated struct

+ NodeHash [32]byte

+ Raw types.Log

+ Staker common.Address

+ type StakingRollupStakeCreatedIterator struct

+ Event *StakingRollupStakeCreated

+ func (it *StakingRollupStakeCreatedIterator) Close() error

+ func (it *StakingRollupStakeCreatedIterator) Error() error

+ func (it *StakingRollupStakeCreatedIterator) Next() bool

+ type StakingRollupStakeMoved struct

+ Raw types.Log

+ Staker common.Address

+ ToNodeHash [32]byte

+ type StakingRollupStakeMovedIterator struct

+ Event *StakingRollupStakeMoved

+ func (it *StakingRollupStakeMovedIterator) Close() error

+ func (it *StakingRollupStakeMovedIterator) Error() error

+ func (it *StakingRollupStakeMovedIterator) Next() bool

+ type StakingRollupStakeRefunded struct

+ Raw types.Log

+ Staker common.Address

+ type StakingRollupStakeRefundedIterator struct

+ Event *StakingRollupStakeRefunded

+ func (it *StakingRollupStakeRefundedIterator) Close() error

+ func (it *StakingRollupStakeRefundedIterator) Error() error

+ func (it *StakingRollupStakeRefundedIterator) Next() bool

+ type StakingSession struct

+ CallOpts bind.CallOpts

+ Contract *Staking

+ TransactOpts bind.TransactOpts

+ func (_Staking *StakingSession) ChallengeFactory() (common.Address, error)

+ func (_Staking *StakingSession) GetStakeRequired() (*big.Int, error)

+ func (_Staking *StakingSession) GetStakeToken() (common.Address, error)

+ func (_Staking *StakingSession) GetWithdrawnStake(_staker common.Address) (*types.Transaction, error)

+ func (_Staking *StakingSession) IsStaked(_stakerAddress common.Address) (bool, error)

+ func (_Staking *StakingSession) ResolveChallenge(winner common.Address, loser common.Address) (*types.Transaction, error)

+ func (_Staking *StakingSession) StartChallenge(asserterAddress common.Address, challengerAddress common.Address, ...) (*types.Transaction, error)

+ type StakingTransactor struct

+ func NewStakingTransactor(address common.Address, transactor bind.ContractTransactor) (*StakingTransactor, error)

+ func (_Staking *StakingTransactor) GetWithdrawnStake(opts *bind.TransactOpts, _staker common.Address) (*types.Transaction, error)

+ func (_Staking *StakingTransactor) ResolveChallenge(opts *bind.TransactOpts, winner common.Address, loser common.Address) (*types.Transaction, error)

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

+ type StakingTransactorRaw struct

+ Contract *StakingTransactor

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

+ func (_Staking *StakingTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type StakingTransactorSession struct

+ Contract *StakingTransactor

+ TransactOpts bind.TransactOpts

+ func (_Staking *StakingTransactorSession) GetWithdrawnStake(_staker common.Address) (*types.Transaction, error)

+ func (_Staking *StakingTransactorSession) ResolveChallenge(winner common.Address, loser common.Address) (*types.Transaction, error)

+ func (_Staking *StakingTransactorSession) StartChallenge(asserterAddress common.Address, challengerAddress common.Address, ...) (*types.Transaction, error)

+ 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

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