bindings

package

Go to main page

Versions in this module

v1

v1.4.3

Jun 3, 2024

v1.4.3-rc.1

May 7, 2024

v1.4.2

Apr 23, 2024

v1.4.1

Apr 17, 2024

v1.4.0

Apr 15, 2024

Changes in this version

+ const DataAvailabilityChallengeStorageLayoutJSON

+ const DelayedWETHStorageLayoutJSON

+ var Create2DeployerABI = Create2DeployerMetaData.ABI

+ var Create2DeployerBin = Create2DeployerMetaData.Bin

+ var Create2DeployerMetaData = &bind.MetaData

+ var DataAvailabilityChallengeABI = DataAvailabilityChallengeMetaData.ABI

+ var DataAvailabilityChallengeBin = DataAvailabilityChallengeMetaData.Bin

+ var DataAvailabilityChallengeMetaData = &bind.MetaData

+ var DataAvailabilityChallengeStorageLayout = new(solc.StorageLayout)

+ var DelayedWETHABI = DelayedWETHMetaData.ABI

+ var DelayedWETHBin = DelayedWETHMetaData.Bin

+ var DelayedWETHMetaData = &bind.MetaData

+ var DelayedWETHStorageLayout = new(solc.StorageLayout)

+ var DeterministicDeploymentProxyABI = DeterministicDeploymentProxyMetaData.ABI

+ var DeterministicDeploymentProxyBin = DeterministicDeploymentProxyMetaData.Bin

+ var DeterministicDeploymentProxyDeployedBin = "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe03601600081602082378035828234f58015156039578182fd5b8082525050506014600cf3"

+ var DeterministicDeploymentProxyMetaData = &bind.MetaData

+ var EntryPointABI = EntryPointMetaData.ABI

+ var EntryPointBin = EntryPointMetaData.Bin

+ var EntryPointMetaData = &bind.MetaData

+ var MultiCall3ABI = MultiCall3MetaData.ABI

+ var MultiCall3Bin = MultiCall3MetaData.Bin

+ var MultiCall3MetaData = &bind.MetaData

+ var MultiSendCallOnlyV130ABI = MultiSendCallOnlyV130MetaData.ABI

+ var MultiSendCallOnlyV130Bin = MultiSendCallOnlyV130MetaData.Bin

+ var MultiSendCallOnlyV130MetaData = &bind.MetaData

+ var MultiSendCallOnly_v130DeployedBin = "0x60806040526004361061001e5760003560e01c80638d80ff0a14610023575b600080fd5b6100dc6004803603602081101561003957600080fd5b810190808035906020019064010000000081111561005657600080fd5b82018360208201111561006857600080fd5b8035906020019184600183028401116401000000008311171561008a57600080fd5b91908080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f8201169050808301925050505050505091929192905050506100de565b005b805160205b8181101561015f578083015160f81c6001820184015160601c60158301850151603584018601516055850187016000856000811461012857600181146101385761013d565b6000808585888a5af1915061013d565b600080fd5b50600081141561014c57600080fd5b82605501870196505050505050506100e3565b50505056fea264697066735822122035246402746c96964495cae5b36461fd44dfb89f8e6cf6f6b8d60c0aa89f414864736f6c63430007060033"

+ var MultiSendV130ABI = MultiSendV130MetaData.ABI

+ var MultiSendV130Bin = MultiSendV130MetaData.Bin

+ var MultiSendV130MetaData = &bind.MetaData

+ var MultiSend_v130DeployedBin = "0x60806040526004361061001e5760003560e01c80638d80ff0a14610023575b600080fd5b6100dc6004803603602081101561003957600080fd5b810190808035906020019064010000000081111561005657600080fd5b82018360208201111561006857600080fd5b8035906020019184600183028401116401000000008311171561008a57600080fd5b91908080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f8201169050808301925050505050505091929192905050506100de565b005b7f000000000000000000000000998739bfdaadde7c933b942a68053933098f9eda73ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610183576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260308152602001806102106030913960400191505060405180910390fd5b805160205b8181101561020a578083015160f81c6001820184015160601c6015830185015160358401860151605585018701600085600081146101cd57600181146101dd576101e8565b6000808585888a5af191506101e8565b6000808585895af491505b5060008114156101f757600080fd5b8260550187019650505050505050610188565b50505056fe4d756c746953656e642073686f756c64206f6e6c792062652063616c6c6564207669612064656c656761746563616c6ca26469706673582212205c784303626eec02b71940b551976170b500a8a36cc5adcbeb2c19751a76d05464736f6c63430007060033"

+ var Permit2ABI = Permit2MetaData.ABI

+ var Permit2Bin = Permit2MetaData.Bin

+ var Permit2Deployer = "0x4e59b44847b379578588920cA78FbF26c0B4956C"

+ var Permit2DeploymentSalt = "0000000000000000000000000000000000000000d3af2663da51c10215000000"

+ var Permit2MetaData = &bind.MetaData

+ var SafeL2V130ABI = SafeL2V130MetaData.ABI

+ var SafeL2V130Bin = SafeL2V130MetaData.Bin

+ var SafeL2V130MetaData = &bind.MetaData

+ var SafeSingletonFactoryABI = SafeSingletonFactoryMetaData.ABI

+ var SafeSingletonFactoryBin = SafeSingletonFactoryMetaData.Bin

+ var SafeSingletonFactoryDeployedBin = "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe03601600081602082378035828234f58015156039578182fd5b8082525050506014600cf3"

+ var SafeSingletonFactoryMetaData = &bind.MetaData

+ var SafeV130ABI = SafeV130MetaData.ABI

+ var SafeV130Bin = SafeV130MetaData.Bin

+ var SafeV130MetaData = &bind.MetaData

+ var SenderCreatorABI = SenderCreatorMetaData.ABI

+ var SenderCreatorBin = SenderCreatorMetaData.Bin

+ var SenderCreatorMetaData = &bind.MetaData

+ func GetDeployerAddress(name string) ([]byte, error)

+ func GetDeploymentSalt(name string) ([]byte, error)

+ func GetInitBytecode(name string) ([]byte, error)

type AlphabetVM2Caller

+ func (_AlphabetVM2 *AlphabetVM2Caller) Step(opts *bind.CallOpts, _stateData []byte, arg1 []byte, _localContext [32]byte) ([32]byte, error)

type AlphabetVM2CallerSession

+ func (_AlphabetVM2 *AlphabetVM2CallerSession) Step(_stateData []byte, arg1 []byte, _localContext [32]byte) ([32]byte, error)

+ type Challenge struct

+ Challenger common.Address

+ LockedBond *big.Int

+ ResolvedBlock *big.Int

+ StartBlock *big.Int

+ type Create2Deployer struct

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

+ func NewCreate2Deployer(address common.Address, backend bind.ContractBackend) (*Create2Deployer, error)

+ type Create2DeployerCaller struct

+ func NewCreate2DeployerCaller(address common.Address, caller bind.ContractCaller) (*Create2DeployerCaller, error)

+ func (_Create2Deployer *Create2DeployerCaller) ComputeAddress(opts *bind.CallOpts, salt [32]byte, codeHash [32]byte) (common.Address, error)

+ func (_Create2Deployer *Create2DeployerCaller) ComputeAddressWithDeployer(opts *bind.CallOpts, salt [32]byte, codeHash [32]byte, deployer common.Address) (common.Address, error)

+ type Create2DeployerCallerRaw struct

+ Contract *Create2DeployerCaller

+ func (_Create2Deployer *Create2DeployerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type Create2DeployerCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *Create2DeployerCaller

+ func (_Create2Deployer *Create2DeployerCallerSession) ComputeAddress(salt [32]byte, codeHash [32]byte) (common.Address, error)

+ func (_Create2Deployer *Create2DeployerCallerSession) ComputeAddressWithDeployer(salt [32]byte, codeHash [32]byte, deployer common.Address) (common.Address, error)

+ type Create2DeployerFilterer struct

+ func NewCreate2DeployerFilterer(address common.Address, filterer bind.ContractFilterer) (*Create2DeployerFilterer, error)

+ type Create2DeployerRaw struct

+ Contract *Create2Deployer

+ func (_Create2Deployer *Create2DeployerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_Create2Deployer *Create2DeployerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type Create2DeployerSession struct

+ CallOpts bind.CallOpts

+ Contract *Create2Deployer

+ TransactOpts bind.TransactOpts

+ func (_Create2Deployer *Create2DeployerSession) ComputeAddress(salt [32]byte, codeHash [32]byte) (common.Address, error)

+ func (_Create2Deployer *Create2DeployerSession) ComputeAddressWithDeployer(salt [32]byte, codeHash [32]byte, deployer common.Address) (common.Address, error)

+ func (_Create2Deployer *Create2DeployerSession) Deploy(value *big.Int, salt [32]byte, code []byte) (*types.Transaction, error)

+ func (_Create2Deployer *Create2DeployerSession) DeployERC1820Implementer(value *big.Int, salt [32]byte) (*types.Transaction, error)

+ func (_Create2Deployer *Create2DeployerSession) Receive() (*types.Transaction, error)

+ type Create2DeployerTransactor struct

+ func NewCreate2DeployerTransactor(address common.Address, transactor bind.ContractTransactor) (*Create2DeployerTransactor, error)

+ func (_Create2Deployer *Create2DeployerTransactor) Deploy(opts *bind.TransactOpts, value *big.Int, salt [32]byte, code []byte) (*types.Transaction, error)

+ func (_Create2Deployer *Create2DeployerTransactor) DeployERC1820Implementer(opts *bind.TransactOpts, value *big.Int, salt [32]byte) (*types.Transaction, error)

+ func (_Create2Deployer *Create2DeployerTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ type Create2DeployerTransactorRaw struct

+ Contract *Create2DeployerTransactor

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

+ func (_Create2Deployer *Create2DeployerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type Create2DeployerTransactorSession struct

+ Contract *Create2DeployerTransactor

+ TransactOpts bind.TransactOpts

+ func (_Create2Deployer *Create2DeployerTransactorSession) Deploy(value *big.Int, salt [32]byte, code []byte) (*types.Transaction, error)

+ func (_Create2Deployer *Create2DeployerTransactorSession) DeployERC1820Implementer(value *big.Int, salt [32]byte) (*types.Transaction, error)

+ func (_Create2Deployer *Create2DeployerTransactorSession) Receive() (*types.Transaction, error)

type CrossDomainMessengerCaller

+ func (_CrossDomainMessenger *CrossDomainMessengerCaller) OtherMessenger(opts *bind.CallOpts) (common.Address, error)

type CrossDomainMessengerCallerSession

+ func (_CrossDomainMessenger *CrossDomainMessengerCallerSession) OtherMessenger() (common.Address, error)

type CrossDomainMessengerSession

+ func (_CrossDomainMessenger *CrossDomainMessengerSession) OtherMessenger() (common.Address, error)

+ type DataAvailabilityChallenge struct

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

+ func NewDataAvailabilityChallenge(address common.Address, backend bind.ContractBackend) (*DataAvailabilityChallenge, error)

+ type DataAvailabilityChallengeBalanceChanged struct

+ Account common.Address

+ Balance *big.Int

+ Raw types.Log

+ type DataAvailabilityChallengeBalanceChangedIterator struct

+ Event *DataAvailabilityChallengeBalanceChanged

+ func (it *DataAvailabilityChallengeBalanceChangedIterator) Close() error

+ func (it *DataAvailabilityChallengeBalanceChangedIterator) Error() error

+ func (it *DataAvailabilityChallengeBalanceChangedIterator) Next() bool

+ type DataAvailabilityChallengeCaller struct

+ func NewDataAvailabilityChallengeCaller(address common.Address, caller bind.ContractCaller) (*DataAvailabilityChallengeCaller, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCaller) Balances(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCaller) BondSize(opts *bind.CallOpts) (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCaller) ChallengeWindow(opts *bind.CallOpts) (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCaller) FixedResolutionCost(opts *bind.CallOpts) (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCaller) GetChallenge(opts *bind.CallOpts, challengedBlockNumber *big.Int, ...) (Challenge, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCaller) GetChallengeStatus(opts *bind.CallOpts, challengedBlockNumber *big.Int, ...) (uint8, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCaller) ResolveWindow(opts *bind.CallOpts) (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCaller) ResolverRefundPercentage(opts *bind.CallOpts) (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCaller) ValidateCommitment(opts *bind.CallOpts, commitment []byte) error

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCaller) VariableResolutionCost(opts *bind.CallOpts) (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCaller) VariableResolutionCostPrecision(opts *bind.CallOpts) (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCaller) Version(opts *bind.CallOpts) (string, error)

+ type DataAvailabilityChallengeCallerRaw struct

+ Contract *DataAvailabilityChallengeCaller

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type DataAvailabilityChallengeCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *DataAvailabilityChallengeCaller

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCallerSession) Balances(arg0 common.Address) (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCallerSession) BondSize() (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCallerSession) ChallengeWindow() (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCallerSession) FixedResolutionCost() (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCallerSession) GetChallenge(challengedBlockNumber *big.Int, challengedCommitment []byte) (Challenge, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCallerSession) GetChallengeStatus(challengedBlockNumber *big.Int, challengedCommitment []byte) (uint8, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCallerSession) Owner() (common.Address, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCallerSession) ResolveWindow() (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCallerSession) ResolverRefundPercentage() (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCallerSession) ValidateCommitment(commitment []byte) error

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCallerSession) VariableResolutionCost() (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCallerSession) VariableResolutionCostPrecision() (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeCallerSession) Version() (string, error)

+ type DataAvailabilityChallengeChallengeStatusChanged struct

+ ChallengedBlockNumber *big.Int

+ ChallengedCommitment []byte

+ Raw types.Log

+ Status uint8

+ type DataAvailabilityChallengeChallengeStatusChangedIterator struct

+ Event *DataAvailabilityChallengeChallengeStatusChanged

+ func (it *DataAvailabilityChallengeChallengeStatusChangedIterator) Close() error

+ func (it *DataAvailabilityChallengeChallengeStatusChangedIterator) Error() error

+ func (it *DataAvailabilityChallengeChallengeStatusChangedIterator) Next() bool

+ type DataAvailabilityChallengeFilterer struct

+ func NewDataAvailabilityChallengeFilterer(address common.Address, filterer bind.ContractFilterer) (*DataAvailabilityChallengeFilterer, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeFilterer) FilterBalanceChanged(opts *bind.FilterOpts) (*DataAvailabilityChallengeBalanceChangedIterator, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeFilterer) FilterChallengeStatusChanged(opts *bind.FilterOpts, challengedBlockNumber []*big.Int) (*DataAvailabilityChallengeChallengeStatusChangedIterator, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeFilterer) FilterInitialized(opts *bind.FilterOpts) (*DataAvailabilityChallengeInitializedIterator, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*DataAvailabilityChallengeOwnershipTransferredIterator, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeFilterer) FilterRequiredBondSizeChanged(opts *bind.FilterOpts) (*DataAvailabilityChallengeRequiredBondSizeChangedIterator, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeFilterer) FilterResolverRefundPercentageChanged(opts *bind.FilterOpts) (*DataAvailabilityChallengeResolverRefundPercentageChangedIterator, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeFilterer) ParseBalanceChanged(log types.Log) (*DataAvailabilityChallengeBalanceChanged, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeFilterer) ParseChallengeStatusChanged(log types.Log) (*DataAvailabilityChallengeChallengeStatusChanged, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeFilterer) ParseInitialized(log types.Log) (*DataAvailabilityChallengeInitialized, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeFilterer) ParseOwnershipTransferred(log types.Log) (*DataAvailabilityChallengeOwnershipTransferred, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeFilterer) ParseRequiredBondSizeChanged(log types.Log) (*DataAvailabilityChallengeRequiredBondSizeChanged, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeFilterer) ParseResolverRefundPercentageChanged(log types.Log) (*DataAvailabilityChallengeResolverRefundPercentageChanged, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeFilterer) WatchBalanceChanged(opts *bind.WatchOpts, sink chan<- *DataAvailabilityChallengeBalanceChanged) (event.Subscription, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeFilterer) WatchChallengeStatusChanged(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *DataAvailabilityChallengeInitialized) (event.Subscription, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeFilterer) WatchRequiredBondSizeChanged(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeFilterer) WatchResolverRefundPercentageChanged(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ type DataAvailabilityChallengeInitialized struct

+ Raw types.Log

+ Version uint8

+ type DataAvailabilityChallengeInitializedIterator struct

+ Event *DataAvailabilityChallengeInitialized

+ func (it *DataAvailabilityChallengeInitializedIterator) Close() error

+ func (it *DataAvailabilityChallengeInitializedIterator) Error() error

+ func (it *DataAvailabilityChallengeInitializedIterator) Next() bool

+ type DataAvailabilityChallengeOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type DataAvailabilityChallengeOwnershipTransferredIterator struct

+ Event *DataAvailabilityChallengeOwnershipTransferred

+ func (it *DataAvailabilityChallengeOwnershipTransferredIterator) Close() error

+ func (it *DataAvailabilityChallengeOwnershipTransferredIterator) Error() error

+ func (it *DataAvailabilityChallengeOwnershipTransferredIterator) Next() bool

+ type DataAvailabilityChallengeRaw struct

+ Contract *DataAvailabilityChallenge

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DataAvailabilityChallengeRequiredBondSizeChanged struct

+ ChallengeWindow *big.Int

+ Raw types.Log

+ type DataAvailabilityChallengeRequiredBondSizeChangedIterator struct

+ Event *DataAvailabilityChallengeRequiredBondSizeChanged

+ func (it *DataAvailabilityChallengeRequiredBondSizeChangedIterator) Close() error

+ func (it *DataAvailabilityChallengeRequiredBondSizeChangedIterator) Error() error

+ func (it *DataAvailabilityChallengeRequiredBondSizeChangedIterator) Next() bool

+ type DataAvailabilityChallengeResolverRefundPercentageChanged struct

+ Raw types.Log

+ ResolverRefundPercentage *big.Int

+ type DataAvailabilityChallengeResolverRefundPercentageChangedIterator struct

+ Event *DataAvailabilityChallengeResolverRefundPercentageChanged

+ func (it *DataAvailabilityChallengeResolverRefundPercentageChangedIterator) Close() error

+ func (it *DataAvailabilityChallengeResolverRefundPercentageChangedIterator) Error() error

+ func (it *DataAvailabilityChallengeResolverRefundPercentageChangedIterator) Next() bool

+ type DataAvailabilityChallengeSession struct

+ CallOpts bind.CallOpts

+ Contract *DataAvailabilityChallenge

+ TransactOpts bind.TransactOpts

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) Balances(arg0 common.Address) (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) BondSize() (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) Challenge(challengedBlockNumber *big.Int, challengedCommitment []byte) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) ChallengeWindow() (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) Deposit() (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) FixedResolutionCost() (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) GetChallenge(challengedBlockNumber *big.Int, challengedCommitment []byte) (Challenge, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) GetChallengeStatus(challengedBlockNumber *big.Int, challengedCommitment []byte) (uint8, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) Initialize(_owner common.Address, _challengeWindow *big.Int, _resolveWindow *big.Int, ...) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) Owner() (common.Address, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) Receive() (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) RenounceOwnership() (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) Resolve(challengedBlockNumber *big.Int, challengedCommitment []byte, ...) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) ResolveWindow() (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) ResolverRefundPercentage() (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) SetBondSize(_bondSize *big.Int) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) SetResolverRefundPercentage(_resolverRefundPercentage *big.Int) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) UnlockBond(challengedBlockNumber *big.Int, challengedCommitment []byte) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) ValidateCommitment(commitment []byte) error

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) VariableResolutionCost() (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) VariableResolutionCostPrecision() (*big.Int, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) Version() (string, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeSession) Withdraw() (*types.Transaction, error)

+ type DataAvailabilityChallengeTransactor struct

+ func NewDataAvailabilityChallengeTransactor(address common.Address, transactor bind.ContractTransactor) (*DataAvailabilityChallengeTransactor, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactor) Challenge(opts *bind.TransactOpts, challengedBlockNumber *big.Int, ...) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactor) Deposit(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactor) Initialize(opts *bind.TransactOpts, _owner common.Address, _challengeWindow *big.Int, ...) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactor) Resolve(opts *bind.TransactOpts, challengedBlockNumber *big.Int, ...) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactor) SetBondSize(opts *bind.TransactOpts, _bondSize *big.Int) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactor) SetResolverRefundPercentage(opts *bind.TransactOpts, _resolverRefundPercentage *big.Int) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactor) UnlockBond(opts *bind.TransactOpts, challengedBlockNumber *big.Int, ...) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactor) Withdraw(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DataAvailabilityChallengeTransactorRaw struct

+ Contract *DataAvailabilityChallengeTransactor

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

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DataAvailabilityChallengeTransactorSession struct

+ Contract *DataAvailabilityChallengeTransactor

+ TransactOpts bind.TransactOpts

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactorSession) Challenge(challengedBlockNumber *big.Int, challengedCommitment []byte) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactorSession) Deposit() (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactorSession) Initialize(_owner common.Address, _challengeWindow *big.Int, _resolveWindow *big.Int, ...) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactorSession) Receive() (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactorSession) Resolve(challengedBlockNumber *big.Int, challengedCommitment []byte, ...) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactorSession) SetBondSize(_bondSize *big.Int) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactorSession) SetResolverRefundPercentage(_resolverRefundPercentage *big.Int) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactorSession) UnlockBond(challengedBlockNumber *big.Int, challengedCommitment []byte) (*types.Transaction, error)

+ func (_DataAvailabilityChallenge *DataAvailabilityChallengeTransactorSession) Withdraw() (*types.Transaction, error)

+ type DelayedWETH struct

+ func DeployDelayedWETH(auth *bind.TransactOpts, backend bind.ContractBackend, _delay *big.Int) (common.Address, *types.Transaction, *DelayedWETH, error)

+ func NewDelayedWETH(address common.Address, backend bind.ContractBackend) (*DelayedWETH, error)

+ type DelayedWETHApproval struct

+ Guy common.Address

+ Raw types.Log

+ Src common.Address

+ Wad *big.Int

+ type DelayedWETHApprovalIterator struct

+ Event *DelayedWETHApproval

+ func (it *DelayedWETHApprovalIterator) Close() error

+ func (it *DelayedWETHApprovalIterator) Error() error

+ func (it *DelayedWETHApprovalIterator) Next() bool

+ type DelayedWETHCaller struct

+ func NewDelayedWETHCaller(address common.Address, caller bind.ContractCaller) (*DelayedWETHCaller, error)

+ func (_DelayedWETH *DelayedWETHCaller) Allowance(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_DelayedWETH *DelayedWETHCaller) BalanceOf(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_DelayedWETH *DelayedWETHCaller) Config(opts *bind.CallOpts) (common.Address, error)

+ func (_DelayedWETH *DelayedWETHCaller) Decimals(opts *bind.CallOpts) (uint8, error)

+ func (_DelayedWETH *DelayedWETHCaller) Delay(opts *bind.CallOpts) (*big.Int, error)

+ func (_DelayedWETH *DelayedWETHCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_DelayedWETH *DelayedWETHCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_DelayedWETH *DelayedWETHCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_DelayedWETH *DelayedWETHCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ func (_DelayedWETH *DelayedWETHCaller) Version(opts *bind.CallOpts) (string, error)

+ func (_DelayedWETH *DelayedWETHCaller) Withdrawals(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (struct{ ... }, error)

+ type DelayedWETHCallerRaw struct

+ Contract *DelayedWETHCaller

+ func (_DelayedWETH *DelayedWETHCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type DelayedWETHCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *DelayedWETHCaller

+ func (_DelayedWETH *DelayedWETHCallerSession) Allowance(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_DelayedWETH *DelayedWETHCallerSession) BalanceOf(arg0 common.Address) (*big.Int, error)

+ func (_DelayedWETH *DelayedWETHCallerSession) Config() (common.Address, error)

+ func (_DelayedWETH *DelayedWETHCallerSession) Decimals() (uint8, error)

+ func (_DelayedWETH *DelayedWETHCallerSession) Delay() (*big.Int, error)

+ func (_DelayedWETH *DelayedWETHCallerSession) Name() (string, error)

+ func (_DelayedWETH *DelayedWETHCallerSession) Owner() (common.Address, error)

+ func (_DelayedWETH *DelayedWETHCallerSession) Symbol() (string, error)

+ func (_DelayedWETH *DelayedWETHCallerSession) TotalSupply() (*big.Int, error)

+ func (_DelayedWETH *DelayedWETHCallerSession) Version() (string, error)

+ func (_DelayedWETH *DelayedWETHCallerSession) Withdrawals(arg0 common.Address, arg1 common.Address) (struct{ ... }, error)

+ type DelayedWETHDeposit struct

+ Dst common.Address

+ Raw types.Log

+ Wad *big.Int

+ type DelayedWETHDepositIterator struct

+ Event *DelayedWETHDeposit

+ func (it *DelayedWETHDepositIterator) Close() error

+ func (it *DelayedWETHDepositIterator) Error() error

+ func (it *DelayedWETHDepositIterator) Next() bool

+ type DelayedWETHFilterer struct

+ func NewDelayedWETHFilterer(address common.Address, filterer bind.ContractFilterer) (*DelayedWETHFilterer, error)

+ func (_DelayedWETH *DelayedWETHFilterer) FilterApproval(opts *bind.FilterOpts, src []common.Address, guy []common.Address) (*DelayedWETHApprovalIterator, error)

+ func (_DelayedWETH *DelayedWETHFilterer) FilterDeposit(opts *bind.FilterOpts, dst []common.Address) (*DelayedWETHDepositIterator, error)

+ func (_DelayedWETH *DelayedWETHFilterer) FilterInitialized(opts *bind.FilterOpts) (*DelayedWETHInitializedIterator, error)

+ func (_DelayedWETH *DelayedWETHFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*DelayedWETHOwnershipTransferredIterator, error)

+ func (_DelayedWETH *DelayedWETHFilterer) FilterTransfer(opts *bind.FilterOpts, src []common.Address, dst []common.Address) (*DelayedWETHTransferIterator, error)

+ func (_DelayedWETH *DelayedWETHFilterer) FilterUnwrap(opts *bind.FilterOpts, src []common.Address) (*DelayedWETHUnwrapIterator, error)

+ func (_DelayedWETH *DelayedWETHFilterer) FilterWithdrawal(opts *bind.FilterOpts, src []common.Address) (*DelayedWETHWithdrawalIterator, error)

+ func (_DelayedWETH *DelayedWETHFilterer) ParseApproval(log types.Log) (*DelayedWETHApproval, error)

+ func (_DelayedWETH *DelayedWETHFilterer) ParseDeposit(log types.Log) (*DelayedWETHDeposit, error)

+ func (_DelayedWETH *DelayedWETHFilterer) ParseInitialized(log types.Log) (*DelayedWETHInitialized, error)

+ func (_DelayedWETH *DelayedWETHFilterer) ParseOwnershipTransferred(log types.Log) (*DelayedWETHOwnershipTransferred, error)

+ func (_DelayedWETH *DelayedWETHFilterer) ParseTransfer(log types.Log) (*DelayedWETHTransfer, error)

+ func (_DelayedWETH *DelayedWETHFilterer) ParseUnwrap(log types.Log) (*DelayedWETHUnwrap, error)

+ func (_DelayedWETH *DelayedWETHFilterer) ParseWithdrawal(log types.Log) (*DelayedWETHWithdrawal, error)

+ func (_DelayedWETH *DelayedWETHFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *DelayedWETHApproval, src []common.Address, ...) (event.Subscription, error)

+ func (_DelayedWETH *DelayedWETHFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *DelayedWETHDeposit, dst []common.Address) (event.Subscription, error)

+ func (_DelayedWETH *DelayedWETHFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *DelayedWETHInitialized) (event.Subscription, error)

+ func (_DelayedWETH *DelayedWETHFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *DelayedWETHOwnershipTransferred, ...) (event.Subscription, error)

+ func (_DelayedWETH *DelayedWETHFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *DelayedWETHTransfer, src []common.Address, ...) (event.Subscription, error)

+ func (_DelayedWETH *DelayedWETHFilterer) WatchUnwrap(opts *bind.WatchOpts, sink chan<- *DelayedWETHUnwrap, src []common.Address) (event.Subscription, error)

+ func (_DelayedWETH *DelayedWETHFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *DelayedWETHWithdrawal, src []common.Address) (event.Subscription, error)

+ type DelayedWETHInitialized struct

+ Raw types.Log

+ Version uint8

+ type DelayedWETHInitializedIterator struct

+ Event *DelayedWETHInitialized

+ func (it *DelayedWETHInitializedIterator) Close() error

+ func (it *DelayedWETHInitializedIterator) Error() error

+ func (it *DelayedWETHInitializedIterator) Next() bool

+ type DelayedWETHOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type DelayedWETHOwnershipTransferredIterator struct

+ Event *DelayedWETHOwnershipTransferred

+ func (it *DelayedWETHOwnershipTransferredIterator) Close() error

+ func (it *DelayedWETHOwnershipTransferredIterator) Error() error

+ func (it *DelayedWETHOwnershipTransferredIterator) Next() bool

+ type DelayedWETHRaw struct

+ Contract *DelayedWETH

+ func (_DelayedWETH *DelayedWETHRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_DelayedWETH *DelayedWETHRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DelayedWETHSession struct

+ CallOpts bind.CallOpts

+ Contract *DelayedWETH

+ TransactOpts bind.TransactOpts

+ func (_DelayedWETH *DelayedWETHSession) Allowance(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_DelayedWETH *DelayedWETHSession) Approve(guy common.Address, wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHSession) BalanceOf(arg0 common.Address) (*big.Int, error)

+ func (_DelayedWETH *DelayedWETHSession) Config() (common.Address, error)

+ func (_DelayedWETH *DelayedWETHSession) Decimals() (uint8, error)

+ func (_DelayedWETH *DelayedWETHSession) Delay() (*big.Int, error)

+ func (_DelayedWETH *DelayedWETHSession) Deposit() (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHSession) Hold(_guy common.Address, _wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHSession) Initialize(_owner common.Address, _config common.Address) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHSession) Name() (string, error)

+ func (_DelayedWETH *DelayedWETHSession) Owner() (common.Address, error)

+ func (_DelayedWETH *DelayedWETHSession) Receive() (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHSession) Recover(_wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHSession) RenounceOwnership() (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHSession) Symbol() (string, error)

+ func (_DelayedWETH *DelayedWETHSession) TotalSupply() (*big.Int, error)

+ func (_DelayedWETH *DelayedWETHSession) Transfer(dst common.Address, wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHSession) TransferFrom(src common.Address, dst common.Address, wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHSession) Unlock(_guy common.Address, _wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHSession) Version() (string, error)

+ func (_DelayedWETH *DelayedWETHSession) Withdraw(_wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHSession) Withdraw0(_guy common.Address, _wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHSession) Withdrawals(arg0 common.Address, arg1 common.Address) (struct{ ... }, error)

+ type DelayedWETHTransactor struct

+ func NewDelayedWETHTransactor(address common.Address, transactor bind.ContractTransactor) (*DelayedWETHTransactor, error)

+ func (_DelayedWETH *DelayedWETHTransactor) Approve(opts *bind.TransactOpts, guy common.Address, wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactor) Deposit(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactor) Hold(opts *bind.TransactOpts, _guy common.Address, _wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactor) Initialize(opts *bind.TransactOpts, _owner common.Address, _config common.Address) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactor) Recover(opts *bind.TransactOpts, _wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactor) Transfer(opts *bind.TransactOpts, dst common.Address, wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactor) TransferFrom(opts *bind.TransactOpts, src common.Address, dst common.Address, wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactor) Unlock(opts *bind.TransactOpts, _guy common.Address, _wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactor) Withdraw(opts *bind.TransactOpts, _wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactor) Withdraw0(opts *bind.TransactOpts, _guy common.Address, _wad *big.Int) (*types.Transaction, error)

+ type DelayedWETHTransactorRaw struct

+ Contract *DelayedWETHTransactor

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

+ func (_DelayedWETH *DelayedWETHTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DelayedWETHTransactorSession struct

+ Contract *DelayedWETHTransactor

+ TransactOpts bind.TransactOpts

+ func (_DelayedWETH *DelayedWETHTransactorSession) Approve(guy common.Address, wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactorSession) Deposit() (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactorSession) Hold(_guy common.Address, _wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactorSession) Initialize(_owner common.Address, _config common.Address) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactorSession) Receive() (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactorSession) Recover(_wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactorSession) Transfer(dst common.Address, wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactorSession) TransferFrom(src common.Address, dst common.Address, wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactorSession) Unlock(_guy common.Address, _wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactorSession) Withdraw(_wad *big.Int) (*types.Transaction, error)

+ func (_DelayedWETH *DelayedWETHTransactorSession) Withdraw0(_guy common.Address, _wad *big.Int) (*types.Transaction, error)

+ type DelayedWETHTransfer struct

+ Dst common.Address

+ Raw types.Log

+ Src common.Address

+ Wad *big.Int

+ type DelayedWETHTransferIterator struct

+ Event *DelayedWETHTransfer

+ func (it *DelayedWETHTransferIterator) Close() error

+ func (it *DelayedWETHTransferIterator) Error() error

+ func (it *DelayedWETHTransferIterator) Next() bool

+ type DelayedWETHUnwrap struct

+ Raw types.Log

+ Src common.Address

+ Wad *big.Int

+ type DelayedWETHUnwrapIterator struct

+ Event *DelayedWETHUnwrap

+ func (it *DelayedWETHUnwrapIterator) Close() error

+ func (it *DelayedWETHUnwrapIterator) Error() error

+ func (it *DelayedWETHUnwrapIterator) Next() bool

+ type DelayedWETHWithdrawal struct

+ Raw types.Log

+ Src common.Address

+ Wad *big.Int

+ type DelayedWETHWithdrawalIterator struct

+ Event *DelayedWETHWithdrawal

+ func (it *DelayedWETHWithdrawalIterator) Close() error

+ func (it *DelayedWETHWithdrawalIterator) Error() error

+ func (it *DelayedWETHWithdrawalIterator) Next() bool

+ type DeterministicDeploymentProxy struct

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

+ func NewDeterministicDeploymentProxy(address common.Address, backend bind.ContractBackend) (*DeterministicDeploymentProxy, error)

+ type DeterministicDeploymentProxyCaller struct

+ func NewDeterministicDeploymentProxyCaller(address common.Address, caller bind.ContractCaller) (*DeterministicDeploymentProxyCaller, error)

+ type DeterministicDeploymentProxyCallerRaw struct

+ Contract *DeterministicDeploymentProxyCaller

+ func (_DeterministicDeploymentProxy *DeterministicDeploymentProxyCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type DeterministicDeploymentProxyCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *DeterministicDeploymentProxyCaller

+ type DeterministicDeploymentProxyFilterer struct

+ func NewDeterministicDeploymentProxyFilterer(address common.Address, filterer bind.ContractFilterer) (*DeterministicDeploymentProxyFilterer, error)

+ type DeterministicDeploymentProxyRaw struct

+ Contract *DeterministicDeploymentProxy

+ func (_DeterministicDeploymentProxy *DeterministicDeploymentProxyRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_DeterministicDeploymentProxy *DeterministicDeploymentProxyRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DeterministicDeploymentProxySession struct

+ CallOpts bind.CallOpts

+ Contract *DeterministicDeploymentProxy

+ TransactOpts bind.TransactOpts

+ func (_DeterministicDeploymentProxy *DeterministicDeploymentProxySession) Fallback(calldata []byte) (*types.Transaction, error)

+ type DeterministicDeploymentProxyTransactor struct

+ func NewDeterministicDeploymentProxyTransactor(address common.Address, transactor bind.ContractTransactor) (*DeterministicDeploymentProxyTransactor, error)

+ func (_DeterministicDeploymentProxy *DeterministicDeploymentProxyTransactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error)

+ type DeterministicDeploymentProxyTransactorRaw struct

+ Contract *DeterministicDeploymentProxyTransactor

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

+ func (_DeterministicDeploymentProxy *DeterministicDeploymentProxyTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DeterministicDeploymentProxyTransactorSession struct

+ Contract *DeterministicDeploymentProxyTransactor

+ TransactOpts bind.TransactOpts

+ func (_DeterministicDeploymentProxy *DeterministicDeploymentProxyTransactorSession) Fallback(calldata []byte) (*types.Transaction, error)

type DisputeGameFactoryCaller

+ func (_DisputeGameFactory *DisputeGameFactoryCaller) FindLatestGames(opts *bind.CallOpts, _gameType uint32, _start *big.Int, _n *big.Int) ([]IDisputeGameFactoryGameSearchResult, error)

+ func (_DisputeGameFactory *DisputeGameFactoryCaller) InitBonds(opts *bind.CallOpts, arg0 uint32) (*big.Int, error)

type DisputeGameFactoryCallerSession

+ func (_DisputeGameFactory *DisputeGameFactoryCallerSession) FindLatestGames(_gameType uint32, _start *big.Int, _n *big.Int) ([]IDisputeGameFactoryGameSearchResult, error)

+ func (_DisputeGameFactory *DisputeGameFactoryCallerSession) InitBonds(arg0 uint32) (*big.Int, error)

type DisputeGameFactoryFilterer

+ func (_DisputeGameFactory *DisputeGameFactoryFilterer) FilterInitBondUpdated(opts *bind.FilterOpts, gameType []uint32, newBond []*big.Int) (*DisputeGameFactoryInitBondUpdatedIterator, error)

+ func (_DisputeGameFactory *DisputeGameFactoryFilterer) ParseInitBondUpdated(log types.Log) (*DisputeGameFactoryInitBondUpdated, error)

+ func (_DisputeGameFactory *DisputeGameFactoryFilterer) WatchInitBondUpdated(opts *bind.WatchOpts, sink chan<- *DisputeGameFactoryInitBondUpdated, ...) (event.Subscription, error)

+ type DisputeGameFactoryInitBondUpdated struct

+ GameType uint32

+ NewBond *big.Int

+ Raw types.Log

+ type DisputeGameFactoryInitBondUpdatedIterator struct

+ Event *DisputeGameFactoryInitBondUpdated

+ func (it *DisputeGameFactoryInitBondUpdatedIterator) Close() error

+ func (it *DisputeGameFactoryInitBondUpdatedIterator) Error() error

+ func (it *DisputeGameFactoryInitBondUpdatedIterator) Next() bool

type DisputeGameFactorySession

+ func (_DisputeGameFactory *DisputeGameFactorySession) FindLatestGames(_gameType uint32, _start *big.Int, _n *big.Int) ([]IDisputeGameFactoryGameSearchResult, error)

+ func (_DisputeGameFactory *DisputeGameFactorySession) InitBonds(arg0 uint32) (*big.Int, error)

+ func (_DisputeGameFactory *DisputeGameFactorySession) SetInitBond(_gameType uint32, _initBond *big.Int) (*types.Transaction, error)

type DisputeGameFactoryTransactor

+ func (_DisputeGameFactory *DisputeGameFactoryTransactor) SetInitBond(opts *bind.TransactOpts, _gameType uint32, _initBond *big.Int) (*types.Transaction, error)

type DisputeGameFactoryTransactorSession

+ func (_DisputeGameFactory *DisputeGameFactoryTransactorSession) SetInitBond(_gameType uint32, _initBond *big.Int) (*types.Transaction, error)

+ type EntryPoint struct

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

+ func NewEntryPoint(address common.Address, backend bind.ContractBackend) (*EntryPoint, error)

+ type EntryPointAccountDeployed struct

+ Factory common.Address

+ Paymaster common.Address

+ Raw types.Log

+ Sender common.Address

+ UserOpHash [32]byte

+ type EntryPointAccountDeployedIterator struct

+ Event *EntryPointAccountDeployed

+ func (it *EntryPointAccountDeployedIterator) Close() error

+ func (it *EntryPointAccountDeployedIterator) Error() error

+ func (it *EntryPointAccountDeployedIterator) Next() bool

+ type EntryPointBeforeExecution struct

+ Raw types.Log

+ type EntryPointBeforeExecutionIterator struct

+ Event *EntryPointBeforeExecution

+ func (it *EntryPointBeforeExecutionIterator) Close() error

+ func (it *EntryPointBeforeExecutionIterator) Error() error

+ func (it *EntryPointBeforeExecutionIterator) Next() bool

+ type EntryPointCaller struct

+ func NewEntryPointCaller(address common.Address, caller bind.ContractCaller) (*EntryPointCaller, error)

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

+ func (_EntryPoint *EntryPointCaller) Deposits(opts *bind.CallOpts, arg0 common.Address) (struct{ ... }, error)

+ func (_EntryPoint *EntryPointCaller) GetDepositInfo(opts *bind.CallOpts, account common.Address) (IStakeManagerDepositInfo, error)

+ func (_EntryPoint *EntryPointCaller) GetNonce(opts *bind.CallOpts, sender common.Address, key *big.Int) (*big.Int, error)

+ func (_EntryPoint *EntryPointCaller) GetUserOpHash(opts *bind.CallOpts, userOp UserOperation) ([32]byte, error)

+ func (_EntryPoint *EntryPointCaller) NonceSequenceNumber(opts *bind.CallOpts, arg0 common.Address, arg1 *big.Int) (*big.Int, error)

+ func (_EntryPoint *EntryPointCaller) SIGVALIDATIONFAILED(opts *bind.CallOpts) (*big.Int, error)

+ func (_EntryPoint *EntryPointCaller) ValidateSenderAndPaymaster(opts *bind.CallOpts, initCode []byte, sender common.Address, ...) error

+ type EntryPointCallerRaw struct

+ Contract *EntryPointCaller

+ func (_EntryPoint *EntryPointCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type EntryPointCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *EntryPointCaller

+ func (_EntryPoint *EntryPointCallerSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_EntryPoint *EntryPointCallerSession) Deposits(arg0 common.Address) (struct{ ... }, error)

+ func (_EntryPoint *EntryPointCallerSession) GetDepositInfo(account common.Address) (IStakeManagerDepositInfo, error)

+ func (_EntryPoint *EntryPointCallerSession) GetNonce(sender common.Address, key *big.Int) (*big.Int, error)

+ func (_EntryPoint *EntryPointCallerSession) GetUserOpHash(userOp UserOperation) ([32]byte, error)

+ func (_EntryPoint *EntryPointCallerSession) NonceSequenceNumber(arg0 common.Address, arg1 *big.Int) (*big.Int, error)

+ func (_EntryPoint *EntryPointCallerSession) SIGVALIDATIONFAILED() (*big.Int, error)

+ func (_EntryPoint *EntryPointCallerSession) ValidateSenderAndPaymaster(initCode []byte, sender common.Address, paymasterAndData []byte) error

+ type EntryPointDeposited struct

+ Account common.Address

+ Raw types.Log

+ TotalDeposit *big.Int

+ type EntryPointDepositedIterator struct

+ Event *EntryPointDeposited

+ func (it *EntryPointDepositedIterator) Close() error

+ func (it *EntryPointDepositedIterator) Error() error

+ func (it *EntryPointDepositedIterator) Next() bool

+ type EntryPointFilterer struct

+ func NewEntryPointFilterer(address common.Address, filterer bind.ContractFilterer) (*EntryPointFilterer, error)

+ func (_EntryPoint *EntryPointFilterer) FilterAccountDeployed(opts *bind.FilterOpts, userOpHash [][32]byte, sender []common.Address) (*EntryPointAccountDeployedIterator, error)

+ func (_EntryPoint *EntryPointFilterer) FilterBeforeExecution(opts *bind.FilterOpts) (*EntryPointBeforeExecutionIterator, error)

+ func (_EntryPoint *EntryPointFilterer) FilterDeposited(opts *bind.FilterOpts, account []common.Address) (*EntryPointDepositedIterator, error)

+ func (_EntryPoint *EntryPointFilterer) FilterSignatureAggregatorChanged(opts *bind.FilterOpts, aggregator []common.Address) (*EntryPointSignatureAggregatorChangedIterator, error)

+ func (_EntryPoint *EntryPointFilterer) FilterStakeLocked(opts *bind.FilterOpts, account []common.Address) (*EntryPointStakeLockedIterator, error)

+ func (_EntryPoint *EntryPointFilterer) FilterStakeUnlocked(opts *bind.FilterOpts, account []common.Address) (*EntryPointStakeUnlockedIterator, error)

+ func (_EntryPoint *EntryPointFilterer) FilterStakeWithdrawn(opts *bind.FilterOpts, account []common.Address) (*EntryPointStakeWithdrawnIterator, error)

+ func (_EntryPoint *EntryPointFilterer) FilterUserOperationEvent(opts *bind.FilterOpts, userOpHash [][32]byte, sender []common.Address, ...) (*EntryPointUserOperationEventIterator, error)

+ func (_EntryPoint *EntryPointFilterer) FilterUserOperationRevertReason(opts *bind.FilterOpts, userOpHash [][32]byte, sender []common.Address) (*EntryPointUserOperationRevertReasonIterator, error)

+ func (_EntryPoint *EntryPointFilterer) FilterWithdrawn(opts *bind.FilterOpts, account []common.Address) (*EntryPointWithdrawnIterator, error)

+ func (_EntryPoint *EntryPointFilterer) ParseAccountDeployed(log types.Log) (*EntryPointAccountDeployed, error)

+ func (_EntryPoint *EntryPointFilterer) ParseBeforeExecution(log types.Log) (*EntryPointBeforeExecution, error)

+ func (_EntryPoint *EntryPointFilterer) ParseDeposited(log types.Log) (*EntryPointDeposited, error)

+ func (_EntryPoint *EntryPointFilterer) ParseSignatureAggregatorChanged(log types.Log) (*EntryPointSignatureAggregatorChanged, error)

+ func (_EntryPoint *EntryPointFilterer) ParseStakeLocked(log types.Log) (*EntryPointStakeLocked, error)

+ func (_EntryPoint *EntryPointFilterer) ParseStakeUnlocked(log types.Log) (*EntryPointStakeUnlocked, error)

+ func (_EntryPoint *EntryPointFilterer) ParseStakeWithdrawn(log types.Log) (*EntryPointStakeWithdrawn, error)

+ func (_EntryPoint *EntryPointFilterer) ParseUserOperationEvent(log types.Log) (*EntryPointUserOperationEvent, error)

+ func (_EntryPoint *EntryPointFilterer) ParseUserOperationRevertReason(log types.Log) (*EntryPointUserOperationRevertReason, error)

+ func (_EntryPoint *EntryPointFilterer) ParseWithdrawn(log types.Log) (*EntryPointWithdrawn, error)

+ func (_EntryPoint *EntryPointFilterer) WatchAccountDeployed(opts *bind.WatchOpts, sink chan<- *EntryPointAccountDeployed, ...) (event.Subscription, error)

+ func (_EntryPoint *EntryPointFilterer) WatchBeforeExecution(opts *bind.WatchOpts, sink chan<- *EntryPointBeforeExecution) (event.Subscription, error)

+ func (_EntryPoint *EntryPointFilterer) WatchDeposited(opts *bind.WatchOpts, sink chan<- *EntryPointDeposited, ...) (event.Subscription, error)

+ func (_EntryPoint *EntryPointFilterer) WatchSignatureAggregatorChanged(opts *bind.WatchOpts, sink chan<- *EntryPointSignatureAggregatorChanged, ...) (event.Subscription, error)

+ func (_EntryPoint *EntryPointFilterer) WatchStakeLocked(opts *bind.WatchOpts, sink chan<- *EntryPointStakeLocked, ...) (event.Subscription, error)

+ func (_EntryPoint *EntryPointFilterer) WatchStakeUnlocked(opts *bind.WatchOpts, sink chan<- *EntryPointStakeUnlocked, ...) (event.Subscription, error)

+ func (_EntryPoint *EntryPointFilterer) WatchStakeWithdrawn(opts *bind.WatchOpts, sink chan<- *EntryPointStakeWithdrawn, ...) (event.Subscription, error)

+ func (_EntryPoint *EntryPointFilterer) WatchUserOperationEvent(opts *bind.WatchOpts, sink chan<- *EntryPointUserOperationEvent, ...) (event.Subscription, error)

+ func (_EntryPoint *EntryPointFilterer) WatchUserOperationRevertReason(opts *bind.WatchOpts, sink chan<- *EntryPointUserOperationRevertReason, ...) (event.Subscription, error)

+ func (_EntryPoint *EntryPointFilterer) WatchWithdrawn(opts *bind.WatchOpts, sink chan<- *EntryPointWithdrawn, ...) (event.Subscription, error)

+ type EntryPointMemoryUserOp struct

+ CallGasLimit *big.Int

+ MaxFeePerGas *big.Int

+ MaxPriorityFeePerGas *big.Int

+ Nonce *big.Int

+ Paymaster common.Address

+ PreVerificationGas *big.Int

+ Sender common.Address

+ VerificationGasLimit *big.Int

+ type EntryPointRaw struct

+ Contract *EntryPoint

+ func (_EntryPoint *EntryPointRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_EntryPoint *EntryPointRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type EntryPointSession struct

+ CallOpts bind.CallOpts

+ Contract *EntryPoint

+ TransactOpts bind.TransactOpts

+ func (_EntryPoint *EntryPointSession) AddStake(unstakeDelaySec uint32) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_EntryPoint *EntryPointSession) DepositTo(account common.Address) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointSession) Deposits(arg0 common.Address) (struct{ ... }, error)

+ func (_EntryPoint *EntryPointSession) GetDepositInfo(account common.Address) (IStakeManagerDepositInfo, error)

+ func (_EntryPoint *EntryPointSession) GetNonce(sender common.Address, key *big.Int) (*big.Int, error)

+ func (_EntryPoint *EntryPointSession) GetSenderAddress(initCode []byte) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointSession) GetUserOpHash(userOp UserOperation) ([32]byte, error)

+ func (_EntryPoint *EntryPointSession) HandleAggregatedOps(opsPerAggregator []IEntryPointUserOpsPerAggregator, beneficiary common.Address) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointSession) HandleOps(ops []UserOperation, beneficiary common.Address) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointSession) IncrementNonce(key *big.Int) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointSession) InnerHandleOp(callData []byte, opInfo EntryPointUserOpInfo, context []byte) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointSession) NonceSequenceNumber(arg0 common.Address, arg1 *big.Int) (*big.Int, error)

+ func (_EntryPoint *EntryPointSession) Receive() (*types.Transaction, error)

+ func (_EntryPoint *EntryPointSession) SIGVALIDATIONFAILED() (*big.Int, error)

+ func (_EntryPoint *EntryPointSession) SimulateHandleOp(op UserOperation, target common.Address, targetCallData []byte) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointSession) SimulateValidation(userOp UserOperation) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointSession) UnlockStake() (*types.Transaction, error)

+ func (_EntryPoint *EntryPointSession) ValidateSenderAndPaymaster(initCode []byte, sender common.Address, paymasterAndData []byte) error

+ func (_EntryPoint *EntryPointSession) WithdrawStake(withdrawAddress common.Address) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointSession) WithdrawTo(withdrawAddress common.Address, withdrawAmount *big.Int) (*types.Transaction, error)

+ type EntryPointSignatureAggregatorChanged struct

+ Aggregator common.Address

+ Raw types.Log

+ type EntryPointSignatureAggregatorChangedIterator struct

+ Event *EntryPointSignatureAggregatorChanged

+ func (it *EntryPointSignatureAggregatorChangedIterator) Close() error

+ func (it *EntryPointSignatureAggregatorChangedIterator) Error() error

+ func (it *EntryPointSignatureAggregatorChangedIterator) Next() bool

+ type EntryPointStakeLocked struct

+ Account common.Address

+ Raw types.Log

+ TotalStaked *big.Int

+ UnstakeDelaySec *big.Int

+ type EntryPointStakeLockedIterator struct

+ Event *EntryPointStakeLocked

+ func (it *EntryPointStakeLockedIterator) Close() error

+ func (it *EntryPointStakeLockedIterator) Error() error

+ func (it *EntryPointStakeLockedIterator) Next() bool

+ type EntryPointStakeUnlocked struct

+ Account common.Address

+ Raw types.Log

+ WithdrawTime *big.Int

+ type EntryPointStakeUnlockedIterator struct

+ Event *EntryPointStakeUnlocked

+ func (it *EntryPointStakeUnlockedIterator) Close() error

+ func (it *EntryPointStakeUnlockedIterator) Error() error

+ func (it *EntryPointStakeUnlockedIterator) Next() bool

+ type EntryPointStakeWithdrawn struct

+ Account common.Address

+ Amount *big.Int

+ Raw types.Log

+ WithdrawAddress common.Address

+ type EntryPointStakeWithdrawnIterator struct

+ Event *EntryPointStakeWithdrawn

+ func (it *EntryPointStakeWithdrawnIterator) Close() error

+ func (it *EntryPointStakeWithdrawnIterator) Error() error

+ func (it *EntryPointStakeWithdrawnIterator) Next() bool

+ type EntryPointTransactor struct

+ func NewEntryPointTransactor(address common.Address, transactor bind.ContractTransactor) (*EntryPointTransactor, error)

+ func (_EntryPoint *EntryPointTransactor) AddStake(opts *bind.TransactOpts, unstakeDelaySec uint32) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactor) DepositTo(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactor) GetSenderAddress(opts *bind.TransactOpts, initCode []byte) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactor) HandleAggregatedOps(opts *bind.TransactOpts, opsPerAggregator []IEntryPointUserOpsPerAggregator, ...) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactor) HandleOps(opts *bind.TransactOpts, ops []UserOperation, beneficiary common.Address) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactor) IncrementNonce(opts *bind.TransactOpts, key *big.Int) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactor) InnerHandleOp(opts *bind.TransactOpts, callData []byte, opInfo EntryPointUserOpInfo, ...) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactor) SimulateHandleOp(opts *bind.TransactOpts, op UserOperation, target common.Address, ...) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactor) SimulateValidation(opts *bind.TransactOpts, userOp UserOperation) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactor) UnlockStake(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactor) WithdrawStake(opts *bind.TransactOpts, withdrawAddress common.Address) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactor) WithdrawTo(opts *bind.TransactOpts, withdrawAddress common.Address, ...) (*types.Transaction, error)

+ type EntryPointTransactorRaw struct

+ Contract *EntryPointTransactor

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

+ func (_EntryPoint *EntryPointTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type EntryPointTransactorSession struct

+ Contract *EntryPointTransactor

+ TransactOpts bind.TransactOpts

+ func (_EntryPoint *EntryPointTransactorSession) AddStake(unstakeDelaySec uint32) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactorSession) DepositTo(account common.Address) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactorSession) GetSenderAddress(initCode []byte) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactorSession) HandleAggregatedOps(opsPerAggregator []IEntryPointUserOpsPerAggregator, beneficiary common.Address) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactorSession) HandleOps(ops []UserOperation, beneficiary common.Address) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactorSession) IncrementNonce(key *big.Int) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactorSession) InnerHandleOp(callData []byte, opInfo EntryPointUserOpInfo, context []byte) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactorSession) Receive() (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactorSession) SimulateHandleOp(op UserOperation, target common.Address, targetCallData []byte) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactorSession) SimulateValidation(userOp UserOperation) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactorSession) UnlockStake() (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactorSession) WithdrawStake(withdrawAddress common.Address) (*types.Transaction, error)

+ func (_EntryPoint *EntryPointTransactorSession) WithdrawTo(withdrawAddress common.Address, withdrawAmount *big.Int) (*types.Transaction, error)

+ type EntryPointUserOpInfo struct

+ ContextOffset *big.Int

+ MUserOp EntryPointMemoryUserOp

+ PreOpGas *big.Int

+ Prefund *big.Int

+ UserOpHash [32]byte

+ type EntryPointUserOperationEvent struct

+ ActualGasCost *big.Int

+ ActualGasUsed *big.Int

+ Nonce *big.Int

+ Paymaster common.Address

+ Raw types.Log

+ Sender common.Address

+ Success bool

+ UserOpHash [32]byte

+ type EntryPointUserOperationEventIterator struct

+ Event *EntryPointUserOperationEvent

+ func (it *EntryPointUserOperationEventIterator) Close() error

+ func (it *EntryPointUserOperationEventIterator) Error() error

+ func (it *EntryPointUserOperationEventIterator) Next() bool

+ type EntryPointUserOperationRevertReason struct

+ Nonce *big.Int

+ Raw types.Log

+ RevertReason []byte

+ Sender common.Address

+ UserOpHash [32]byte

+ type EntryPointUserOperationRevertReasonIterator struct

+ Event *EntryPointUserOperationRevertReason

+ func (it *EntryPointUserOperationRevertReasonIterator) Close() error

+ func (it *EntryPointUserOperationRevertReasonIterator) Error() error

+ func (it *EntryPointUserOperationRevertReasonIterator) Next() bool

+ type EntryPointWithdrawn struct

+ Account common.Address

+ Amount *big.Int

+ Raw types.Log

+ WithdrawAddress common.Address

+ type EntryPointWithdrawnIterator struct

+ Event *EntryPointWithdrawn

+ func (it *EntryPointWithdrawnIterator) Close() error

+ func (it *EntryPointWithdrawnIterator) Error() error

+ func (it *EntryPointWithdrawnIterator) Next() bool

type FaultDisputeGameCaller

+ func (_FaultDisputeGame *FaultDisputeGameCaller) AbsolutePrestate(opts *bind.CallOpts) ([32]byte, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) ClaimedBondFlag(opts *bind.CallOpts) (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) Credit(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) GameDuration(opts *bind.CallOpts) (uint64, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) GetRequiredBond(opts *bind.CallOpts, _position *big.Int) (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) L2ChainId(opts *bind.CallOpts) (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) MaxGameDepth(opts *bind.CallOpts) (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) ResolvedAt(opts *bind.CallOpts) (uint64, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) SplitDepth(opts *bind.CallOpts) (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) StartingBlockNumber(opts *bind.CallOpts) (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) StartingOutputRoot(opts *bind.CallOpts) (struct{ ... }, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) StartingRootHash(opts *bind.CallOpts) ([32]byte, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) Vm(opts *bind.CallOpts) (common.Address, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) Weth(opts *bind.CallOpts) (common.Address, error)

type FaultDisputeGameCallerSession

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) AbsolutePrestate() ([32]byte, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) ClaimedBondFlag() (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) Credit(arg0 common.Address) (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) GameDuration() (uint64, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) GetRequiredBond(_position *big.Int) (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) L2ChainId() (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) MaxGameDepth() (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) ResolvedAt() (uint64, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) SplitDepth() (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) StartingBlockNumber() (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) StartingOutputRoot() (struct{ ... }, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) StartingRootHash() ([32]byte, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) Vm() (common.Address, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) Weth() (common.Address, error)

type FaultDisputeGameSession

+ func (_FaultDisputeGame *FaultDisputeGameSession) AbsolutePrestate() ([32]byte, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) ClaimCredit(_recipient common.Address) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) ClaimedBondFlag() (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) Credit(arg0 common.Address) (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) Fallback(calldata []byte) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) GameDuration() (uint64, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) GetRequiredBond(_position *big.Int) (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) L2ChainId() (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) MaxGameDepth() (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) Receive() (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) ResolvedAt() (uint64, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) SplitDepth() (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) StartingBlockNumber() (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) StartingOutputRoot() (struct{ ... }, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) StartingRootHash() ([32]byte, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) Vm() (common.Address, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) Weth() (common.Address, error)

type FaultDisputeGameTransactor

+ func (_FaultDisputeGame *FaultDisputeGameTransactor) ClaimCredit(opts *bind.TransactOpts, _recipient common.Address) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameTransactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

type FaultDisputeGameTransactorSession

+ func (_FaultDisputeGame *FaultDisputeGameTransactorSession) ClaimCredit(_recipient common.Address) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameTransactorSession) Fallback(calldata []byte) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameTransactorSession) Receive() (*types.Transaction, error)

type GasPriceOracleCaller

+ func (_GasPriceOracle *GasPriceOracleCaller) BaseFeeScalar(opts *bind.CallOpts) (uint32, error)

+ func (_GasPriceOracle *GasPriceOracleCaller) BlobBaseFee(opts *bind.CallOpts) (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleCaller) BlobBaseFeeScalar(opts *bind.CallOpts) (uint32, error)

+ func (_GasPriceOracle *GasPriceOracleCaller) IsEcotone(opts *bind.CallOpts) (bool, error)

type GasPriceOracleCallerSession

+ func (_GasPriceOracle *GasPriceOracleCallerSession) BaseFeeScalar() (uint32, error)

+ func (_GasPriceOracle *GasPriceOracleCallerSession) BlobBaseFee() (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleCallerSession) BlobBaseFeeScalar() (uint32, error)

+ func (_GasPriceOracle *GasPriceOracleCallerSession) IsEcotone() (bool, error)

type GasPriceOracleSession

+ func (_GasPriceOracle *GasPriceOracleSession) BaseFeeScalar() (uint32, error)

+ func (_GasPriceOracle *GasPriceOracleSession) BlobBaseFee() (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleSession) BlobBaseFeeScalar() (uint32, error)

+ func (_GasPriceOracle *GasPriceOracleSession) IsEcotone() (bool, error)

+ func (_GasPriceOracle *GasPriceOracleSession) SetEcotone() (*types.Transaction, error)

type GasPriceOracleTransactor

+ func (_GasPriceOracle *GasPriceOracleTransactor) SetEcotone(opts *bind.TransactOpts) (*types.Transaction, error)

type GasPriceOracleTransactorSession

+ func (_GasPriceOracle *GasPriceOracleTransactorSession) SetEcotone() (*types.Transaction, error)

+ type IAllowanceTransferAllowanceTransferDetails struct

+ Amount *big.Int

+ From common.Address

+ To common.Address

+ Token common.Address

+ type IAllowanceTransferPermitBatch struct

+ Details []IAllowanceTransferPermitDetails

+ SigDeadline *big.Int

+ Spender common.Address

+ type IAllowanceTransferPermitDetails struct

+ Amount *big.Int

+ Expiration *big.Int

+ Nonce *big.Int

+ Token common.Address

+ type IAllowanceTransferPermitSingle struct

+ Details IAllowanceTransferPermitDetails

+ SigDeadline *big.Int

+ Spender common.Address

+ type IAllowanceTransferTokenSpenderPair struct

+ Spender common.Address

+ Token common.Address

+ type IDisputeGameFactoryGameSearchResult struct

+ ExtraData []byte

+ Index *big.Int

+ Metadata [32]byte

+ RootClaim [32]byte

+ Timestamp uint64

+ type IEntryPointUserOpsPerAggregator struct

+ Aggregator common.Address

+ Signature []byte

+ UserOps []UserOperation

+ type ISignatureTransferPermitBatchTransferFrom struct

+ Deadline *big.Int

+ Nonce *big.Int

+ Permitted []ISignatureTransferTokenPermissions

+ type ISignatureTransferPermitTransferFrom struct

+ Deadline *big.Int

+ Nonce *big.Int

+ Permitted ISignatureTransferTokenPermissions

+ type ISignatureTransferSignatureTransferDetails struct

+ RequestedAmount *big.Int

+ To common.Address

+ type ISignatureTransferTokenPermissions struct

+ Amount *big.Int

+ Token common.Address

+ type IStakeManagerDepositInfo struct

+ Deposit *big.Int

+ Stake *big.Int

+ Staked bool

+ UnstakeDelaySec uint32

+ WithdrawTime *big.Int

type L1BlockCaller

+ func (_L1Block *L1BlockCaller) BaseFeeScalar(opts *bind.CallOpts) (uint32, error)

+ func (_L1Block *L1BlockCaller) BlobBaseFee(opts *bind.CallOpts) (*big.Int, error)

+ func (_L1Block *L1BlockCaller) BlobBaseFeeScalar(opts *bind.CallOpts) (uint32, error)

type L1BlockCallerSession

+ func (_L1Block *L1BlockCallerSession) BaseFeeScalar() (uint32, error)

+ func (_L1Block *L1BlockCallerSession) BlobBaseFee() (*big.Int, error)

+ func (_L1Block *L1BlockCallerSession) BlobBaseFeeScalar() (uint32, error)

type L1BlockSession

+ func (_L1Block *L1BlockSession) BaseFeeScalar() (uint32, error)

+ func (_L1Block *L1BlockSession) BlobBaseFee() (*big.Int, error)

+ func (_L1Block *L1BlockSession) BlobBaseFeeScalar() (uint32, error)

+ func (_L1Block *L1BlockSession) SetL1BlockValuesEcotone() (*types.Transaction, error)

type L1BlockTransactor

+ func (_L1Block *L1BlockTransactor) SetL1BlockValuesEcotone(opts *bind.TransactOpts) (*types.Transaction, error)

type L1BlockTransactorSession

+ func (_L1Block *L1BlockTransactorSession) SetL1BlockValuesEcotone() (*types.Transaction, error)

type L1CrossDomainMessengerCaller

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCaller) OtherMessenger(opts *bind.CallOpts) (common.Address, error)

type L1CrossDomainMessengerCallerSession

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) OtherMessenger() (common.Address, error)

type L1CrossDomainMessengerSession

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) OtherMessenger() (common.Address, error)

type L2CrossDomainMessengerCaller

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) OtherMessenger(opts *bind.CallOpts) (common.Address, error)

type L2CrossDomainMessengerCallerSession

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) OtherMessenger() (common.Address, error)

type L2CrossDomainMessengerSession

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) OtherMessenger() (common.Address, error)

+ type LibKeccakStateMatrix struct

+ State [25]uint64

type MIPSCaller

+ func (_MIPS *MIPSCaller) Version(opts *bind.CallOpts) (string, error)

type MIPSCallerSession

+ func (_MIPS *MIPSCallerSession) Version() (string, error)

type MIPSSession

+ func (_MIPS *MIPSSession) Version() (string, error)

+ type MultiCall3 struct

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

+ func NewMultiCall3(address common.Address, backend bind.ContractBackend) (*MultiCall3, error)

+ type MultiCall3Caller struct

+ func NewMultiCall3Caller(address common.Address, caller bind.ContractCaller) (*MultiCall3Caller, error)

+ func (_MultiCall3 *MultiCall3Caller) GetBasefee(opts *bind.CallOpts) (*big.Int, error)

+ func (_MultiCall3 *MultiCall3Caller) GetBlockHash(opts *bind.CallOpts, blockNumber *big.Int) ([32]byte, error)

+ func (_MultiCall3 *MultiCall3Caller) GetBlockNumber(opts *bind.CallOpts) (*big.Int, error)

+ func (_MultiCall3 *MultiCall3Caller) GetChainId(opts *bind.CallOpts) (*big.Int, error)

+ func (_MultiCall3 *MultiCall3Caller) GetCurrentBlockCoinbase(opts *bind.CallOpts) (common.Address, error)

+ func (_MultiCall3 *MultiCall3Caller) GetCurrentBlockDifficulty(opts *bind.CallOpts) (*big.Int, error)

+ func (_MultiCall3 *MultiCall3Caller) GetCurrentBlockGasLimit(opts *bind.CallOpts) (*big.Int, error)

+ func (_MultiCall3 *MultiCall3Caller) GetCurrentBlockTimestamp(opts *bind.CallOpts) (*big.Int, error)

+ func (_MultiCall3 *MultiCall3Caller) GetEthBalance(opts *bind.CallOpts, addr common.Address) (*big.Int, error)

+ func (_MultiCall3 *MultiCall3Caller) GetLastBlockHash(opts *bind.CallOpts) ([32]byte, error)

+ type MultiCall3CallerRaw struct

+ Contract *MultiCall3Caller

+ func (_MultiCall3 *MultiCall3CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type MultiCall3CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *MultiCall3Caller

+ func (_MultiCall3 *MultiCall3CallerSession) GetBasefee() (*big.Int, error)

+ func (_MultiCall3 *MultiCall3CallerSession) GetBlockHash(blockNumber *big.Int) ([32]byte, error)

+ func (_MultiCall3 *MultiCall3CallerSession) GetBlockNumber() (*big.Int, error)

+ func (_MultiCall3 *MultiCall3CallerSession) GetChainId() (*big.Int, error)

+ func (_MultiCall3 *MultiCall3CallerSession) GetCurrentBlockCoinbase() (common.Address, error)

+ func (_MultiCall3 *MultiCall3CallerSession) GetCurrentBlockDifficulty() (*big.Int, error)

+ func (_MultiCall3 *MultiCall3CallerSession) GetCurrentBlockGasLimit() (*big.Int, error)

+ func (_MultiCall3 *MultiCall3CallerSession) GetCurrentBlockTimestamp() (*big.Int, error)

+ func (_MultiCall3 *MultiCall3CallerSession) GetEthBalance(addr common.Address) (*big.Int, error)

+ func (_MultiCall3 *MultiCall3CallerSession) GetLastBlockHash() ([32]byte, error)

+ type MultiCall3Filterer struct

+ func NewMultiCall3Filterer(address common.Address, filterer bind.ContractFilterer) (*MultiCall3Filterer, error)

+ type MultiCall3Raw struct

+ Contract *MultiCall3

+ func (_MultiCall3 *MultiCall3Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_MultiCall3 *MultiCall3Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MultiCall3Session struct

+ CallOpts bind.CallOpts

+ Contract *MultiCall3

+ TransactOpts bind.TransactOpts

+ func (_MultiCall3 *MultiCall3Session) Aggregate(calls []Multicall3Call) (*types.Transaction, error)

+ func (_MultiCall3 *MultiCall3Session) Aggregate3(calls []Multicall3Call3) (*types.Transaction, error)

+ func (_MultiCall3 *MultiCall3Session) Aggregate3Value(calls []Multicall3Call3Value) (*types.Transaction, error)

+ func (_MultiCall3 *MultiCall3Session) BlockAndAggregate(calls []Multicall3Call) (*types.Transaction, error)

+ func (_MultiCall3 *MultiCall3Session) GetBasefee() (*big.Int, error)

+ func (_MultiCall3 *MultiCall3Session) GetBlockHash(blockNumber *big.Int) ([32]byte, error)

+ func (_MultiCall3 *MultiCall3Session) GetBlockNumber() (*big.Int, error)

+ func (_MultiCall3 *MultiCall3Session) GetChainId() (*big.Int, error)

+ func (_MultiCall3 *MultiCall3Session) GetCurrentBlockCoinbase() (common.Address, error)

+ func (_MultiCall3 *MultiCall3Session) GetCurrentBlockDifficulty() (*big.Int, error)

+ func (_MultiCall3 *MultiCall3Session) GetCurrentBlockGasLimit() (*big.Int, error)

+ func (_MultiCall3 *MultiCall3Session) GetCurrentBlockTimestamp() (*big.Int, error)

+ func (_MultiCall3 *MultiCall3Session) GetEthBalance(addr common.Address) (*big.Int, error)

+ func (_MultiCall3 *MultiCall3Session) GetLastBlockHash() ([32]byte, error)

+ func (_MultiCall3 *MultiCall3Session) TryAggregate(requireSuccess bool, calls []Multicall3Call) (*types.Transaction, error)

+ func (_MultiCall3 *MultiCall3Session) TryBlockAndAggregate(requireSuccess bool, calls []Multicall3Call) (*types.Transaction, error)

+ type MultiCall3Transactor struct

+ func NewMultiCall3Transactor(address common.Address, transactor bind.ContractTransactor) (*MultiCall3Transactor, error)

+ func (_MultiCall3 *MultiCall3Transactor) Aggregate(opts *bind.TransactOpts, calls []Multicall3Call) (*types.Transaction, error)

+ func (_MultiCall3 *MultiCall3Transactor) Aggregate3(opts *bind.TransactOpts, calls []Multicall3Call3) (*types.Transaction, error)

+ func (_MultiCall3 *MultiCall3Transactor) Aggregate3Value(opts *bind.TransactOpts, calls []Multicall3Call3Value) (*types.Transaction, error)

+ func (_MultiCall3 *MultiCall3Transactor) BlockAndAggregate(opts *bind.TransactOpts, calls []Multicall3Call) (*types.Transaction, error)

+ func (_MultiCall3 *MultiCall3Transactor) TryAggregate(opts *bind.TransactOpts, requireSuccess bool, calls []Multicall3Call) (*types.Transaction, error)

+ func (_MultiCall3 *MultiCall3Transactor) TryBlockAndAggregate(opts *bind.TransactOpts, requireSuccess bool, calls []Multicall3Call) (*types.Transaction, error)

+ type MultiCall3TransactorRaw struct

+ Contract *MultiCall3Transactor

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

+ func (_MultiCall3 *MultiCall3TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MultiCall3TransactorSession struct

+ Contract *MultiCall3Transactor

+ TransactOpts bind.TransactOpts

+ func (_MultiCall3 *MultiCall3TransactorSession) Aggregate(calls []Multicall3Call) (*types.Transaction, error)

+ func (_MultiCall3 *MultiCall3TransactorSession) Aggregate3(calls []Multicall3Call3) (*types.Transaction, error)

+ func (_MultiCall3 *MultiCall3TransactorSession) Aggregate3Value(calls []Multicall3Call3Value) (*types.Transaction, error)

+ func (_MultiCall3 *MultiCall3TransactorSession) BlockAndAggregate(calls []Multicall3Call) (*types.Transaction, error)

+ func (_MultiCall3 *MultiCall3TransactorSession) TryAggregate(requireSuccess bool, calls []Multicall3Call) (*types.Transaction, error)

+ func (_MultiCall3 *MultiCall3TransactorSession) TryBlockAndAggregate(requireSuccess bool, calls []Multicall3Call) (*types.Transaction, error)

+ type MultiSendCallOnlyV130 struct

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

+ func NewMultiSendCallOnlyV130(address common.Address, backend bind.ContractBackend) (*MultiSendCallOnlyV130, error)

+ type MultiSendCallOnlyV130Caller struct

+ func NewMultiSendCallOnlyV130Caller(address common.Address, caller bind.ContractCaller) (*MultiSendCallOnlyV130Caller, error)

+ type MultiSendCallOnlyV130CallerRaw struct

+ Contract *MultiSendCallOnlyV130Caller

+ func (_MultiSendCallOnlyV130 *MultiSendCallOnlyV130CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type MultiSendCallOnlyV130CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *MultiSendCallOnlyV130Caller

+ type MultiSendCallOnlyV130Filterer struct

+ func NewMultiSendCallOnlyV130Filterer(address common.Address, filterer bind.ContractFilterer) (*MultiSendCallOnlyV130Filterer, error)

+ type MultiSendCallOnlyV130Raw struct

+ Contract *MultiSendCallOnlyV130

+ func (_MultiSendCallOnlyV130 *MultiSendCallOnlyV130Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_MultiSendCallOnlyV130 *MultiSendCallOnlyV130Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MultiSendCallOnlyV130Session struct

+ CallOpts bind.CallOpts

+ Contract *MultiSendCallOnlyV130

+ TransactOpts bind.TransactOpts

+ func (_MultiSendCallOnlyV130 *MultiSendCallOnlyV130Session) MultiSend(transactions []byte) (*types.Transaction, error)

+ type MultiSendCallOnlyV130Transactor struct

+ func NewMultiSendCallOnlyV130Transactor(address common.Address, transactor bind.ContractTransactor) (*MultiSendCallOnlyV130Transactor, error)

+ func (_MultiSendCallOnlyV130 *MultiSendCallOnlyV130Transactor) MultiSend(opts *bind.TransactOpts, transactions []byte) (*types.Transaction, error)

+ type MultiSendCallOnlyV130TransactorRaw struct

+ Contract *MultiSendCallOnlyV130Transactor

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

+ func (_MultiSendCallOnlyV130 *MultiSendCallOnlyV130TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MultiSendCallOnlyV130TransactorSession struct

+ Contract *MultiSendCallOnlyV130Transactor

+ TransactOpts bind.TransactOpts

+ func (_MultiSendCallOnlyV130 *MultiSendCallOnlyV130TransactorSession) MultiSend(transactions []byte) (*types.Transaction, error)

+ type MultiSendV130 struct

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

+ func NewMultiSendV130(address common.Address, backend bind.ContractBackend) (*MultiSendV130, error)

+ type MultiSendV130Caller struct

+ func NewMultiSendV130Caller(address common.Address, caller bind.ContractCaller) (*MultiSendV130Caller, error)

+ type MultiSendV130CallerRaw struct

+ Contract *MultiSendV130Caller

+ func (_MultiSendV130 *MultiSendV130CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type MultiSendV130CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *MultiSendV130Caller

+ type MultiSendV130Filterer struct

+ func NewMultiSendV130Filterer(address common.Address, filterer bind.ContractFilterer) (*MultiSendV130Filterer, error)

+ type MultiSendV130Raw struct

+ Contract *MultiSendV130

+ func (_MultiSendV130 *MultiSendV130Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_MultiSendV130 *MultiSendV130Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MultiSendV130Session struct

+ CallOpts bind.CallOpts

+ Contract *MultiSendV130

+ TransactOpts bind.TransactOpts

+ func (_MultiSendV130 *MultiSendV130Session) MultiSend(transactions []byte) (*types.Transaction, error)

+ type MultiSendV130Transactor struct

+ func NewMultiSendV130Transactor(address common.Address, transactor bind.ContractTransactor) (*MultiSendV130Transactor, error)

+ func (_MultiSendV130 *MultiSendV130Transactor) MultiSend(opts *bind.TransactOpts, transactions []byte) (*types.Transaction, error)

+ type MultiSendV130TransactorRaw struct

+ Contract *MultiSendV130Transactor

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

+ func (_MultiSendV130 *MultiSendV130TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MultiSendV130TransactorSession struct

+ Contract *MultiSendV130Transactor

+ TransactOpts bind.TransactOpts

+ func (_MultiSendV130 *MultiSendV130TransactorSession) MultiSend(transactions []byte) (*types.Transaction, error)

+ type Multicall3Call struct

+ CallData []byte

+ Target common.Address

+ type Multicall3Call3 struct

+ AllowFailure bool

+ CallData []byte

+ Target common.Address

+ type Multicall3Call3Value struct

+ AllowFailure bool

+ CallData []byte

+ Target common.Address

+ Value *big.Int

+ type Multicall3Result struct

+ ReturnData []byte

+ Success bool

+ type Permit2 struct

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

+ func NewPermit2(address common.Address, backend bind.ContractBackend) (*Permit2, error)

+ type Permit2Approval struct

+ Amount *big.Int

+ Expiration *big.Int

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Token common.Address

+ type Permit2ApprovalIterator struct

+ Event *Permit2Approval

+ func (it *Permit2ApprovalIterator) Close() error

+ func (it *Permit2ApprovalIterator) Error() error

+ func (it *Permit2ApprovalIterator) Next() bool

+ type Permit2Caller struct

+ func NewPermit2Caller(address common.Address, caller bind.ContractCaller) (*Permit2Caller, error)

+ func (_Permit2 *Permit2Caller) Allowance(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address, ...) (struct{ ... }, error)

+ func (_Permit2 *Permit2Caller) DOMAINSEPARATOR(opts *bind.CallOpts) ([32]byte, error)

+ func (_Permit2 *Permit2Caller) NonceBitmap(opts *bind.CallOpts, arg0 common.Address, arg1 *big.Int) (*big.Int, error)

+ type Permit2CallerRaw struct

+ Contract *Permit2Caller

+ func (_Permit2 *Permit2CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type Permit2CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *Permit2Caller

+ func (_Permit2 *Permit2CallerSession) Allowance(arg0 common.Address, arg1 common.Address, arg2 common.Address) (struct{ ... }, error)

+ func (_Permit2 *Permit2CallerSession) DOMAINSEPARATOR() ([32]byte, error)

+ func (_Permit2 *Permit2CallerSession) NonceBitmap(arg0 common.Address, arg1 *big.Int) (*big.Int, error)

+ type Permit2Filterer struct

+ func NewPermit2Filterer(address common.Address, filterer bind.ContractFilterer) (*Permit2Filterer, error)

+ func (_Permit2 *Permit2Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, token []common.Address, ...) (*Permit2ApprovalIterator, error)

+ func (_Permit2 *Permit2Filterer) FilterLockdown(opts *bind.FilterOpts, owner []common.Address) (*Permit2LockdownIterator, error)

+ func (_Permit2 *Permit2Filterer) FilterNonceInvalidation(opts *bind.FilterOpts, owner []common.Address, token []common.Address, ...) (*Permit2NonceInvalidationIterator, error)

+ func (_Permit2 *Permit2Filterer) FilterPermit(opts *bind.FilterOpts, owner []common.Address, token []common.Address, ...) (*Permit2PermitIterator, error)

+ func (_Permit2 *Permit2Filterer) FilterUnorderedNonceInvalidation(opts *bind.FilterOpts, owner []common.Address) (*Permit2UnorderedNonceInvalidationIterator, error)

+ func (_Permit2 *Permit2Filterer) ParseApproval(log types.Log) (*Permit2Approval, error)

+ func (_Permit2 *Permit2Filterer) ParseLockdown(log types.Log) (*Permit2Lockdown, error)

+ func (_Permit2 *Permit2Filterer) ParseNonceInvalidation(log types.Log) (*Permit2NonceInvalidation, error)

+ func (_Permit2 *Permit2Filterer) ParsePermit(log types.Log) (*Permit2Permit, error)

+ func (_Permit2 *Permit2Filterer) ParseUnorderedNonceInvalidation(log types.Log) (*Permit2UnorderedNonceInvalidation, error)

+ func (_Permit2 *Permit2Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *Permit2Approval, owner []common.Address, ...) (event.Subscription, error)

+ func (_Permit2 *Permit2Filterer) WatchLockdown(opts *bind.WatchOpts, sink chan<- *Permit2Lockdown, owner []common.Address) (event.Subscription, error)

+ func (_Permit2 *Permit2Filterer) WatchNonceInvalidation(opts *bind.WatchOpts, sink chan<- *Permit2NonceInvalidation, ...) (event.Subscription, error)

+ func (_Permit2 *Permit2Filterer) WatchPermit(opts *bind.WatchOpts, sink chan<- *Permit2Permit, owner []common.Address, ...) (event.Subscription, error)

+ func (_Permit2 *Permit2Filterer) WatchUnorderedNonceInvalidation(opts *bind.WatchOpts, sink chan<- *Permit2UnorderedNonceInvalidation, ...) (event.Subscription, error)

+ type Permit2Lockdown struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Token common.Address

+ type Permit2LockdownIterator struct

+ Event *Permit2Lockdown

+ func (it *Permit2LockdownIterator) Close() error

+ func (it *Permit2LockdownIterator) Error() error

+ func (it *Permit2LockdownIterator) Next() bool

+ type Permit2NonceInvalidation struct

+ NewNonce *big.Int

+ OldNonce *big.Int

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Token common.Address

+ type Permit2NonceInvalidationIterator struct

+ Event *Permit2NonceInvalidation

+ func (it *Permit2NonceInvalidationIterator) Close() error

+ func (it *Permit2NonceInvalidationIterator) Error() error

+ func (it *Permit2NonceInvalidationIterator) Next() bool

+ type Permit2Permit struct

+ Amount *big.Int

+ Expiration *big.Int

+ Nonce *big.Int

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Token common.Address

+ type Permit2PermitIterator struct

+ Event *Permit2Permit

+ func (it *Permit2PermitIterator) Close() error

+ func (it *Permit2PermitIterator) Error() error

+ func (it *Permit2PermitIterator) Next() bool

+ type Permit2Raw struct

+ Contract *Permit2

+ func (_Permit2 *Permit2Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_Permit2 *Permit2Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type Permit2Session struct

+ CallOpts bind.CallOpts

+ Contract *Permit2

+ TransactOpts bind.TransactOpts

+ func (_Permit2 *Permit2Session) Allowance(arg0 common.Address, arg1 common.Address, arg2 common.Address) (struct{ ... }, error)

+ func (_Permit2 *Permit2Session) Approve(token common.Address, spender common.Address, amount *big.Int, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2Session) DOMAINSEPARATOR() ([32]byte, error)

+ func (_Permit2 *Permit2Session) InvalidateNonces(token common.Address, spender common.Address, newNonce *big.Int) (*types.Transaction, error)

+ func (_Permit2 *Permit2Session) InvalidateUnorderedNonces(wordPos *big.Int, mask *big.Int) (*types.Transaction, error)

+ func (_Permit2 *Permit2Session) Lockdown(approvals []IAllowanceTransferTokenSpenderPair) (*types.Transaction, error)

+ func (_Permit2 *Permit2Session) NonceBitmap(arg0 common.Address, arg1 *big.Int) (*big.Int, error)

+ func (_Permit2 *Permit2Session) Permit(owner common.Address, permitBatch IAllowanceTransferPermitBatch, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2Session) Permit0(owner common.Address, permitSingle IAllowanceTransferPermitSingle, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2Session) PermitTransferFrom(permit ISignatureTransferPermitTransferFrom, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2Session) PermitTransferFrom0(permit ISignatureTransferPermitBatchTransferFrom, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2Session) PermitWitnessTransferFrom(permit ISignatureTransferPermitTransferFrom, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2Session) PermitWitnessTransferFrom0(permit ISignatureTransferPermitBatchTransferFrom, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2Session) TransferFrom(transferDetails []IAllowanceTransferAllowanceTransferDetails) (*types.Transaction, error)

+ func (_Permit2 *Permit2Session) TransferFrom0(from common.Address, to common.Address, amount *big.Int, token common.Address) (*types.Transaction, error)

+ type Permit2Transactor struct

+ func NewPermit2Transactor(address common.Address, transactor bind.ContractTransactor) (*Permit2Transactor, error)

+ func (_Permit2 *Permit2Transactor) Approve(opts *bind.TransactOpts, token common.Address, spender common.Address, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2Transactor) InvalidateNonces(opts *bind.TransactOpts, token common.Address, spender common.Address, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2Transactor) InvalidateUnorderedNonces(opts *bind.TransactOpts, wordPos *big.Int, mask *big.Int) (*types.Transaction, error)

+ func (_Permit2 *Permit2Transactor) Lockdown(opts *bind.TransactOpts, approvals []IAllowanceTransferTokenSpenderPair) (*types.Transaction, error)

+ func (_Permit2 *Permit2Transactor) Permit(opts *bind.TransactOpts, owner common.Address, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2Transactor) Permit0(opts *bind.TransactOpts, owner common.Address, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2Transactor) PermitTransferFrom(opts *bind.TransactOpts, permit ISignatureTransferPermitTransferFrom, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2Transactor) PermitTransferFrom0(opts *bind.TransactOpts, permit ISignatureTransferPermitBatchTransferFrom, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2Transactor) PermitWitnessTransferFrom(opts *bind.TransactOpts, permit ISignatureTransferPermitTransferFrom, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2Transactor) PermitWitnessTransferFrom0(opts *bind.TransactOpts, permit ISignatureTransferPermitBatchTransferFrom, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2Transactor) TransferFrom(opts *bind.TransactOpts, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2Transactor) TransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ type Permit2TransactorRaw struct

+ Contract *Permit2Transactor

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

+ func (_Permit2 *Permit2TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type Permit2TransactorSession struct

+ Contract *Permit2Transactor

+ TransactOpts bind.TransactOpts

+ func (_Permit2 *Permit2TransactorSession) Approve(token common.Address, spender common.Address, amount *big.Int, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2TransactorSession) InvalidateNonces(token common.Address, spender common.Address, newNonce *big.Int) (*types.Transaction, error)

+ func (_Permit2 *Permit2TransactorSession) InvalidateUnorderedNonces(wordPos *big.Int, mask *big.Int) (*types.Transaction, error)

+ func (_Permit2 *Permit2TransactorSession) Lockdown(approvals []IAllowanceTransferTokenSpenderPair) (*types.Transaction, error)

+ func (_Permit2 *Permit2TransactorSession) Permit(owner common.Address, permitBatch IAllowanceTransferPermitBatch, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2TransactorSession) Permit0(owner common.Address, permitSingle IAllowanceTransferPermitSingle, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2TransactorSession) PermitTransferFrom(permit ISignatureTransferPermitTransferFrom, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2TransactorSession) PermitTransferFrom0(permit ISignatureTransferPermitBatchTransferFrom, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2TransactorSession) PermitWitnessTransferFrom(permit ISignatureTransferPermitTransferFrom, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2TransactorSession) PermitWitnessTransferFrom0(permit ISignatureTransferPermitBatchTransferFrom, ...) (*types.Transaction, error)

+ func (_Permit2 *Permit2TransactorSession) TransferFrom(transferDetails []IAllowanceTransferAllowanceTransferDetails) (*types.Transaction, error)

+ func (_Permit2 *Permit2TransactorSession) TransferFrom0(from common.Address, to common.Address, amount *big.Int, token common.Address) (*types.Transaction, error)

+ type Permit2UnorderedNonceInvalidation struct

+ Mask *big.Int

+ Owner common.Address

+ Raw types.Log

+ Word *big.Int

+ type Permit2UnorderedNonceInvalidationIterator struct

+ Event *Permit2UnorderedNonceInvalidation

+ func (it *Permit2UnorderedNonceInvalidationIterator) Close() error

+ func (it *Permit2UnorderedNonceInvalidationIterator) Error() error

+ func (it *Permit2UnorderedNonceInvalidationIterator) Next() bool

type PreimageOracleCaller

+ func (_PreimageOracle *PreimageOracleCaller) ChallengePeriod(opts *bind.CallOpts) (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleCaller) GetTreeRootLPP(opts *bind.CallOpts, _owner common.Address, _uuid *big.Int) ([32]byte, error)

+ func (_PreimageOracle *PreimageOracleCaller) KECCAKTREEDEPTH(opts *bind.CallOpts) (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleCaller) MAXLEAFCOUNT(opts *bind.CallOpts) (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleCaller) MINBONDSIZE(opts *bind.CallOpts) (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleCaller) MinProposalSize(opts *bind.CallOpts) (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleCaller) ProposalBlocks(opts *bind.CallOpts, arg0 common.Address, arg1 *big.Int, arg2 *big.Int) (uint64, error)

+ func (_PreimageOracle *PreimageOracleCaller) ProposalBlocksLen(opts *bind.CallOpts, _claimant common.Address, _uuid *big.Int) (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleCaller) ProposalBonds(opts *bind.CallOpts, arg0 common.Address, arg1 *big.Int) (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleCaller) ProposalBranches(opts *bind.CallOpts, arg0 common.Address, arg1 *big.Int, arg2 *big.Int) ([32]byte, error)

+ func (_PreimageOracle *PreimageOracleCaller) ProposalCount(opts *bind.CallOpts) (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleCaller) ProposalMetadata(opts *bind.CallOpts, arg0 common.Address, arg1 *big.Int) ([32]byte, error)

+ func (_PreimageOracle *PreimageOracleCaller) ProposalParts(opts *bind.CallOpts, arg0 common.Address, arg1 *big.Int) ([32]byte, error)

+ func (_PreimageOracle *PreimageOracleCaller) Proposals(opts *bind.CallOpts, arg0 *big.Int) (struct{ ... }, error)

+ func (_PreimageOracle *PreimageOracleCaller) Version(opts *bind.CallOpts) (string, error)

+ func (_PreimageOracle *PreimageOracleCaller) ZeroHashes(opts *bind.CallOpts, arg0 *big.Int) ([32]byte, error)

type PreimageOracleCallerSession

+ func (_PreimageOracle *PreimageOracleCallerSession) ChallengePeriod() (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleCallerSession) GetTreeRootLPP(_owner common.Address, _uuid *big.Int) ([32]byte, error)

+ func (_PreimageOracle *PreimageOracleCallerSession) KECCAKTREEDEPTH() (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleCallerSession) MAXLEAFCOUNT() (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleCallerSession) MINBONDSIZE() (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleCallerSession) MinProposalSize() (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleCallerSession) ProposalBlocks(arg0 common.Address, arg1 *big.Int, arg2 *big.Int) (uint64, error)

+ func (_PreimageOracle *PreimageOracleCallerSession) ProposalBlocksLen(_claimant common.Address, _uuid *big.Int) (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleCallerSession) ProposalBonds(arg0 common.Address, arg1 *big.Int) (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleCallerSession) ProposalBranches(arg0 common.Address, arg1 *big.Int, arg2 *big.Int) ([32]byte, error)

+ func (_PreimageOracle *PreimageOracleCallerSession) ProposalCount() (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleCallerSession) ProposalMetadata(arg0 common.Address, arg1 *big.Int) ([32]byte, error)

+ func (_PreimageOracle *PreimageOracleCallerSession) ProposalParts(arg0 common.Address, arg1 *big.Int) ([32]byte, error)

+ func (_PreimageOracle *PreimageOracleCallerSession) Proposals(arg0 *big.Int) (struct{ ... }, error)

+ func (_PreimageOracle *PreimageOracleCallerSession) Version() (string, error)

+ func (_PreimageOracle *PreimageOracleCallerSession) ZeroHashes(arg0 *big.Int) ([32]byte, error)

+ type PreimageOracleLeaf struct

+ Index *big.Int

+ Input []byte

+ StateCommitment [32]byte

type PreimageOracleSession

+ func (_PreimageOracle *PreimageOracleSession) AddLeavesLPP(_uuid *big.Int, _inputStartBlock *big.Int, _input []byte, ...) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleSession) ChallengeFirstLPP(_claimant common.Address, _uuid *big.Int, _postState PreimageOracleLeaf, ...) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleSession) ChallengeLPP(_claimant common.Address, _uuid *big.Int, _stateMatrix LibKeccakStateMatrix, ...) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleSession) ChallengePeriod() (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleSession) GetTreeRootLPP(_owner common.Address, _uuid *big.Int) ([32]byte, error)

+ func (_PreimageOracle *PreimageOracleSession) InitLPP(_uuid *big.Int, _partOffset uint32, _claimedSize uint32) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleSession) KECCAKTREEDEPTH() (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleSession) LoadBlobPreimagePart(_z *big.Int, _y *big.Int, _commitment []byte, _proof []byte, ...) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleSession) LoadPrecompilePreimagePart(_partOffset *big.Int, _precompile common.Address, _input []byte) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleSession) LoadSha256PreimagePart(_partOffset *big.Int, _preimage []byte) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleSession) MAXLEAFCOUNT() (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleSession) MINBONDSIZE() (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleSession) MinProposalSize() (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleSession) ProposalBlocks(arg0 common.Address, arg1 *big.Int, arg2 *big.Int) (uint64, error)

+ func (_PreimageOracle *PreimageOracleSession) ProposalBlocksLen(_claimant common.Address, _uuid *big.Int) (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleSession) ProposalBonds(arg0 common.Address, arg1 *big.Int) (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleSession) ProposalBranches(arg0 common.Address, arg1 *big.Int, arg2 *big.Int) ([32]byte, error)

+ func (_PreimageOracle *PreimageOracleSession) ProposalCount() (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleSession) ProposalMetadata(arg0 common.Address, arg1 *big.Int) ([32]byte, error)

+ func (_PreimageOracle *PreimageOracleSession) ProposalParts(arg0 common.Address, arg1 *big.Int) ([32]byte, error)

+ func (_PreimageOracle *PreimageOracleSession) Proposals(arg0 *big.Int) (struct{ ... }, error)

+ func (_PreimageOracle *PreimageOracleSession) SqueezeLPP(_claimant common.Address, _uuid *big.Int, _stateMatrix LibKeccakStateMatrix, ...) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleSession) Version() (string, error)

+ func (_PreimageOracle *PreimageOracleSession) ZeroHashes(arg0 *big.Int) ([32]byte, error)

type PreimageOracleTransactor

+ func (_PreimageOracle *PreimageOracleTransactor) AddLeavesLPP(opts *bind.TransactOpts, _uuid *big.Int, _inputStartBlock *big.Int, ...) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleTransactor) ChallengeFirstLPP(opts *bind.TransactOpts, _claimant common.Address, _uuid *big.Int, ...) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleTransactor) ChallengeLPP(opts *bind.TransactOpts, _claimant common.Address, _uuid *big.Int, ...) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleTransactor) InitLPP(opts *bind.TransactOpts, _uuid *big.Int, _partOffset uint32, ...) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleTransactor) LoadBlobPreimagePart(opts *bind.TransactOpts, _z *big.Int, _y *big.Int, _commitment []byte, ...) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleTransactor) LoadPrecompilePreimagePart(opts *bind.TransactOpts, _partOffset *big.Int, _precompile common.Address, ...) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleTransactor) LoadSha256PreimagePart(opts *bind.TransactOpts, _partOffset *big.Int, _preimage []byte) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleTransactor) SqueezeLPP(opts *bind.TransactOpts, _claimant common.Address, _uuid *big.Int, ...) (*types.Transaction, error)

type PreimageOracleTransactorSession

+ func (_PreimageOracle *PreimageOracleTransactorSession) AddLeavesLPP(_uuid *big.Int, _inputStartBlock *big.Int, _input []byte, ...) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleTransactorSession) ChallengeFirstLPP(_claimant common.Address, _uuid *big.Int, _postState PreimageOracleLeaf, ...) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleTransactorSession) ChallengeLPP(_claimant common.Address, _uuid *big.Int, _stateMatrix LibKeccakStateMatrix, ...) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleTransactorSession) InitLPP(_uuid *big.Int, _partOffset uint32, _claimedSize uint32) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleTransactorSession) LoadBlobPreimagePart(_z *big.Int, _y *big.Int, _commitment []byte, _proof []byte, ...) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleTransactorSession) LoadPrecompilePreimagePart(_partOffset *big.Int, _precompile common.Address, _input []byte) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleTransactorSession) LoadSha256PreimagePart(_partOffset *big.Int, _preimage []byte) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleTransactorSession) SqueezeLPP(_claimant common.Address, _uuid *big.Int, _stateMatrix LibKeccakStateMatrix, ...) (*types.Transaction, error)

+ type SafeL2V130 struct

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

+ func NewSafeL2V130(address common.Address, backend bind.ContractBackend) (*SafeL2V130, error)

+ type SafeL2V130AddedOwner struct

+ Owner common.Address

+ Raw types.Log

+ type SafeL2V130AddedOwnerIterator struct

+ Event *SafeL2V130AddedOwner

+ func (it *SafeL2V130AddedOwnerIterator) Close() error

+ func (it *SafeL2V130AddedOwnerIterator) Error() error

+ func (it *SafeL2V130AddedOwnerIterator) Next() bool

+ type SafeL2V130ApproveHash struct

+ ApprovedHash [32]byte

+ Owner common.Address

+ Raw types.Log

+ type SafeL2V130ApproveHashIterator struct

+ Event *SafeL2V130ApproveHash

+ func (it *SafeL2V130ApproveHashIterator) Close() error

+ func (it *SafeL2V130ApproveHashIterator) Error() error

+ func (it *SafeL2V130ApproveHashIterator) Next() bool

+ type SafeL2V130Caller struct

+ func NewSafeL2V130Caller(address common.Address, caller bind.ContractCaller) (*SafeL2V130Caller, error)

+ func (_SafeL2V130 *SafeL2V130Caller) ApprovedHashes(opts *bind.CallOpts, arg0 common.Address, arg1 [32]byte) (*big.Int, error)

+ func (_SafeL2V130 *SafeL2V130Caller) CheckNSignatures(opts *bind.CallOpts, dataHash [32]byte, data []byte, signatures []byte, ...) error

+ func (_SafeL2V130 *SafeL2V130Caller) CheckSignatures(opts *bind.CallOpts, dataHash [32]byte, data []byte, signatures []byte) error

+ func (_SafeL2V130 *SafeL2V130Caller) DomainSeparator(opts *bind.CallOpts) ([32]byte, error)

+ func (_SafeL2V130 *SafeL2V130Caller) EncodeTransactionData(opts *bind.CallOpts, to common.Address, value *big.Int, data []byte, ...) ([]byte, error)

+ func (_SafeL2V130 *SafeL2V130Caller) GetChainId(opts *bind.CallOpts) (*big.Int, error)

+ func (_SafeL2V130 *SafeL2V130Caller) GetModulesPaginated(opts *bind.CallOpts, start common.Address, pageSize *big.Int) (struct{ ... }, error)

+ func (_SafeL2V130 *SafeL2V130Caller) GetOwners(opts *bind.CallOpts) ([]common.Address, error)

+ func (_SafeL2V130 *SafeL2V130Caller) GetStorageAt(opts *bind.CallOpts, offset *big.Int, length *big.Int) ([]byte, error)

+ func (_SafeL2V130 *SafeL2V130Caller) GetThreshold(opts *bind.CallOpts) (*big.Int, error)

+ func (_SafeL2V130 *SafeL2V130Caller) GetTransactionHash(opts *bind.CallOpts, to common.Address, value *big.Int, data []byte, ...) ([32]byte, error)

+ func (_SafeL2V130 *SafeL2V130Caller) IsModuleEnabled(opts *bind.CallOpts, module common.Address) (bool, error)

+ func (_SafeL2V130 *SafeL2V130Caller) IsOwner(opts *bind.CallOpts, owner common.Address) (bool, error)

+ func (_SafeL2V130 *SafeL2V130Caller) Nonce(opts *bind.CallOpts) (*big.Int, error)

+ func (_SafeL2V130 *SafeL2V130Caller) SignedMessages(opts *bind.CallOpts, arg0 [32]byte) (*big.Int, error)

+ func (_SafeL2V130 *SafeL2V130Caller) VERSION(opts *bind.CallOpts) (string, error)

+ type SafeL2V130CallerRaw struct

+ Contract *SafeL2V130Caller

+ func (_SafeL2V130 *SafeL2V130CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type SafeL2V130CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SafeL2V130Caller

+ func (_SafeL2V130 *SafeL2V130CallerSession) ApprovedHashes(arg0 common.Address, arg1 [32]byte) (*big.Int, error)

+ func (_SafeL2V130 *SafeL2V130CallerSession) CheckNSignatures(dataHash [32]byte, data []byte, signatures []byte, requiredSignatures *big.Int) error

+ func (_SafeL2V130 *SafeL2V130CallerSession) CheckSignatures(dataHash [32]byte, data []byte, signatures []byte) error

+ func (_SafeL2V130 *SafeL2V130CallerSession) DomainSeparator() ([32]byte, error)

+ func (_SafeL2V130 *SafeL2V130CallerSession) EncodeTransactionData(to common.Address, value *big.Int, data []byte, operation uint8, ...) ([]byte, error)

+ func (_SafeL2V130 *SafeL2V130CallerSession) GetChainId() (*big.Int, error)

+ func (_SafeL2V130 *SafeL2V130CallerSession) GetModulesPaginated(start common.Address, pageSize *big.Int) (struct{ ... }, error)

+ func (_SafeL2V130 *SafeL2V130CallerSession) GetOwners() ([]common.Address, error)

+ func (_SafeL2V130 *SafeL2V130CallerSession) GetStorageAt(offset *big.Int, length *big.Int) ([]byte, error)

+ func (_SafeL2V130 *SafeL2V130CallerSession) GetThreshold() (*big.Int, error)

+ func (_SafeL2V130 *SafeL2V130CallerSession) GetTransactionHash(to common.Address, value *big.Int, data []byte, operation uint8, ...) ([32]byte, error)

+ func (_SafeL2V130 *SafeL2V130CallerSession) IsModuleEnabled(module common.Address) (bool, error)

+ func (_SafeL2V130 *SafeL2V130CallerSession) IsOwner(owner common.Address) (bool, error)

+ func (_SafeL2V130 *SafeL2V130CallerSession) Nonce() (*big.Int, error)

+ func (_SafeL2V130 *SafeL2V130CallerSession) SignedMessages(arg0 [32]byte) (*big.Int, error)

+ func (_SafeL2V130 *SafeL2V130CallerSession) VERSION() (string, error)

+ type SafeL2V130ChangedFallbackHandler struct

+ Handler common.Address

+ Raw types.Log

+ type SafeL2V130ChangedFallbackHandlerIterator struct

+ Event *SafeL2V130ChangedFallbackHandler

+ func (it *SafeL2V130ChangedFallbackHandlerIterator) Close() error

+ func (it *SafeL2V130ChangedFallbackHandlerIterator) Error() error

+ func (it *SafeL2V130ChangedFallbackHandlerIterator) Next() bool

+ type SafeL2V130ChangedGuard struct

+ Guard common.Address

+ Raw types.Log

+ type SafeL2V130ChangedGuardIterator struct

+ Event *SafeL2V130ChangedGuard

+ func (it *SafeL2V130ChangedGuardIterator) Close() error

+ func (it *SafeL2V130ChangedGuardIterator) Error() error

+ func (it *SafeL2V130ChangedGuardIterator) Next() bool

+ type SafeL2V130ChangedThreshold struct

+ Raw types.Log

+ Threshold *big.Int

+ type SafeL2V130ChangedThresholdIterator struct

+ Event *SafeL2V130ChangedThreshold

+ func (it *SafeL2V130ChangedThresholdIterator) Close() error

+ func (it *SafeL2V130ChangedThresholdIterator) Error() error

+ func (it *SafeL2V130ChangedThresholdIterator) Next() bool

+ type SafeL2V130DisabledModule struct

+ Module common.Address

+ Raw types.Log

+ type SafeL2V130DisabledModuleIterator struct

+ Event *SafeL2V130DisabledModule

+ func (it *SafeL2V130DisabledModuleIterator) Close() error

+ func (it *SafeL2V130DisabledModuleIterator) Error() error

+ func (it *SafeL2V130DisabledModuleIterator) Next() bool

+ type SafeL2V130EnabledModule struct

+ Module common.Address

+ Raw types.Log

+ type SafeL2V130EnabledModuleIterator struct

+ Event *SafeL2V130EnabledModule

+ func (it *SafeL2V130EnabledModuleIterator) Close() error

+ func (it *SafeL2V130EnabledModuleIterator) Error() error

+ func (it *SafeL2V130EnabledModuleIterator) Next() bool

+ type SafeL2V130ExecutionFailure struct

+ Payment *big.Int

+ Raw types.Log

+ TxHash [32]byte

+ type SafeL2V130ExecutionFailureIterator struct

+ Event *SafeL2V130ExecutionFailure

+ func (it *SafeL2V130ExecutionFailureIterator) Close() error

+ func (it *SafeL2V130ExecutionFailureIterator) Error() error

+ func (it *SafeL2V130ExecutionFailureIterator) Next() bool

+ type SafeL2V130ExecutionFromModuleFailure struct

+ Module common.Address

+ Raw types.Log

+ type SafeL2V130ExecutionFromModuleFailureIterator struct

+ Event *SafeL2V130ExecutionFromModuleFailure

+ func (it *SafeL2V130ExecutionFromModuleFailureIterator) Close() error

+ func (it *SafeL2V130ExecutionFromModuleFailureIterator) Error() error

+ func (it *SafeL2V130ExecutionFromModuleFailureIterator) Next() bool

+ type SafeL2V130ExecutionFromModuleSuccess struct

+ Module common.Address

+ Raw types.Log

+ type SafeL2V130ExecutionFromModuleSuccessIterator struct

+ Event *SafeL2V130ExecutionFromModuleSuccess

+ func (it *SafeL2V130ExecutionFromModuleSuccessIterator) Close() error

+ func (it *SafeL2V130ExecutionFromModuleSuccessIterator) Error() error

+ func (it *SafeL2V130ExecutionFromModuleSuccessIterator) Next() bool

+ type SafeL2V130ExecutionSuccess struct

+ Payment *big.Int

+ Raw types.Log

+ TxHash [32]byte

+ type SafeL2V130ExecutionSuccessIterator struct

+ Event *SafeL2V130ExecutionSuccess

+ func (it *SafeL2V130ExecutionSuccessIterator) Close() error

+ func (it *SafeL2V130ExecutionSuccessIterator) Error() error

+ func (it *SafeL2V130ExecutionSuccessIterator) Next() bool

+ type SafeL2V130Filterer struct

+ func NewSafeL2V130Filterer(address common.Address, filterer bind.ContractFilterer) (*SafeL2V130Filterer, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) FilterAddedOwner(opts *bind.FilterOpts) (*SafeL2V130AddedOwnerIterator, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) FilterApproveHash(opts *bind.FilterOpts, approvedHash [][32]byte, owner []common.Address) (*SafeL2V130ApproveHashIterator, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) FilterChangedFallbackHandler(opts *bind.FilterOpts) (*SafeL2V130ChangedFallbackHandlerIterator, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) FilterChangedGuard(opts *bind.FilterOpts) (*SafeL2V130ChangedGuardIterator, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) FilterChangedThreshold(opts *bind.FilterOpts) (*SafeL2V130ChangedThresholdIterator, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) FilterDisabledModule(opts *bind.FilterOpts) (*SafeL2V130DisabledModuleIterator, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) FilterEnabledModule(opts *bind.FilterOpts) (*SafeL2V130EnabledModuleIterator, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) FilterExecutionFailure(opts *bind.FilterOpts) (*SafeL2V130ExecutionFailureIterator, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) FilterExecutionFromModuleFailure(opts *bind.FilterOpts, module []common.Address) (*SafeL2V130ExecutionFromModuleFailureIterator, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) FilterExecutionFromModuleSuccess(opts *bind.FilterOpts, module []common.Address) (*SafeL2V130ExecutionFromModuleSuccessIterator, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) FilterExecutionSuccess(opts *bind.FilterOpts) (*SafeL2V130ExecutionSuccessIterator, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) FilterRemovedOwner(opts *bind.FilterOpts) (*SafeL2V130RemovedOwnerIterator, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) FilterSafeModuleTransaction(opts *bind.FilterOpts) (*SafeL2V130SafeModuleTransactionIterator, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) FilterSafeMultiSigTransaction(opts *bind.FilterOpts) (*SafeL2V130SafeMultiSigTransactionIterator, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) FilterSafeReceived(opts *bind.FilterOpts, sender []common.Address) (*SafeL2V130SafeReceivedIterator, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) FilterSafeSetup(opts *bind.FilterOpts, initiator []common.Address) (*SafeL2V130SafeSetupIterator, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) FilterSignMsg(opts *bind.FilterOpts, msgHash [][32]byte) (*SafeL2V130SignMsgIterator, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) ParseAddedOwner(log types.Log) (*SafeL2V130AddedOwner, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) ParseApproveHash(log types.Log) (*SafeL2V130ApproveHash, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) ParseChangedFallbackHandler(log types.Log) (*SafeL2V130ChangedFallbackHandler, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) ParseChangedGuard(log types.Log) (*SafeL2V130ChangedGuard, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) ParseChangedThreshold(log types.Log) (*SafeL2V130ChangedThreshold, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) ParseDisabledModule(log types.Log) (*SafeL2V130DisabledModule, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) ParseEnabledModule(log types.Log) (*SafeL2V130EnabledModule, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) ParseExecutionFailure(log types.Log) (*SafeL2V130ExecutionFailure, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) ParseExecutionFromModuleFailure(log types.Log) (*SafeL2V130ExecutionFromModuleFailure, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) ParseExecutionFromModuleSuccess(log types.Log) (*SafeL2V130ExecutionFromModuleSuccess, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) ParseExecutionSuccess(log types.Log) (*SafeL2V130ExecutionSuccess, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) ParseRemovedOwner(log types.Log) (*SafeL2V130RemovedOwner, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) ParseSafeModuleTransaction(log types.Log) (*SafeL2V130SafeModuleTransaction, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) ParseSafeMultiSigTransaction(log types.Log) (*SafeL2V130SafeMultiSigTransaction, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) ParseSafeReceived(log types.Log) (*SafeL2V130SafeReceived, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) ParseSafeSetup(log types.Log) (*SafeL2V130SafeSetup, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) ParseSignMsg(log types.Log) (*SafeL2V130SignMsg, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) WatchAddedOwner(opts *bind.WatchOpts, sink chan<- *SafeL2V130AddedOwner) (event.Subscription, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) WatchApproveHash(opts *bind.WatchOpts, sink chan<- *SafeL2V130ApproveHash, ...) (event.Subscription, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) WatchChangedFallbackHandler(opts *bind.WatchOpts, sink chan<- *SafeL2V130ChangedFallbackHandler) (event.Subscription, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) WatchChangedGuard(opts *bind.WatchOpts, sink chan<- *SafeL2V130ChangedGuard) (event.Subscription, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) WatchChangedThreshold(opts *bind.WatchOpts, sink chan<- *SafeL2V130ChangedThreshold) (event.Subscription, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) WatchDisabledModule(opts *bind.WatchOpts, sink chan<- *SafeL2V130DisabledModule) (event.Subscription, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) WatchEnabledModule(opts *bind.WatchOpts, sink chan<- *SafeL2V130EnabledModule) (event.Subscription, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) WatchExecutionFailure(opts *bind.WatchOpts, sink chan<- *SafeL2V130ExecutionFailure) (event.Subscription, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) WatchExecutionFromModuleFailure(opts *bind.WatchOpts, sink chan<- *SafeL2V130ExecutionFromModuleFailure, ...) (event.Subscription, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) WatchExecutionFromModuleSuccess(opts *bind.WatchOpts, sink chan<- *SafeL2V130ExecutionFromModuleSuccess, ...) (event.Subscription, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) WatchExecutionSuccess(opts *bind.WatchOpts, sink chan<- *SafeL2V130ExecutionSuccess) (event.Subscription, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) WatchRemovedOwner(opts *bind.WatchOpts, sink chan<- *SafeL2V130RemovedOwner) (event.Subscription, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) WatchSafeModuleTransaction(opts *bind.WatchOpts, sink chan<- *SafeL2V130SafeModuleTransaction) (event.Subscription, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) WatchSafeMultiSigTransaction(opts *bind.WatchOpts, sink chan<- *SafeL2V130SafeMultiSigTransaction) (event.Subscription, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) WatchSafeReceived(opts *bind.WatchOpts, sink chan<- *SafeL2V130SafeReceived, ...) (event.Subscription, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) WatchSafeSetup(opts *bind.WatchOpts, sink chan<- *SafeL2V130SafeSetup, ...) (event.Subscription, error)

+ func (_SafeL2V130 *SafeL2V130Filterer) WatchSignMsg(opts *bind.WatchOpts, sink chan<- *SafeL2V130SignMsg, msgHash [][32]byte) (event.Subscription, error)

+ type SafeL2V130Raw struct

+ Contract *SafeL2V130

+ func (_SafeL2V130 *SafeL2V130Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_SafeL2V130 *SafeL2V130Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeL2V130RemovedOwner struct

+ Owner common.Address

+ Raw types.Log

+ type SafeL2V130RemovedOwnerIterator struct

+ Event *SafeL2V130RemovedOwner

+ func (it *SafeL2V130RemovedOwnerIterator) Close() error

+ func (it *SafeL2V130RemovedOwnerIterator) Error() error

+ func (it *SafeL2V130RemovedOwnerIterator) Next() bool

+ type SafeL2V130SafeModuleTransaction struct

+ Data []byte

+ Module common.Address

+ Operation uint8

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type SafeL2V130SafeModuleTransactionIterator struct

+ Event *SafeL2V130SafeModuleTransaction

+ func (it *SafeL2V130SafeModuleTransactionIterator) Close() error

+ func (it *SafeL2V130SafeModuleTransactionIterator) Error() error

+ func (it *SafeL2V130SafeModuleTransactionIterator) Next() bool

+ type SafeL2V130SafeMultiSigTransaction struct

+ AdditionalInfo []byte

+ BaseGas *big.Int

+ Data []byte

+ GasPrice *big.Int

+ GasToken common.Address

+ Operation uint8

+ Raw types.Log

+ RefundReceiver common.Address

+ SafeTxGas *big.Int

+ Signatures []byte

+ To common.Address

+ Value *big.Int

+ type SafeL2V130SafeMultiSigTransactionIterator struct

+ Event *SafeL2V130SafeMultiSigTransaction

+ func (it *SafeL2V130SafeMultiSigTransactionIterator) Close() error

+ func (it *SafeL2V130SafeMultiSigTransactionIterator) Error() error

+ func (it *SafeL2V130SafeMultiSigTransactionIterator) Next() bool

+ type SafeL2V130SafeReceived struct

+ Raw types.Log

+ Sender common.Address

+ Value *big.Int

+ type SafeL2V130SafeReceivedIterator struct

+ Event *SafeL2V130SafeReceived

+ func (it *SafeL2V130SafeReceivedIterator) Close() error

+ func (it *SafeL2V130SafeReceivedIterator) Error() error

+ func (it *SafeL2V130SafeReceivedIterator) Next() bool

+ type SafeL2V130SafeSetup struct

+ FallbackHandler common.Address

+ Initializer common.Address

+ Initiator common.Address

+ Owners []common.Address

+ Raw types.Log

+ Threshold *big.Int

+ type SafeL2V130SafeSetupIterator struct

+ Event *SafeL2V130SafeSetup

+ func (it *SafeL2V130SafeSetupIterator) Close() error

+ func (it *SafeL2V130SafeSetupIterator) Error() error

+ func (it *SafeL2V130SafeSetupIterator) Next() bool

+ type SafeL2V130Session struct

+ CallOpts bind.CallOpts

+ Contract *SafeL2V130

+ TransactOpts bind.TransactOpts

+ func (_SafeL2V130 *SafeL2V130Session) AddOwnerWithThreshold(owner common.Address, _threshold *big.Int) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Session) ApproveHash(hashToApprove [32]byte) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Session) ApprovedHashes(arg0 common.Address, arg1 [32]byte) (*big.Int, error)

+ func (_SafeL2V130 *SafeL2V130Session) ChangeThreshold(_threshold *big.Int) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Session) CheckNSignatures(dataHash [32]byte, data []byte, signatures []byte, requiredSignatures *big.Int) error

+ func (_SafeL2V130 *SafeL2V130Session) CheckSignatures(dataHash [32]byte, data []byte, signatures []byte) error

+ func (_SafeL2V130 *SafeL2V130Session) DisableModule(prevModule common.Address, module common.Address) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Session) DomainSeparator() ([32]byte, error)

+ func (_SafeL2V130 *SafeL2V130Session) EnableModule(module common.Address) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Session) EncodeTransactionData(to common.Address, value *big.Int, data []byte, operation uint8, ...) ([]byte, error)

+ func (_SafeL2V130 *SafeL2V130Session) ExecTransaction(to common.Address, value *big.Int, data []byte, operation uint8, ...) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Session) ExecTransactionFromModule(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Session) ExecTransactionFromModuleReturnData(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Session) Fallback(calldata []byte) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Session) GetChainId() (*big.Int, error)

+ func (_SafeL2V130 *SafeL2V130Session) GetModulesPaginated(start common.Address, pageSize *big.Int) (struct{ ... }, error)

+ func (_SafeL2V130 *SafeL2V130Session) GetOwners() ([]common.Address, error)

+ func (_SafeL2V130 *SafeL2V130Session) GetStorageAt(offset *big.Int, length *big.Int) ([]byte, error)

+ func (_SafeL2V130 *SafeL2V130Session) GetThreshold() (*big.Int, error)

+ func (_SafeL2V130 *SafeL2V130Session) GetTransactionHash(to common.Address, value *big.Int, data []byte, operation uint8, ...) ([32]byte, error)

+ func (_SafeL2V130 *SafeL2V130Session) IsModuleEnabled(module common.Address) (bool, error)

+ func (_SafeL2V130 *SafeL2V130Session) IsOwner(owner common.Address) (bool, error)

+ func (_SafeL2V130 *SafeL2V130Session) Nonce() (*big.Int, error)

+ func (_SafeL2V130 *SafeL2V130Session) Receive() (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Session) RemoveOwner(prevOwner common.Address, owner common.Address, _threshold *big.Int) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Session) RequiredTxGas(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Session) SetFallbackHandler(handler common.Address) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Session) SetGuard(guard common.Address) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Session) Setup(_owners []common.Address, _threshold *big.Int, to common.Address, data []byte, ...) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Session) SignedMessages(arg0 [32]byte) (*big.Int, error)

+ func (_SafeL2V130 *SafeL2V130Session) SimulateAndRevert(targetContract common.Address, calldataPayload []byte) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Session) SwapOwner(prevOwner common.Address, oldOwner common.Address, newOwner common.Address) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Session) VERSION() (string, error)

+ type SafeL2V130SignMsg struct

+ MsgHash [32]byte

+ Raw types.Log

+ type SafeL2V130SignMsgIterator struct

+ Event *SafeL2V130SignMsg

+ func (it *SafeL2V130SignMsgIterator) Close() error

+ func (it *SafeL2V130SignMsgIterator) Error() error

+ func (it *SafeL2V130SignMsgIterator) Next() bool

+ type SafeL2V130Transactor struct

+ func NewSafeL2V130Transactor(address common.Address, transactor bind.ContractTransactor) (*SafeL2V130Transactor, error)

+ func (_SafeL2V130 *SafeL2V130Transactor) AddOwnerWithThreshold(opts *bind.TransactOpts, owner common.Address, _threshold *big.Int) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Transactor) ApproveHash(opts *bind.TransactOpts, hashToApprove [32]byte) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Transactor) ChangeThreshold(opts *bind.TransactOpts, _threshold *big.Int) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Transactor) DisableModule(opts *bind.TransactOpts, prevModule common.Address, module common.Address) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Transactor) EnableModule(opts *bind.TransactOpts, module common.Address) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Transactor) ExecTransaction(opts *bind.TransactOpts, to common.Address, value *big.Int, data []byte, ...) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Transactor) ExecTransactionFromModule(opts *bind.TransactOpts, to common.Address, value *big.Int, data []byte, ...) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Transactor) ExecTransactionFromModuleReturnData(opts *bind.TransactOpts, to common.Address, value *big.Int, data []byte, ...) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Transactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Transactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Transactor) RemoveOwner(opts *bind.TransactOpts, prevOwner common.Address, owner common.Address, ...) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Transactor) RequiredTxGas(opts *bind.TransactOpts, to common.Address, value *big.Int, data []byte, ...) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Transactor) SetFallbackHandler(opts *bind.TransactOpts, handler common.Address) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Transactor) SetGuard(opts *bind.TransactOpts, guard common.Address) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Transactor) Setup(opts *bind.TransactOpts, _owners []common.Address, _threshold *big.Int, ...) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Transactor) SimulateAndRevert(opts *bind.TransactOpts, targetContract common.Address, calldataPayload []byte) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130Transactor) SwapOwner(opts *bind.TransactOpts, prevOwner common.Address, oldOwner common.Address, ...) (*types.Transaction, error)

+ type SafeL2V130TransactorRaw struct

+ Contract *SafeL2V130Transactor

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

+ func (_SafeL2V130 *SafeL2V130TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeL2V130TransactorSession struct

+ Contract *SafeL2V130Transactor

+ TransactOpts bind.TransactOpts

+ func (_SafeL2V130 *SafeL2V130TransactorSession) AddOwnerWithThreshold(owner common.Address, _threshold *big.Int) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130TransactorSession) ApproveHash(hashToApprove [32]byte) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130TransactorSession) ChangeThreshold(_threshold *big.Int) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130TransactorSession) DisableModule(prevModule common.Address, module common.Address) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130TransactorSession) EnableModule(module common.Address) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130TransactorSession) ExecTransaction(to common.Address, value *big.Int, data []byte, operation uint8, ...) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130TransactorSession) ExecTransactionFromModule(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130TransactorSession) ExecTransactionFromModuleReturnData(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130TransactorSession) Fallback(calldata []byte) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130TransactorSession) Receive() (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130TransactorSession) RemoveOwner(prevOwner common.Address, owner common.Address, _threshold *big.Int) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130TransactorSession) RequiredTxGas(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130TransactorSession) SetFallbackHandler(handler common.Address) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130TransactorSession) SetGuard(guard common.Address) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130TransactorSession) Setup(_owners []common.Address, _threshold *big.Int, to common.Address, data []byte, ...) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130TransactorSession) SimulateAndRevert(targetContract common.Address, calldataPayload []byte) (*types.Transaction, error)

+ func (_SafeL2V130 *SafeL2V130TransactorSession) SwapOwner(prevOwner common.Address, oldOwner common.Address, newOwner common.Address) (*types.Transaction, error)

+ type SafeSingletonFactory struct

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

+ func NewSafeSingletonFactory(address common.Address, backend bind.ContractBackend) (*SafeSingletonFactory, error)

+ type SafeSingletonFactoryCaller struct

+ func NewSafeSingletonFactoryCaller(address common.Address, caller bind.ContractCaller) (*SafeSingletonFactoryCaller, error)

+ type SafeSingletonFactoryCallerRaw struct

+ Contract *SafeSingletonFactoryCaller

+ func (_SafeSingletonFactory *SafeSingletonFactoryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type SafeSingletonFactoryCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SafeSingletonFactoryCaller

+ type SafeSingletonFactoryFilterer struct

+ func NewSafeSingletonFactoryFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeSingletonFactoryFilterer, error)

+ type SafeSingletonFactoryRaw struct

+ Contract *SafeSingletonFactory

+ func (_SafeSingletonFactory *SafeSingletonFactoryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_SafeSingletonFactory *SafeSingletonFactoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeSingletonFactorySession struct

+ CallOpts bind.CallOpts

+ Contract *SafeSingletonFactory

+ TransactOpts bind.TransactOpts

+ func (_SafeSingletonFactory *SafeSingletonFactorySession) Fallback(calldata []byte) (*types.Transaction, error)

+ type SafeSingletonFactoryTransactor struct

+ func NewSafeSingletonFactoryTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeSingletonFactoryTransactor, error)

+ func (_SafeSingletonFactory *SafeSingletonFactoryTransactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error)

+ type SafeSingletonFactoryTransactorRaw struct

+ Contract *SafeSingletonFactoryTransactor

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

+ func (_SafeSingletonFactory *SafeSingletonFactoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeSingletonFactoryTransactorSession struct

+ Contract *SafeSingletonFactoryTransactor

+ TransactOpts bind.TransactOpts

+ func (_SafeSingletonFactory *SafeSingletonFactoryTransactorSession) Fallback(calldata []byte) (*types.Transaction, error)

+ type SafeV130 struct

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

+ func NewSafeV130(address common.Address, backend bind.ContractBackend) (*SafeV130, error)

+ type SafeV130AddedOwner struct

+ Owner common.Address

+ Raw types.Log

+ type SafeV130AddedOwnerIterator struct

+ Event *SafeV130AddedOwner

+ func (it *SafeV130AddedOwnerIterator) Close() error

+ func (it *SafeV130AddedOwnerIterator) Error() error

+ func (it *SafeV130AddedOwnerIterator) Next() bool

+ type SafeV130ApproveHash struct

+ ApprovedHash [32]byte

+ Owner common.Address

+ Raw types.Log

+ type SafeV130ApproveHashIterator struct

+ Event *SafeV130ApproveHash

+ func (it *SafeV130ApproveHashIterator) Close() error

+ func (it *SafeV130ApproveHashIterator) Error() error

+ func (it *SafeV130ApproveHashIterator) Next() bool

+ type SafeV130Caller struct

+ func NewSafeV130Caller(address common.Address, caller bind.ContractCaller) (*SafeV130Caller, error)

+ func (_SafeV130 *SafeV130Caller) ApprovedHashes(opts *bind.CallOpts, arg0 common.Address, arg1 [32]byte) (*big.Int, error)

+ func (_SafeV130 *SafeV130Caller) CheckNSignatures(opts *bind.CallOpts, dataHash [32]byte, data []byte, signatures []byte, ...) error

+ func (_SafeV130 *SafeV130Caller) CheckSignatures(opts *bind.CallOpts, dataHash [32]byte, data []byte, signatures []byte) error

+ func (_SafeV130 *SafeV130Caller) DomainSeparator(opts *bind.CallOpts) ([32]byte, error)

+ func (_SafeV130 *SafeV130Caller) EncodeTransactionData(opts *bind.CallOpts, to common.Address, value *big.Int, data []byte, ...) ([]byte, error)

+ func (_SafeV130 *SafeV130Caller) GetChainId(opts *bind.CallOpts) (*big.Int, error)

+ func (_SafeV130 *SafeV130Caller) GetModulesPaginated(opts *bind.CallOpts, start common.Address, pageSize *big.Int) (struct{ ... }, error)

+ func (_SafeV130 *SafeV130Caller) GetOwners(opts *bind.CallOpts) ([]common.Address, error)

+ func (_SafeV130 *SafeV130Caller) GetStorageAt(opts *bind.CallOpts, offset *big.Int, length *big.Int) ([]byte, error)

+ func (_SafeV130 *SafeV130Caller) GetThreshold(opts *bind.CallOpts) (*big.Int, error)

+ func (_SafeV130 *SafeV130Caller) GetTransactionHash(opts *bind.CallOpts, to common.Address, value *big.Int, data []byte, ...) ([32]byte, error)

+ func (_SafeV130 *SafeV130Caller) IsModuleEnabled(opts *bind.CallOpts, module common.Address) (bool, error)

+ func (_SafeV130 *SafeV130Caller) IsOwner(opts *bind.CallOpts, owner common.Address) (bool, error)

+ func (_SafeV130 *SafeV130Caller) Nonce(opts *bind.CallOpts) (*big.Int, error)

+ func (_SafeV130 *SafeV130Caller) SignedMessages(opts *bind.CallOpts, arg0 [32]byte) (*big.Int, error)

+ func (_SafeV130 *SafeV130Caller) VERSION(opts *bind.CallOpts) (string, error)

+ type SafeV130CallerRaw struct

+ Contract *SafeV130Caller

+ func (_SafeV130 *SafeV130CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type SafeV130CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SafeV130Caller

+ func (_SafeV130 *SafeV130CallerSession) ApprovedHashes(arg0 common.Address, arg1 [32]byte) (*big.Int, error)

+ func (_SafeV130 *SafeV130CallerSession) CheckNSignatures(dataHash [32]byte, data []byte, signatures []byte, requiredSignatures *big.Int) error

+ func (_SafeV130 *SafeV130CallerSession) CheckSignatures(dataHash [32]byte, data []byte, signatures []byte) error

+ func (_SafeV130 *SafeV130CallerSession) DomainSeparator() ([32]byte, error)

+ func (_SafeV130 *SafeV130CallerSession) EncodeTransactionData(to common.Address, value *big.Int, data []byte, operation uint8, ...) ([]byte, error)

+ func (_SafeV130 *SafeV130CallerSession) GetChainId() (*big.Int, error)

+ func (_SafeV130 *SafeV130CallerSession) GetModulesPaginated(start common.Address, pageSize *big.Int) (struct{ ... }, error)

+ func (_SafeV130 *SafeV130CallerSession) GetOwners() ([]common.Address, error)

+ func (_SafeV130 *SafeV130CallerSession) GetStorageAt(offset *big.Int, length *big.Int) ([]byte, error)

+ func (_SafeV130 *SafeV130CallerSession) GetThreshold() (*big.Int, error)

+ func (_SafeV130 *SafeV130CallerSession) GetTransactionHash(to common.Address, value *big.Int, data []byte, operation uint8, ...) ([32]byte, error)

+ func (_SafeV130 *SafeV130CallerSession) IsModuleEnabled(module common.Address) (bool, error)

+ func (_SafeV130 *SafeV130CallerSession) IsOwner(owner common.Address) (bool, error)

+ func (_SafeV130 *SafeV130CallerSession) Nonce() (*big.Int, error)

+ func (_SafeV130 *SafeV130CallerSession) SignedMessages(arg0 [32]byte) (*big.Int, error)

+ func (_SafeV130 *SafeV130CallerSession) VERSION() (string, error)

+ type SafeV130ChangedFallbackHandler struct

+ Handler common.Address

+ Raw types.Log

+ type SafeV130ChangedFallbackHandlerIterator struct

+ Event *SafeV130ChangedFallbackHandler

+ func (it *SafeV130ChangedFallbackHandlerIterator) Close() error

+ func (it *SafeV130ChangedFallbackHandlerIterator) Error() error

+ func (it *SafeV130ChangedFallbackHandlerIterator) Next() bool

+ type SafeV130ChangedGuard struct

+ Guard common.Address

+ Raw types.Log

+ type SafeV130ChangedGuardIterator struct

+ Event *SafeV130ChangedGuard

+ func (it *SafeV130ChangedGuardIterator) Close() error

+ func (it *SafeV130ChangedGuardIterator) Error() error

+ func (it *SafeV130ChangedGuardIterator) Next() bool

+ type SafeV130ChangedThreshold struct

+ Raw types.Log

+ Threshold *big.Int

+ type SafeV130ChangedThresholdIterator struct

+ Event *SafeV130ChangedThreshold

+ func (it *SafeV130ChangedThresholdIterator) Close() error

+ func (it *SafeV130ChangedThresholdIterator) Error() error

+ func (it *SafeV130ChangedThresholdIterator) Next() bool

+ type SafeV130DisabledModule struct

+ Module common.Address

+ Raw types.Log

+ type SafeV130DisabledModuleIterator struct

+ Event *SafeV130DisabledModule

+ func (it *SafeV130DisabledModuleIterator) Close() error

+ func (it *SafeV130DisabledModuleIterator) Error() error

+ func (it *SafeV130DisabledModuleIterator) Next() bool

+ type SafeV130EnabledModule struct

+ Module common.Address

+ Raw types.Log

+ type SafeV130EnabledModuleIterator struct

+ Event *SafeV130EnabledModule

+ func (it *SafeV130EnabledModuleIterator) Close() error

+ func (it *SafeV130EnabledModuleIterator) Error() error

+ func (it *SafeV130EnabledModuleIterator) Next() bool

+ type SafeV130ExecutionFailure struct

+ Payment *big.Int

+ Raw types.Log

+ TxHash [32]byte

+ type SafeV130ExecutionFailureIterator struct

+ Event *SafeV130ExecutionFailure

+ func (it *SafeV130ExecutionFailureIterator) Close() error

+ func (it *SafeV130ExecutionFailureIterator) Error() error

+ func (it *SafeV130ExecutionFailureIterator) Next() bool

+ type SafeV130ExecutionFromModuleFailure struct

+ Module common.Address

+ Raw types.Log

+ type SafeV130ExecutionFromModuleFailureIterator struct

+ Event *SafeV130ExecutionFromModuleFailure

+ func (it *SafeV130ExecutionFromModuleFailureIterator) Close() error

+ func (it *SafeV130ExecutionFromModuleFailureIterator) Error() error

+ func (it *SafeV130ExecutionFromModuleFailureIterator) Next() bool

+ type SafeV130ExecutionFromModuleSuccess struct

+ Module common.Address

+ Raw types.Log

+ type SafeV130ExecutionFromModuleSuccessIterator struct

+ Event *SafeV130ExecutionFromModuleSuccess

+ func (it *SafeV130ExecutionFromModuleSuccessIterator) Close() error

+ func (it *SafeV130ExecutionFromModuleSuccessIterator) Error() error

+ func (it *SafeV130ExecutionFromModuleSuccessIterator) Next() bool

+ type SafeV130ExecutionSuccess struct

+ Payment *big.Int

+ Raw types.Log

+ TxHash [32]byte

+ type SafeV130ExecutionSuccessIterator struct

+ Event *SafeV130ExecutionSuccess

+ func (it *SafeV130ExecutionSuccessIterator) Close() error

+ func (it *SafeV130ExecutionSuccessIterator) Error() error

+ func (it *SafeV130ExecutionSuccessIterator) Next() bool

+ type SafeV130Filterer struct

+ func NewSafeV130Filterer(address common.Address, filterer bind.ContractFilterer) (*SafeV130Filterer, error)

+ func (_SafeV130 *SafeV130Filterer) FilterAddedOwner(opts *bind.FilterOpts) (*SafeV130AddedOwnerIterator, error)

+ func (_SafeV130 *SafeV130Filterer) FilterApproveHash(opts *bind.FilterOpts, approvedHash [][32]byte, owner []common.Address) (*SafeV130ApproveHashIterator, error)

+ func (_SafeV130 *SafeV130Filterer) FilterChangedFallbackHandler(opts *bind.FilterOpts) (*SafeV130ChangedFallbackHandlerIterator, error)

+ func (_SafeV130 *SafeV130Filterer) FilterChangedGuard(opts *bind.FilterOpts) (*SafeV130ChangedGuardIterator, error)

+ func (_SafeV130 *SafeV130Filterer) FilterChangedThreshold(opts *bind.FilterOpts) (*SafeV130ChangedThresholdIterator, error)

+ func (_SafeV130 *SafeV130Filterer) FilterDisabledModule(opts *bind.FilterOpts) (*SafeV130DisabledModuleIterator, error)

+ func (_SafeV130 *SafeV130Filterer) FilterEnabledModule(opts *bind.FilterOpts) (*SafeV130EnabledModuleIterator, error)

+ func (_SafeV130 *SafeV130Filterer) FilterExecutionFailure(opts *bind.FilterOpts) (*SafeV130ExecutionFailureIterator, error)

+ func (_SafeV130 *SafeV130Filterer) FilterExecutionFromModuleFailure(opts *bind.FilterOpts, module []common.Address) (*SafeV130ExecutionFromModuleFailureIterator, error)

+ func (_SafeV130 *SafeV130Filterer) FilterExecutionFromModuleSuccess(opts *bind.FilterOpts, module []common.Address) (*SafeV130ExecutionFromModuleSuccessIterator, error)

+ func (_SafeV130 *SafeV130Filterer) FilterExecutionSuccess(opts *bind.FilterOpts) (*SafeV130ExecutionSuccessIterator, error)

+ func (_SafeV130 *SafeV130Filterer) FilterRemovedOwner(opts *bind.FilterOpts) (*SafeV130RemovedOwnerIterator, error)

+ func (_SafeV130 *SafeV130Filterer) FilterSafeReceived(opts *bind.FilterOpts, sender []common.Address) (*SafeV130SafeReceivedIterator, error)

+ func (_SafeV130 *SafeV130Filterer) FilterSafeSetup(opts *bind.FilterOpts, initiator []common.Address) (*SafeV130SafeSetupIterator, error)

+ func (_SafeV130 *SafeV130Filterer) FilterSignMsg(opts *bind.FilterOpts, msgHash [][32]byte) (*SafeV130SignMsgIterator, error)

+ func (_SafeV130 *SafeV130Filterer) ParseAddedOwner(log types.Log) (*SafeV130AddedOwner, error)

+ func (_SafeV130 *SafeV130Filterer) ParseApproveHash(log types.Log) (*SafeV130ApproveHash, error)

+ func (_SafeV130 *SafeV130Filterer) ParseChangedFallbackHandler(log types.Log) (*SafeV130ChangedFallbackHandler, error)

+ func (_SafeV130 *SafeV130Filterer) ParseChangedGuard(log types.Log) (*SafeV130ChangedGuard, error)

+ func (_SafeV130 *SafeV130Filterer) ParseChangedThreshold(log types.Log) (*SafeV130ChangedThreshold, error)

+ func (_SafeV130 *SafeV130Filterer) ParseDisabledModule(log types.Log) (*SafeV130DisabledModule, error)

+ func (_SafeV130 *SafeV130Filterer) ParseEnabledModule(log types.Log) (*SafeV130EnabledModule, error)

+ func (_SafeV130 *SafeV130Filterer) ParseExecutionFailure(log types.Log) (*SafeV130ExecutionFailure, error)

+ func (_SafeV130 *SafeV130Filterer) ParseExecutionFromModuleFailure(log types.Log) (*SafeV130ExecutionFromModuleFailure, error)

+ func (_SafeV130 *SafeV130Filterer) ParseExecutionFromModuleSuccess(log types.Log) (*SafeV130ExecutionFromModuleSuccess, error)

+ func (_SafeV130 *SafeV130Filterer) ParseExecutionSuccess(log types.Log) (*SafeV130ExecutionSuccess, error)

+ func (_SafeV130 *SafeV130Filterer) ParseRemovedOwner(log types.Log) (*SafeV130RemovedOwner, error)

+ func (_SafeV130 *SafeV130Filterer) ParseSafeReceived(log types.Log) (*SafeV130SafeReceived, error)

+ func (_SafeV130 *SafeV130Filterer) ParseSafeSetup(log types.Log) (*SafeV130SafeSetup, error)

+ func (_SafeV130 *SafeV130Filterer) ParseSignMsg(log types.Log) (*SafeV130SignMsg, error)

+ func (_SafeV130 *SafeV130Filterer) WatchAddedOwner(opts *bind.WatchOpts, sink chan<- *SafeV130AddedOwner) (event.Subscription, error)

+ func (_SafeV130 *SafeV130Filterer) WatchApproveHash(opts *bind.WatchOpts, sink chan<- *SafeV130ApproveHash, ...) (event.Subscription, error)

+ func (_SafeV130 *SafeV130Filterer) WatchChangedFallbackHandler(opts *bind.WatchOpts, sink chan<- *SafeV130ChangedFallbackHandler) (event.Subscription, error)

+ func (_SafeV130 *SafeV130Filterer) WatchChangedGuard(opts *bind.WatchOpts, sink chan<- *SafeV130ChangedGuard) (event.Subscription, error)

+ func (_SafeV130 *SafeV130Filterer) WatchChangedThreshold(opts *bind.WatchOpts, sink chan<- *SafeV130ChangedThreshold) (event.Subscription, error)

+ func (_SafeV130 *SafeV130Filterer) WatchDisabledModule(opts *bind.WatchOpts, sink chan<- *SafeV130DisabledModule) (event.Subscription, error)

+ func (_SafeV130 *SafeV130Filterer) WatchEnabledModule(opts *bind.WatchOpts, sink chan<- *SafeV130EnabledModule) (event.Subscription, error)

+ func (_SafeV130 *SafeV130Filterer) WatchExecutionFailure(opts *bind.WatchOpts, sink chan<- *SafeV130ExecutionFailure) (event.Subscription, error)

+ func (_SafeV130 *SafeV130Filterer) WatchExecutionFromModuleFailure(opts *bind.WatchOpts, sink chan<- *SafeV130ExecutionFromModuleFailure, ...) (event.Subscription, error)

+ func (_SafeV130 *SafeV130Filterer) WatchExecutionFromModuleSuccess(opts *bind.WatchOpts, sink chan<- *SafeV130ExecutionFromModuleSuccess, ...) (event.Subscription, error)

+ func (_SafeV130 *SafeV130Filterer) WatchExecutionSuccess(opts *bind.WatchOpts, sink chan<- *SafeV130ExecutionSuccess) (event.Subscription, error)

+ func (_SafeV130 *SafeV130Filterer) WatchRemovedOwner(opts *bind.WatchOpts, sink chan<- *SafeV130RemovedOwner) (event.Subscription, error)

+ func (_SafeV130 *SafeV130Filterer) WatchSafeReceived(opts *bind.WatchOpts, sink chan<- *SafeV130SafeReceived, ...) (event.Subscription, error)

+ func (_SafeV130 *SafeV130Filterer) WatchSafeSetup(opts *bind.WatchOpts, sink chan<- *SafeV130SafeSetup, ...) (event.Subscription, error)

+ func (_SafeV130 *SafeV130Filterer) WatchSignMsg(opts *bind.WatchOpts, sink chan<- *SafeV130SignMsg, msgHash [][32]byte) (event.Subscription, error)

+ type SafeV130Raw struct

+ Contract *SafeV130

+ func (_SafeV130 *SafeV130Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_SafeV130 *SafeV130Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeV130RemovedOwner struct

+ Owner common.Address

+ Raw types.Log

+ type SafeV130RemovedOwnerIterator struct

+ Event *SafeV130RemovedOwner

+ func (it *SafeV130RemovedOwnerIterator) Close() error

+ func (it *SafeV130RemovedOwnerIterator) Error() error

+ func (it *SafeV130RemovedOwnerIterator) Next() bool

+ type SafeV130SafeReceived struct

+ Raw types.Log

+ Sender common.Address

+ Value *big.Int

+ type SafeV130SafeReceivedIterator struct

+ Event *SafeV130SafeReceived

+ func (it *SafeV130SafeReceivedIterator) Close() error

+ func (it *SafeV130SafeReceivedIterator) Error() error

+ func (it *SafeV130SafeReceivedIterator) Next() bool

+ type SafeV130SafeSetup struct

+ FallbackHandler common.Address

+ Initializer common.Address

+ Initiator common.Address

+ Owners []common.Address

+ Raw types.Log

+ Threshold *big.Int

+ type SafeV130SafeSetupIterator struct

+ Event *SafeV130SafeSetup

+ func (it *SafeV130SafeSetupIterator) Close() error

+ func (it *SafeV130SafeSetupIterator) Error() error

+ func (it *SafeV130SafeSetupIterator) Next() bool

+ type SafeV130Session struct

+ CallOpts bind.CallOpts

+ Contract *SafeV130

+ TransactOpts bind.TransactOpts

+ func (_SafeV130 *SafeV130Session) AddOwnerWithThreshold(owner common.Address, _threshold *big.Int) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Session) ApproveHash(hashToApprove [32]byte) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Session) ApprovedHashes(arg0 common.Address, arg1 [32]byte) (*big.Int, error)

+ func (_SafeV130 *SafeV130Session) ChangeThreshold(_threshold *big.Int) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Session) CheckNSignatures(dataHash [32]byte, data []byte, signatures []byte, requiredSignatures *big.Int) error

+ func (_SafeV130 *SafeV130Session) CheckSignatures(dataHash [32]byte, data []byte, signatures []byte) error

+ func (_SafeV130 *SafeV130Session) DisableModule(prevModule common.Address, module common.Address) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Session) DomainSeparator() ([32]byte, error)

+ func (_SafeV130 *SafeV130Session) EnableModule(module common.Address) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Session) EncodeTransactionData(to common.Address, value *big.Int, data []byte, operation uint8, ...) ([]byte, error)

+ func (_SafeV130 *SafeV130Session) ExecTransaction(to common.Address, value *big.Int, data []byte, operation uint8, ...) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Session) ExecTransactionFromModule(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Session) ExecTransactionFromModuleReturnData(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Session) Fallback(calldata []byte) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Session) GetChainId() (*big.Int, error)

+ func (_SafeV130 *SafeV130Session) GetModulesPaginated(start common.Address, pageSize *big.Int) (struct{ ... }, error)

+ func (_SafeV130 *SafeV130Session) GetOwners() ([]common.Address, error)

+ func (_SafeV130 *SafeV130Session) GetStorageAt(offset *big.Int, length *big.Int) ([]byte, error)

+ func (_SafeV130 *SafeV130Session) GetThreshold() (*big.Int, error)

+ func (_SafeV130 *SafeV130Session) GetTransactionHash(to common.Address, value *big.Int, data []byte, operation uint8, ...) ([32]byte, error)

+ func (_SafeV130 *SafeV130Session) IsModuleEnabled(module common.Address) (bool, error)

+ func (_SafeV130 *SafeV130Session) IsOwner(owner common.Address) (bool, error)

+ func (_SafeV130 *SafeV130Session) Nonce() (*big.Int, error)

+ func (_SafeV130 *SafeV130Session) Receive() (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Session) RemoveOwner(prevOwner common.Address, owner common.Address, _threshold *big.Int) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Session) RequiredTxGas(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Session) SetFallbackHandler(handler common.Address) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Session) SetGuard(guard common.Address) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Session) Setup(_owners []common.Address, _threshold *big.Int, to common.Address, data []byte, ...) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Session) SignedMessages(arg0 [32]byte) (*big.Int, error)

+ func (_SafeV130 *SafeV130Session) SimulateAndRevert(targetContract common.Address, calldataPayload []byte) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Session) SwapOwner(prevOwner common.Address, oldOwner common.Address, newOwner common.Address) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Session) VERSION() (string, error)

+ type SafeV130SignMsg struct

+ MsgHash [32]byte

+ Raw types.Log

+ type SafeV130SignMsgIterator struct

+ Event *SafeV130SignMsg

+ func (it *SafeV130SignMsgIterator) Close() error

+ func (it *SafeV130SignMsgIterator) Error() error

+ func (it *SafeV130SignMsgIterator) Next() bool

+ type SafeV130Transactor struct

+ func NewSafeV130Transactor(address common.Address, transactor bind.ContractTransactor) (*SafeV130Transactor, error)

+ func (_SafeV130 *SafeV130Transactor) AddOwnerWithThreshold(opts *bind.TransactOpts, owner common.Address, _threshold *big.Int) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Transactor) ApproveHash(opts *bind.TransactOpts, hashToApprove [32]byte) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Transactor) ChangeThreshold(opts *bind.TransactOpts, _threshold *big.Int) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Transactor) DisableModule(opts *bind.TransactOpts, prevModule common.Address, module common.Address) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Transactor) EnableModule(opts *bind.TransactOpts, module common.Address) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Transactor) ExecTransaction(opts *bind.TransactOpts, to common.Address, value *big.Int, data []byte, ...) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Transactor) ExecTransactionFromModule(opts *bind.TransactOpts, to common.Address, value *big.Int, data []byte, ...) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Transactor) ExecTransactionFromModuleReturnData(opts *bind.TransactOpts, to common.Address, value *big.Int, data []byte, ...) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Transactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Transactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Transactor) RemoveOwner(opts *bind.TransactOpts, prevOwner common.Address, owner common.Address, ...) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Transactor) RequiredTxGas(opts *bind.TransactOpts, to common.Address, value *big.Int, data []byte, ...) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Transactor) SetFallbackHandler(opts *bind.TransactOpts, handler common.Address) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Transactor) SetGuard(opts *bind.TransactOpts, guard common.Address) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Transactor) Setup(opts *bind.TransactOpts, _owners []common.Address, _threshold *big.Int, ...) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Transactor) SimulateAndRevert(opts *bind.TransactOpts, targetContract common.Address, calldataPayload []byte) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130Transactor) SwapOwner(opts *bind.TransactOpts, prevOwner common.Address, oldOwner common.Address, ...) (*types.Transaction, error)

+ type SafeV130TransactorRaw struct

+ Contract *SafeV130Transactor

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

+ func (_SafeV130 *SafeV130TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeV130TransactorSession struct

+ Contract *SafeV130Transactor

+ TransactOpts bind.TransactOpts

+ func (_SafeV130 *SafeV130TransactorSession) AddOwnerWithThreshold(owner common.Address, _threshold *big.Int) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130TransactorSession) ApproveHash(hashToApprove [32]byte) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130TransactorSession) ChangeThreshold(_threshold *big.Int) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130TransactorSession) DisableModule(prevModule common.Address, module common.Address) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130TransactorSession) EnableModule(module common.Address) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130TransactorSession) ExecTransaction(to common.Address, value *big.Int, data []byte, operation uint8, ...) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130TransactorSession) ExecTransactionFromModule(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130TransactorSession) ExecTransactionFromModuleReturnData(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130TransactorSession) Fallback(calldata []byte) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130TransactorSession) Receive() (*types.Transaction, error)

+ func (_SafeV130 *SafeV130TransactorSession) RemoveOwner(prevOwner common.Address, owner common.Address, _threshold *big.Int) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130TransactorSession) RequiredTxGas(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130TransactorSession) SetFallbackHandler(handler common.Address) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130TransactorSession) SetGuard(guard common.Address) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130TransactorSession) Setup(_owners []common.Address, _threshold *big.Int, to common.Address, data []byte, ...) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130TransactorSession) SimulateAndRevert(targetContract common.Address, calldataPayload []byte) (*types.Transaction, error)

+ func (_SafeV130 *SafeV130TransactorSession) SwapOwner(prevOwner common.Address, oldOwner common.Address, newOwner common.Address) (*types.Transaction, error)

+ type SenderCreator struct

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

+ func NewSenderCreator(address common.Address, backend bind.ContractBackend) (*SenderCreator, error)

+ type SenderCreatorCaller struct

+ func NewSenderCreatorCaller(address common.Address, caller bind.ContractCaller) (*SenderCreatorCaller, error)

+ type SenderCreatorCallerRaw struct

+ Contract *SenderCreatorCaller

+ func (_SenderCreator *SenderCreatorCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type SenderCreatorCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SenderCreatorCaller

+ type SenderCreatorFilterer struct

+ func NewSenderCreatorFilterer(address common.Address, filterer bind.ContractFilterer) (*SenderCreatorFilterer, error)

+ type SenderCreatorRaw struct

+ Contract *SenderCreator

+ func (_SenderCreator *SenderCreatorRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_SenderCreator *SenderCreatorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SenderCreatorSession struct

+ CallOpts bind.CallOpts

+ Contract *SenderCreator

+ TransactOpts bind.TransactOpts

+ func (_SenderCreator *SenderCreatorSession) CreateSender(initCode []byte) (*types.Transaction, error)

+ type SenderCreatorTransactor struct

+ func NewSenderCreatorTransactor(address common.Address, transactor bind.ContractTransactor) (*SenderCreatorTransactor, error)

+ func (_SenderCreator *SenderCreatorTransactor) CreateSender(opts *bind.TransactOpts, initCode []byte) (*types.Transaction, error)

+ type SenderCreatorTransactorRaw struct

+ Contract *SenderCreatorTransactor

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

+ func (_SenderCreator *SenderCreatorTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SenderCreatorTransactorSession struct

+ Contract *SenderCreatorTransactor

+ TransactOpts bind.TransactOpts

+ func (_SenderCreator *SenderCreatorTransactorSession) CreateSender(initCode []byte) (*types.Transaction, error)

type SystemConfigCaller

+ func (_SystemConfig *SystemConfigCaller) STARTBLOCKSLOT(opts *bind.CallOpts) ([32]byte, error)

type SystemConfigCallerSession

+ func (_SystemConfig *SystemConfigCallerSession) STARTBLOCKSLOT() ([32]byte, error)

type SystemConfigSession

+ func (_SystemConfig *SystemConfigSession) STARTBLOCKSLOT() ([32]byte, error)

+ type UserOperation struct

+ CallData []byte

+ CallGasLimit *big.Int

+ InitCode []byte

+ MaxFeePerGas *big.Int

+ MaxPriorityFeePerGas *big.Int

+ Nonce *big.Int

+ PaymasterAndData []byte

+ PreVerificationGas *big.Int

+ Sender common.Address

+ Signature []byte

+ VerificationGasLimit *big.Int

v1.4.0-rc.1

Apr 12, 2024

v1.3.4

Apr 1, 2024

v1.3.3

Mar 28, 2024

v1.3.3-rc.2

Mar 27, 2024

v1.3.3-rc.1

Mar 23, 2024

v1.3.2

Mar 4, 2024

v1.3.2-rc.1

Feb 28, 2024

v1.3.1

Feb 22, 2024

v1.3.0

Feb 16, 2024

Changes in this version

+ const AlphabetVM2StorageLayoutJSON

+ const OutputBisectionGameStorageLayoutJSON

+ const SuperchainConfigStorageLayoutJSON

+ var AlphabetVM2ABI = AlphabetVM2MetaData.ABI

+ var AlphabetVM2Bin = AlphabetVM2MetaData.Bin

+ var AlphabetVM2MetaData = &bind.MetaData

+ var AlphabetVM2StorageLayout = new(solc.StorageLayout)

+ var Create2DeployerCodeHash = common.HexToHash("0xb0550b5b431e30d38000efb7107aaa0ade03d48a7198a140edda9d27134468b2")

+ var OutputBisectionGameABI = OutputBisectionGameMetaData.ABI

+ var OutputBisectionGameBin = OutputBisectionGameMetaData.Bin

+ var OutputBisectionGameMetaData = &bind.MetaData

+ var OutputBisectionGameStorageLayout = new(solc.StorageLayout)

+ var SuperchainConfigABI = SuperchainConfigMetaData.ABI

+ var SuperchainConfigBin = SuperchainConfigMetaData.Bin

+ var SuperchainConfigMetaData = &bind.MetaData

+ var SuperchainConfigStorageLayout = new(solc.StorageLayout)

+ func HasImmutableReferences(name string) (bool, error)

+ type AlphabetVM2 struct

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

+ func NewAlphabetVM2(address common.Address, backend bind.ContractBackend) (*AlphabetVM2, error)

+ type AlphabetVM2Caller struct

+ func NewAlphabetVM2Caller(address common.Address, caller bind.ContractCaller) (*AlphabetVM2Caller, error)

+ func (_AlphabetVM2 *AlphabetVM2Caller) Oracle(opts *bind.CallOpts) (common.Address, error)

+ type AlphabetVM2CallerRaw struct

+ Contract *AlphabetVM2Caller

+ func (_AlphabetVM2 *AlphabetVM2CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type AlphabetVM2CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *AlphabetVM2Caller

+ func (_AlphabetVM2 *AlphabetVM2CallerSession) Oracle() (common.Address, error)

+ type AlphabetVM2Filterer struct

+ func NewAlphabetVM2Filterer(address common.Address, filterer bind.ContractFilterer) (*AlphabetVM2Filterer, error)

+ type AlphabetVM2Raw struct

+ Contract *AlphabetVM2

+ func (_AlphabetVM2 *AlphabetVM2Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_AlphabetVM2 *AlphabetVM2Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AlphabetVM2Session struct

+ CallOpts bind.CallOpts

+ Contract *AlphabetVM2

+ TransactOpts bind.TransactOpts

+ func (_AlphabetVM2 *AlphabetVM2Session) Oracle() (common.Address, error)

+ func (_AlphabetVM2 *AlphabetVM2Session) Step(_stateData []byte, arg1 []byte, _localContext [32]byte) (*types.Transaction, error)

+ type AlphabetVM2Transactor struct

+ func NewAlphabetVM2Transactor(address common.Address, transactor bind.ContractTransactor) (*AlphabetVM2Transactor, error)

+ func (_AlphabetVM2 *AlphabetVM2Transactor) Step(opts *bind.TransactOpts, _stateData []byte, arg1 []byte, ...) (*types.Transaction, error)

+ type AlphabetVM2TransactorRaw struct

+ Contract *AlphabetVM2Transactor

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

+ func (_AlphabetVM2 *AlphabetVM2TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AlphabetVM2TransactorSession struct

+ Contract *AlphabetVM2Transactor

+ TransactOpts bind.TransactOpts

+ func (_AlphabetVM2 *AlphabetVM2TransactorSession) Step(_stateData []byte, arg1 []byte, _localContext [32]byte) (*types.Transaction, error)

type CrossDomainMessengerCaller

+ func (_CrossDomainMessenger *CrossDomainMessengerCaller) Paused(opts *bind.CallOpts) (bool, error)

type CrossDomainMessengerCallerSession

+ func (_CrossDomainMessenger *CrossDomainMessengerCallerSession) Paused() (bool, error)

type CrossDomainMessengerSession

+ func (_CrossDomainMessenger *CrossDomainMessengerSession) Paused() (bool, error)

type L1CrossDomainMessengerCaller

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCaller) SuperchainConfig(opts *bind.CallOpts) (common.Address, error)

type L1CrossDomainMessengerCallerSession

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) SuperchainConfig() (common.Address, error)

type L1CrossDomainMessengerSession

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) SuperchainConfig() (common.Address, error)

type L1ERC721BridgeCaller

+ func (_L1ERC721Bridge *L1ERC721BridgeCaller) Paused(opts *bind.CallOpts) (bool, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeCaller) SuperchainConfig(opts *bind.CallOpts) (common.Address, error)

type L1ERC721BridgeCallerSession

+ func (_L1ERC721Bridge *L1ERC721BridgeCallerSession) Paused() (bool, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeCallerSession) SuperchainConfig() (common.Address, error)

type L1ERC721BridgeSession

+ func (_L1ERC721Bridge *L1ERC721BridgeSession) Paused() (bool, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeSession) SuperchainConfig() (common.Address, error)

type L1StandardBridgeCaller

+ func (_L1StandardBridge *L1StandardBridgeCaller) Paused(opts *bind.CallOpts) (bool, error)

+ func (_L1StandardBridge *L1StandardBridgeCaller) SuperchainConfig(opts *bind.CallOpts) (common.Address, error)

type L1StandardBridgeCallerSession

+ func (_L1StandardBridge *L1StandardBridgeCallerSession) Paused() (bool, error)

+ func (_L1StandardBridge *L1StandardBridgeCallerSession) SuperchainConfig() (common.Address, error)

type L1StandardBridgeSession

+ func (_L1StandardBridge *L1StandardBridgeSession) Paused() (bool, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) SuperchainConfig() (common.Address, error)

type L2ERC721BridgeCaller

+ func (_L2ERC721Bridge *L2ERC721BridgeCaller) Paused(opts *bind.CallOpts) (bool, error)

type L2ERC721BridgeCallerSession

+ func (_L2ERC721Bridge *L2ERC721BridgeCallerSession) Paused() (bool, error)

type L2ERC721BridgeSession

+ func (_L2ERC721Bridge *L2ERC721BridgeSession) Paused() (bool, error)

type L2StandardBridgeCaller

+ func (_L2StandardBridge *L2StandardBridgeCaller) Paused(opts *bind.CallOpts) (bool, error)

type L2StandardBridgeCallerSession

+ func (_L2StandardBridge *L2StandardBridgeCallerSession) Paused() (bool, error)

type L2StandardBridgeSession

+ func (_L2StandardBridge *L2StandardBridgeSession) Paused() (bool, error)

type OptimismPortalCaller

+ func (_OptimismPortal *OptimismPortalCaller) SuperchainConfig(opts *bind.CallOpts) (common.Address, error)

type OptimismPortalCallerSession

+ func (_OptimismPortal *OptimismPortalCallerSession) SuperchainConfig() (common.Address, error)

type OptimismPortalSession

+ func (_OptimismPortal *OptimismPortalSession) SuperchainConfig() (common.Address, error)

+ type OutputBisectionGame struct

+ func DeployOutputBisectionGame(auth *bind.TransactOpts, backend bind.ContractBackend, _gameType uint8, ...) (common.Address, *types.Transaction, *OutputBisectionGame, error)

+ func NewOutputBisectionGame(address common.Address, backend bind.ContractBackend) (*OutputBisectionGame, error)

+ type OutputBisectionGameCaller struct

+ func NewOutputBisectionGameCaller(address common.Address, caller bind.ContractCaller) (*OutputBisectionGameCaller, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) ABSOLUTEPRESTATE(opts *bind.CallOpts) ([32]byte, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) BondManager(opts *bind.CallOpts) (common.Address, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) ClaimData(opts *bind.CallOpts, arg0 *big.Int) (struct{ ... }, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) ClaimDataLen(opts *bind.CallOpts) (*big.Int, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) CreatedAt(opts *bind.CallOpts) (uint64, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) ExtraData(opts *bind.CallOpts) ([]byte, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) GAMEDURATION(opts *bind.CallOpts) (uint64, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) GENESISBLOCKNUMBER(opts *bind.CallOpts) (*big.Int, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) GENESISOUTPUTROOT(opts *bind.CallOpts) ([32]byte, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) GameData(opts *bind.CallOpts) (struct{ ... }, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) GameType(opts *bind.CallOpts) (uint8, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) L1Head(opts *bind.CallOpts) ([32]byte, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) L2BlockNumber(opts *bind.CallOpts) (*big.Int, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) MAXGAMEDEPTH(opts *bind.CallOpts) (*big.Int, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) ResolvedAt(opts *bind.CallOpts) (uint64, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) RootClaim(opts *bind.CallOpts) ([32]byte, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) SPLITDEPTH(opts *bind.CallOpts) (*big.Int, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) Status(opts *bind.CallOpts) (uint8, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) VM(opts *bind.CallOpts) (common.Address, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) Version(opts *bind.CallOpts) (string, error)

+ type OutputBisectionGameCallerRaw struct

+ Contract *OutputBisectionGameCaller

+ func (_OutputBisectionGame *OutputBisectionGameCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type OutputBisectionGameCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OutputBisectionGameCaller

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) ABSOLUTEPRESTATE() ([32]byte, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) BondManager() (common.Address, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) ClaimData(arg0 *big.Int) (struct{ ... }, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) ClaimDataLen() (*big.Int, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) CreatedAt() (uint64, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) ExtraData() ([]byte, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) GAMEDURATION() (uint64, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) GENESISBLOCKNUMBER() (*big.Int, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) GENESISOUTPUTROOT() ([32]byte, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) GameData() (struct{ ... }, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) GameType() (uint8, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) L1Head() ([32]byte, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) L2BlockNumber() (*big.Int, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) MAXGAMEDEPTH() (*big.Int, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) ResolvedAt() (uint64, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) RootClaim() ([32]byte, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) SPLITDEPTH() (*big.Int, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) Status() (uint8, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) VM() (common.Address, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) Version() (string, error)

+ type OutputBisectionGameFilterer struct

+ func NewOutputBisectionGameFilterer(address common.Address, filterer bind.ContractFilterer) (*OutputBisectionGameFilterer, error)

+ func (_OutputBisectionGame *OutputBisectionGameFilterer) FilterMove(opts *bind.FilterOpts, parentIndex []*big.Int, claim [][32]byte, ...) (*OutputBisectionGameMoveIterator, error)

+ func (_OutputBisectionGame *OutputBisectionGameFilterer) FilterResolved(opts *bind.FilterOpts, status []uint8) (*OutputBisectionGameResolvedIterator, error)

+ func (_OutputBisectionGame *OutputBisectionGameFilterer) ParseMove(log types.Log) (*OutputBisectionGameMove, error)

+ func (_OutputBisectionGame *OutputBisectionGameFilterer) ParseResolved(log types.Log) (*OutputBisectionGameResolved, error)

+ func (_OutputBisectionGame *OutputBisectionGameFilterer) WatchMove(opts *bind.WatchOpts, sink chan<- *OutputBisectionGameMove, ...) (event.Subscription, error)

+ func (_OutputBisectionGame *OutputBisectionGameFilterer) WatchResolved(opts *bind.WatchOpts, sink chan<- *OutputBisectionGameResolved, status []uint8) (event.Subscription, error)

+ type OutputBisectionGameMove struct

+ Claim [32]byte

+ Claimant common.Address

+ ParentIndex *big.Int

+ Raw types.Log

+ type OutputBisectionGameMoveIterator struct

+ Event *OutputBisectionGameMove

+ func (it *OutputBisectionGameMoveIterator) Close() error

+ func (it *OutputBisectionGameMoveIterator) Error() error

+ func (it *OutputBisectionGameMoveIterator) Next() bool

+ type OutputBisectionGameRaw struct

+ Contract *OutputBisectionGame

+ func (_OutputBisectionGame *OutputBisectionGameRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_OutputBisectionGame *OutputBisectionGameRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OutputBisectionGameResolved struct

+ Raw types.Log

+ Status uint8

+ type OutputBisectionGameResolvedIterator struct

+ Event *OutputBisectionGameResolved

+ func (it *OutputBisectionGameResolvedIterator) Close() error

+ func (it *OutputBisectionGameResolvedIterator) Error() error

+ func (it *OutputBisectionGameResolvedIterator) Next() bool

+ type OutputBisectionGameSession struct

+ CallOpts bind.CallOpts

+ Contract *OutputBisectionGame

+ TransactOpts bind.TransactOpts

+ func (_OutputBisectionGame *OutputBisectionGameSession) ABSOLUTEPRESTATE() ([32]byte, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) AddLocalData(_ident *big.Int, _execLeafIdx *big.Int, _partOffset *big.Int) (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) Attack(_parentIndex *big.Int, _claim [32]byte) (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) BondManager() (common.Address, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) ClaimData(arg0 *big.Int) (struct{ ... }, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) ClaimDataLen() (*big.Int, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) CreatedAt() (uint64, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) Defend(_parentIndex *big.Int, _claim [32]byte) (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) ExtraData() ([]byte, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) GAMEDURATION() (uint64, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) GENESISBLOCKNUMBER() (*big.Int, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) GENESISOUTPUTROOT() ([32]byte, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) GameData() (struct{ ... }, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) GameType() (uint8, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) Initialize() (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) L1Head() ([32]byte, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) L2BlockNumber() (*big.Int, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) MAXGAMEDEPTH() (*big.Int, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) Move(_challengeIndex *big.Int, _claim [32]byte, _isAttack bool) (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) Resolve() (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) ResolveClaim(_claimIndex *big.Int) (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) ResolvedAt() (uint64, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) RootClaim() ([32]byte, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) SPLITDEPTH() (*big.Int, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) Status() (uint8, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) Step(_claimIndex *big.Int, _isAttack bool, _stateData []byte, _proof []byte) (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) VM() (common.Address, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) Version() (string, error)

+ type OutputBisectionGameTransactor struct

+ func NewOutputBisectionGameTransactor(address common.Address, transactor bind.ContractTransactor) (*OutputBisectionGameTransactor, error)

+ func (_OutputBisectionGame *OutputBisectionGameTransactor) AddLocalData(opts *bind.TransactOpts, _ident *big.Int, _execLeafIdx *big.Int, ...) (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameTransactor) Attack(opts *bind.TransactOpts, _parentIndex *big.Int, _claim [32]byte) (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameTransactor) Defend(opts *bind.TransactOpts, _parentIndex *big.Int, _claim [32]byte) (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameTransactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameTransactor) Move(opts *bind.TransactOpts, _challengeIndex *big.Int, _claim [32]byte, ...) (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameTransactor) Resolve(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameTransactor) ResolveClaim(opts *bind.TransactOpts, _claimIndex *big.Int) (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameTransactor) Step(opts *bind.TransactOpts, _claimIndex *big.Int, _isAttack bool, ...) (*types.Transaction, error)

+ type OutputBisectionGameTransactorRaw struct

+ Contract *OutputBisectionGameTransactor

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

+ func (_OutputBisectionGame *OutputBisectionGameTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OutputBisectionGameTransactorSession struct

+ Contract *OutputBisectionGameTransactor

+ TransactOpts bind.TransactOpts

+ func (_OutputBisectionGame *OutputBisectionGameTransactorSession) AddLocalData(_ident *big.Int, _execLeafIdx *big.Int, _partOffset *big.Int) (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameTransactorSession) Attack(_parentIndex *big.Int, _claim [32]byte) (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameTransactorSession) Defend(_parentIndex *big.Int, _claim [32]byte) (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameTransactorSession) Initialize() (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameTransactorSession) Move(_challengeIndex *big.Int, _claim [32]byte, _isAttack bool) (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameTransactorSession) Resolve() (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameTransactorSession) ResolveClaim(_claimIndex *big.Int) (*types.Transaction, error)

+ func (_OutputBisectionGame *OutputBisectionGameTransactorSession) Step(_claimIndex *big.Int, _isAttack bool, _stateData []byte, _proof []byte) (*types.Transaction, error)

type StandardBridgeCaller

+ func (_StandardBridge *StandardBridgeCaller) Paused(opts *bind.CallOpts) (bool, error)

type StandardBridgeCallerSession

+ func (_StandardBridge *StandardBridgeCallerSession) Paused() (bool, error)

type StandardBridgeSession

+ func (_StandardBridge *StandardBridgeSession) Paused() (bool, error)

type StorageSetterCaller

+ func (_StorageSetter *StorageSetterCaller) GetBool(opts *bind.CallOpts, _slot [32]byte) (bool, error)

type StorageSetterCallerSession

+ func (_StorageSetter *StorageSetterCallerSession) GetBool(_slot [32]byte) (bool, error)

type StorageSetterSession

+ func (_StorageSetter *StorageSetterSession) GetBool(_slot [32]byte) (bool, error)

+ func (_StorageSetter *StorageSetterSession) SetBool(_slot [32]byte, _value bool) (*types.Transaction, error)

+ func (_StorageSetter *StorageSetterSession) SetBytes320(_slot [32]byte, _value [32]byte) (*types.Transaction, error)

+ type StorageSetterSlot struct

+ Key [32]byte

+ Value [32]byte

type StorageSetterTransactor

+ func (_StorageSetter *StorageSetterTransactor) SetBool(opts *bind.TransactOpts, _slot [32]byte, _value bool) (*types.Transaction, error)

+ func (_StorageSetter *StorageSetterTransactor) SetBytes320(opts *bind.TransactOpts, _slot [32]byte, _value [32]byte) (*types.Transaction, error)

type StorageSetterTransactorSession

+ func (_StorageSetter *StorageSetterTransactorSession) SetBool(_slot [32]byte, _value bool) (*types.Transaction, error)

+ func (_StorageSetter *StorageSetterTransactorSession) SetBytes320(_slot [32]byte, _value [32]byte) (*types.Transaction, error)

+ type SuperchainConfig struct

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

+ func NewSuperchainConfig(address common.Address, backend bind.ContractBackend) (*SuperchainConfig, error)

+ type SuperchainConfigCaller struct

+ func NewSuperchainConfigCaller(address common.Address, caller bind.ContractCaller) (*SuperchainConfigCaller, error)

+ func (_SuperchainConfig *SuperchainConfigCaller) GUARDIANSLOT(opts *bind.CallOpts) ([32]byte, error)

+ func (_SuperchainConfig *SuperchainConfigCaller) Guardian(opts *bind.CallOpts) (common.Address, error)

+ func (_SuperchainConfig *SuperchainConfigCaller) PAUSEDSLOT(opts *bind.CallOpts) ([32]byte, error)

+ func (_SuperchainConfig *SuperchainConfigCaller) Paused(opts *bind.CallOpts) (bool, error)

+ func (_SuperchainConfig *SuperchainConfigCaller) Version(opts *bind.CallOpts) (string, error)

+ type SuperchainConfigCallerRaw struct

+ Contract *SuperchainConfigCaller

+ func (_SuperchainConfig *SuperchainConfigCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type SuperchainConfigCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SuperchainConfigCaller

+ func (_SuperchainConfig *SuperchainConfigCallerSession) GUARDIANSLOT() ([32]byte, error)

+ func (_SuperchainConfig *SuperchainConfigCallerSession) Guardian() (common.Address, error)

+ func (_SuperchainConfig *SuperchainConfigCallerSession) PAUSEDSLOT() ([32]byte, error)

+ func (_SuperchainConfig *SuperchainConfigCallerSession) Paused() (bool, error)

+ func (_SuperchainConfig *SuperchainConfigCallerSession) Version() (string, error)

+ type SuperchainConfigConfigUpdate struct

+ Data []byte

+ Raw types.Log

+ UpdateType uint8

+ type SuperchainConfigConfigUpdateIterator struct

+ Event *SuperchainConfigConfigUpdate

+ func (it *SuperchainConfigConfigUpdateIterator) Close() error

+ func (it *SuperchainConfigConfigUpdateIterator) Error() error

+ func (it *SuperchainConfigConfigUpdateIterator) Next() bool

+ type SuperchainConfigFilterer struct

+ func NewSuperchainConfigFilterer(address common.Address, filterer bind.ContractFilterer) (*SuperchainConfigFilterer, error)

+ func (_SuperchainConfig *SuperchainConfigFilterer) FilterConfigUpdate(opts *bind.FilterOpts, updateType []uint8) (*SuperchainConfigConfigUpdateIterator, error)

+ func (_SuperchainConfig *SuperchainConfigFilterer) FilterInitialized(opts *bind.FilterOpts) (*SuperchainConfigInitializedIterator, error)

+ func (_SuperchainConfig *SuperchainConfigFilterer) FilterPaused(opts *bind.FilterOpts) (*SuperchainConfigPausedIterator, error)

+ func (_SuperchainConfig *SuperchainConfigFilterer) FilterUnpaused(opts *bind.FilterOpts) (*SuperchainConfigUnpausedIterator, error)

+ func (_SuperchainConfig *SuperchainConfigFilterer) ParseConfigUpdate(log types.Log) (*SuperchainConfigConfigUpdate, error)

+ func (_SuperchainConfig *SuperchainConfigFilterer) ParseInitialized(log types.Log) (*SuperchainConfigInitialized, error)

+ func (_SuperchainConfig *SuperchainConfigFilterer) ParsePaused(log types.Log) (*SuperchainConfigPaused, error)

+ func (_SuperchainConfig *SuperchainConfigFilterer) ParseUnpaused(log types.Log) (*SuperchainConfigUnpaused, error)

+ func (_SuperchainConfig *SuperchainConfigFilterer) WatchConfigUpdate(opts *bind.WatchOpts, sink chan<- *SuperchainConfigConfigUpdate, ...) (event.Subscription, error)

+ func (_SuperchainConfig *SuperchainConfigFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *SuperchainConfigInitialized) (event.Subscription, error)

+ func (_SuperchainConfig *SuperchainConfigFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *SuperchainConfigPaused) (event.Subscription, error)

+ func (_SuperchainConfig *SuperchainConfigFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *SuperchainConfigUnpaused) (event.Subscription, error)

+ type SuperchainConfigInitialized struct

+ Raw types.Log

+ Version uint8

+ type SuperchainConfigInitializedIterator struct

+ Event *SuperchainConfigInitialized

+ func (it *SuperchainConfigInitializedIterator) Close() error

+ func (it *SuperchainConfigInitializedIterator) Error() error

+ func (it *SuperchainConfigInitializedIterator) Next() bool

+ type SuperchainConfigPaused struct

+ Identifier string

+ Raw types.Log

+ type SuperchainConfigPausedIterator struct

+ Event *SuperchainConfigPaused

+ func (it *SuperchainConfigPausedIterator) Close() error

+ func (it *SuperchainConfigPausedIterator) Error() error

+ func (it *SuperchainConfigPausedIterator) Next() bool

+ type SuperchainConfigRaw struct

+ Contract *SuperchainConfig

+ func (_SuperchainConfig *SuperchainConfigRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_SuperchainConfig *SuperchainConfigRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SuperchainConfigSession struct

+ CallOpts bind.CallOpts

+ Contract *SuperchainConfig

+ TransactOpts bind.TransactOpts

+ func (_SuperchainConfig *SuperchainConfigSession) GUARDIANSLOT() ([32]byte, error)

+ func (_SuperchainConfig *SuperchainConfigSession) Guardian() (common.Address, error)

+ func (_SuperchainConfig *SuperchainConfigSession) Initialize(_guardian common.Address) (*types.Transaction, error)

+ func (_SuperchainConfig *SuperchainConfigSession) PAUSEDSLOT() ([32]byte, error)

+ func (_SuperchainConfig *SuperchainConfigSession) Pause(_identifier string) (*types.Transaction, error)

+ func (_SuperchainConfig *SuperchainConfigSession) Paused() (bool, error)

+ func (_SuperchainConfig *SuperchainConfigSession) Unpause() (*types.Transaction, error)

+ func (_SuperchainConfig *SuperchainConfigSession) Version() (string, error)

+ type SuperchainConfigTransactor struct

+ func NewSuperchainConfigTransactor(address common.Address, transactor bind.ContractTransactor) (*SuperchainConfigTransactor, error)

+ func (_SuperchainConfig *SuperchainConfigTransactor) Initialize(opts *bind.TransactOpts, _guardian common.Address) (*types.Transaction, error)

+ func (_SuperchainConfig *SuperchainConfigTransactor) Pause(opts *bind.TransactOpts, _identifier string) (*types.Transaction, error)

+ func (_SuperchainConfig *SuperchainConfigTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SuperchainConfigTransactorRaw struct

+ Contract *SuperchainConfigTransactor

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

+ func (_SuperchainConfig *SuperchainConfigTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SuperchainConfigTransactorSession struct

+ Contract *SuperchainConfigTransactor

+ TransactOpts bind.TransactOpts

+ func (_SuperchainConfig *SuperchainConfigTransactorSession) Initialize(_guardian common.Address) (*types.Transaction, error)

+ func (_SuperchainConfig *SuperchainConfigTransactorSession) Pause(_identifier string) (*types.Transaction, error)

+ func (_SuperchainConfig *SuperchainConfigTransactorSession) Unpause() (*types.Transaction, error)

+ type SuperchainConfigUnpaused struct

+ Raw types.Log

+ type SuperchainConfigUnpausedIterator struct

+ Event *SuperchainConfigUnpaused

+ func (it *SuperchainConfigUnpausedIterator) Close() error

+ func (it *SuperchainConfigUnpausedIterator) Error() error

+ func (it *SuperchainConfigUnpausedIterator) Next() bool

v1.3.0-rc.1

Feb 13, 2024

v1.2.1

Feb 16, 2024

v1.2.0

Feb 13, 2024

Changes in this version

+ const AddressManagerStorageLayoutJSON

+ const AlphabetVMStorageLayoutJSON

+ const BaseFeeVaultStorageLayoutJSON

+ const BlockOracleStorageLayoutJSON

+ const CrossDomainMessengerStorageLayoutJSON

+ const DelayedVetoableStorageLayoutJSON

+ const DeployerWhitelistStorageLayoutJSON

+ const DisputeGameFactoryStorageLayoutJSON

+ const EASStorageLayoutJSON

+ const ERC20StorageLayoutJSON

+ const FaultDisputeGameStorageLayoutJSON

+ const GasPriceOracleStorageLayoutJSON

+ const GovernanceTokenStorageLayoutJSON

+ const ISemverStorageLayoutJSON

+ const L1BlockNumberStorageLayoutJSON

+ const LegacyERC20ETHStorageLayoutJSON

+ const LegacyMessagePasserStorageLayoutJSON

+ const MIPSStorageLayoutJSON

+ const OptimismMintableERC20FactoryStorageLayoutJSON

+ const OptimismMintableERC20StorageLayoutJSON

+ const OptimismMintableERC721FactoryStorageLayoutJSON

+ const OptimismPortalStorageLayoutJSON

+ const PreimageOracleStorageLayoutJSON

+ const ProtocolVersionsStorageLayoutJSON

+ const SafeProxyFactoryStorageLayoutJSON

+ const SafeStorageLayoutJSON

+ const SchemaRegistryStorageLayoutJSON

+ const SequencerFeeVaultStorageLayoutJSON

+ const StandardBridgeStorageLayoutJSON

+ const StorageSetterStorageLayoutJSON

+ var AddressManagerABI = AddressManagerMetaData.ABI

+ var AddressManagerBin = AddressManagerMetaData.Bin

+ var AddressManagerMetaData = &bind.MetaData

+ var AddressManagerStorageLayout = new(solc.StorageLayout)

+ var AlphabetVMABI = AlphabetVMMetaData.ABI

+ var AlphabetVMBin = AlphabetVMMetaData.Bin

+ var AlphabetVMMetaData = &bind.MetaData

+ var AlphabetVMStorageLayout = new(solc.StorageLayout)

+ var BaseFeeVaultABI = BaseFeeVaultMetaData.ABI

+ var BaseFeeVaultBin = BaseFeeVaultMetaData.Bin

+ var BaseFeeVaultMetaData = &bind.MetaData

+ var BaseFeeVaultStorageLayout = new(solc.StorageLayout)

+ var BlockOracleABI = BlockOracleMetaData.ABI

+ var BlockOracleBin = BlockOracleMetaData.Bin

+ var BlockOracleDeployedBin = "0x608060405234801561001057600080fd5b50600436106100415760003560e01c806354fd4d501461004657806399d548aa14610098578063c2c4c5c1146100d0575b600080fd5b6100826040518060400160405280600581526020017f302e302e3100000000000000000000000000000000000000000000000000000081525081565b60405161008f9190610210565b60405180910390f35b6100ab6100a6366004610283565b6100e6565b604080518251815260209283015167ffffffffffffffff16928101929092520161008f565b6100d8610165565b60405190815260200161008f565b604080518082018252600080825260209182018190528381528082528281208351808501909452805480855260019091015467ffffffffffffffff169284019290925203610160576040517f37cf270500000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b919050565b600061017260014361029c565b60408051808201825282408082524267ffffffffffffffff81811660208086018281526000898152918290528782209651875551600190960180547fffffffffffffffffffffffffffffffffffffffffffffffff000000000000000016969093169590951790915593519495509093909291849186917fb67ff58b33060fd371a35ae2d9f1c3cdaec9b8197969f6efe2594a1ff4ba68c691a4505090565b600060208083528351808285015260005b8181101561023d57858101830151858201604001528201610221565b8181111561024f576000604083870101525b50601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016929092016040019392505050565b60006020828403121561029557600080fd5b5035919050565b6000828210156102d5577f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b50039056fea164736f6c634300080f000a"

+ var BlockOracleMetaData = &bind.MetaData

+ var BlockOracleStorageLayout = new(solc.StorageLayout)

+ var CrossDomainMessengerABI = CrossDomainMessengerMetaData.ABI

+ var CrossDomainMessengerDeployedBin = "0x"

+ var CrossDomainMessengerMetaData = &bind.MetaData

+ var CrossDomainMessengerStorageLayout = new(solc.StorageLayout)

+ var DelayedVetoableABI = DelayedVetoableMetaData.ABI

+ var DelayedVetoableBin = DelayedVetoableMetaData.Bin

+ var DelayedVetoableMetaData = &bind.MetaData

+ var DelayedVetoableStorageLayout = new(solc.StorageLayout)

+ var DeployerWhitelistABI = DeployerWhitelistMetaData.ABI

+ var DeployerWhitelistBin = DeployerWhitelistMetaData.Bin

+ var DeployerWhitelistMetaData = &bind.MetaData

+ var DeployerWhitelistStorageLayout = new(solc.StorageLayout)

+ var DisputeGameFactoryABI = DisputeGameFactoryMetaData.ABI

+ var DisputeGameFactoryBin = DisputeGameFactoryMetaData.Bin

+ var DisputeGameFactoryMetaData = &bind.MetaData

+ var DisputeGameFactoryStorageLayout = new(solc.StorageLayout)

+ var EASABI = EASMetaData.ABI

+ var EASBin = EASMetaData.Bin

+ var EASMetaData = &bind.MetaData

+ var EASStorageLayout = new(solc.StorageLayout)

+ var ERC20StorageLayout = new(solc.StorageLayout)

+ var FaultDisputeGameABI = FaultDisputeGameMetaData.ABI

+ var FaultDisputeGameBin = FaultDisputeGameMetaData.Bin

+ var FaultDisputeGameMetaData = &bind.MetaData

+ var FaultDisputeGameStorageLayout = new(solc.StorageLayout)

+ var GasPriceOracleStorageLayout = new(solc.StorageLayout)

+ var GovernanceTokenABI = GovernanceTokenMetaData.ABI

+ var GovernanceTokenBin = GovernanceTokenMetaData.Bin

+ var GovernanceTokenMetaData = &bind.MetaData

+ var GovernanceTokenStorageLayout = new(solc.StorageLayout)

+ var ISemverABI = ISemverMetaData.ABI

+ var ISemverDeployedBin = "0x"

+ var ISemverMetaData = &bind.MetaData

+ var ISemverStorageLayout = new(solc.StorageLayout)

+ var L1BlockNumberABI = L1BlockNumberMetaData.ABI

+ var L1BlockNumberBin = L1BlockNumberMetaData.Bin

+ var L1BlockNumberDeployedBin = "0x60806040526004361061002d5760003560e01c806354fd4d5014610052578063b9b3efe9146100b157610048565b3661004857600061003c6100d4565b90508060005260206000f35b600061003c6100d4565b34801561005e57600080fd5b5061009b6040518060400160405280600581526020017f312e312e3000000000000000000000000000000000000000000000000000000081525081565b6040516100a89190610168565b60405180910390f35b3480156100bd57600080fd5b506100c66100d4565b6040519081526020016100a8565b600073420000000000000000000000000000000000001573ffffffffffffffffffffffffffffffffffffffff16638381f58a6040518163ffffffff1660e01b8152600401602060405180830381865afa158015610135573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061015991906101db565b67ffffffffffffffff16905090565b600060208083528351808285015260005b8181101561019557858101830151858201604001528201610179565b818111156101a7576000604083870101525b50601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016929092016040019392505050565b6000602082840312156101ed57600080fd5b815167ffffffffffffffff8116811461020557600080fd5b939250505056fea164736f6c634300080f000a"

+ var L1BlockNumberMetaData = &bind.MetaData

+ var L1BlockNumberStorageLayout = new(solc.StorageLayout)

+ var LegacyERC20ETHABI = LegacyERC20ETHMetaData.ABI

+ var LegacyERC20ETHBin = LegacyERC20ETHMetaData.Bin

+ var LegacyERC20ETHMetaData = &bind.MetaData

+ var LegacyERC20ETHStorageLayout = new(solc.StorageLayout)

+ var LegacyMessagePasserABI = LegacyMessagePasserMetaData.ABI

+ var LegacyMessagePasserBin = LegacyMessagePasserMetaData.Bin

+ var LegacyMessagePasserMetaData = &bind.MetaData

+ var LegacyMessagePasserStorageLayout = new(solc.StorageLayout)

+ var MIPSABI = MIPSMetaData.ABI

+ var MIPSBin = MIPSMetaData.Bin

+ var MIPSMetaData = &bind.MetaData

+ var MIPSStorageLayout = new(solc.StorageLayout)

+ var OptimismMintableERC20ABI = OptimismMintableERC20MetaData.ABI

+ var OptimismMintableERC20Bin = OptimismMintableERC20MetaData.Bin

+ var OptimismMintableERC20FactoryABI = OptimismMintableERC20FactoryMetaData.ABI

+ var OptimismMintableERC20FactoryBin = OptimismMintableERC20FactoryMetaData.Bin

+ var OptimismMintableERC20FactoryMetaData = &bind.MetaData

+ var OptimismMintableERC20FactoryStorageLayout = new(solc.StorageLayout)

+ var OptimismMintableERC20MetaData = &bind.MetaData

+ var OptimismMintableERC20StorageLayout = new(solc.StorageLayout)

+ var OptimismMintableERC721FactoryABI = OptimismMintableERC721FactoryMetaData.ABI

+ var OptimismMintableERC721FactoryBin = OptimismMintableERC721FactoryMetaData.Bin

+ var OptimismMintableERC721FactoryMetaData = &bind.MetaData

+ var OptimismMintableERC721FactoryStorageLayout = new(solc.StorageLayout)

+ var OptimismPortalABI = OptimismPortalMetaData.ABI

+ var OptimismPortalBin = OptimismPortalMetaData.Bin

+ var OptimismPortalMetaData = &bind.MetaData

+ var OptimismPortalStorageLayout = new(solc.StorageLayout)

+ var PreimageOracleABI = PreimageOracleMetaData.ABI

+ var PreimageOracleBin = PreimageOracleMetaData.Bin

+ var PreimageOracleDeployedSourceMap = "306:3911:137:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;537:68;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;413:25:299;;;401:2;386:18;537:68:137;;;;;;;;680:66;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;614:14:299;;607:22;589:41;;577:2;562:18;680:66:137;449:187:299;1367:1211:137;;;;;;:::i;:::-;;:::i;789:536::-;;;;;;:::i;:::-;;:::i;:::-;;;;1274:25:299;;;1330:2;1315:18;;1308:34;;;;1247:18;789:536:137;1100:248:299;2620:1595:137;;;;;;:::i;:::-;;:::i;:::-;;419:50;;;;;;:::i;:::-;;;;;;;;;;;;;;;1367:1211;1560:12;1665:51;1694:6;1702:13;1665:28;:51::i;:::-;1658:58;-1:-1:-1;1810:9:137;:5;1818:1;1810:9;:::i;:::-;1796:11;:23;:37;;;;1831:2;1823:5;:10;1796:37;1792:90;;;1856:15;;;;;;;;;;;;;;1792:90;1951:12;2051:4;2044:18;;;2152:3;2148:15;;;2135:29;;2184:4;2177:19;;;;2286:18;;2376:20;;;:14;:20;;;;;;:33;;;;;;;;:40;;;;2412:4;2376:40;;;;;;2426:19;;;;;;;;:32;;;;;;;;;:39;2542:21;;;;;;;;;:29;2391:4;1367:1211;-1:-1:-1;;1367:1211:137:o;789:536::-;865:12;914:20;;;:14;:20;;;;;;;;:29;;;;;;;;;865:12;;914:29;;906:62;;;;;;;2908:2:299;906:62:137;;;2890:21:299;2947:2;2927:18;;;2920:30;2986:22;2966:18;;;2959:50;3026:18;;906:62:137;;;;;;;;-1:-1:-1;1099:14:137;1116:21;;;1087:2;1116:21;;;;;;;;1167:10;1116:21;1176:1;1167:10;:::i;:::-;1151:12;:7;1161:2;1151:12;:::i;:::-;:26;1147:87;;1216:7;1203:10;:6;1212:1;1203:10;:::i;:::-;:20;;;;:::i;:::-;1193:30;;1147:87;-1:-1:-1;1290:19:137;;;;:13;:19;;;;;;;;:28;;;;;;;;;;;;789:536;;-1:-1:-1;789:536:137:o;2620:1595::-;2916:4;2903:18;2721:12;;3045:1;3035:12;;3019:29;;3016:210;;;3120:10;3117:1;3110:21;3210:1;3204:4;3197:15;3016:210;3469:3;3465:14;;;3369:4;3453:27;3500:11;3474:4;3619:16;3500:11;3601:41;3832:29;;;3836:11;3832:29;3826:36;3884:20;;;;4031:19;4024:27;4053:11;4021:44;4084:19;;;;4062:1;4084:19;;;;;;;;:32;;;;;;;;:39;;;;4119:4;4084:39;;;;;;4133:18;;;;;;;;:31;;;;;;;;;:38;;;;4181:20;;;;;;;;;;;:27;;;;-1:-1:-1;;;;2620:1595:137:o;552:449:136:-;835:11;860:19;848:32;;832:49;965:29;832:49;980:13;1676:4;1670:11;;1533:21;1787:15;;;1828:8;1822:4;1815:22;1850:27;;;1996:4;1983:18;;;2098:17;;2003:19;1979:44;2025:11;1976:61;;1455:676;965:29;958:36;552:449;-1:-1:-1;;;552:449:136:o;14:248:299:-;82:6;90;143:2;131:9;122:7;118:23;114:32;111:52;;;159:1;156;149:12;111:52;-1:-1:-1;;182:23:299;;;252:2;237:18;;;224:32;;-1:-1:-1;14:248:299:o;641:454::-;736:6;744;752;760;768;821:3;809:9;800:7;796:23;792:33;789:53;;;838:1;835;828:12;789:53;-1:-1:-1;;861:23:299;;;931:2;916:18;;903:32;;-1:-1:-1;982:2:299;967:18;;954:32;;1033:2;1018:18;;1005:32;;-1:-1:-1;1084:3:299;1069:19;1056:33;;-1:-1:-1;641:454:299;-1:-1:-1;641:454:299:o;1353:659::-;1432:6;1440;1448;1501:2;1489:9;1480:7;1476:23;1472:32;1469:52;;;1517:1;1514;1507:12;1469:52;1553:9;1540:23;1530:33;;1614:2;1603:9;1599:18;1586:32;1637:18;1678:2;1670:6;1667:14;1664:34;;;1694:1;1691;1684:12;1664:34;1732:6;1721:9;1717:22;1707:32;;1777:7;1770:4;1766:2;1762:13;1758:27;1748:55;;1799:1;1796;1789:12;1748:55;1839:2;1826:16;1865:2;1857:6;1854:14;1851:34;;;1881:1;1878;1871:12;1851:34;1926:7;1921:2;1912:6;1908:2;1904:15;1900:24;1897:37;1894:57;;;1947:1;1944;1937:12;1894:57;1978:2;1974;1970:11;1960:21;;2000:6;1990:16;;;;;1353:659;;;;;:::o;2017:180::-;2076:6;2129:2;2117:9;2108:7;2104:23;2100:32;2097:52;;;2145:1;2142;2135:12;2097:52;-1:-1:-1;2168:23:299;;2017:180;-1:-1:-1;2017:180:299:o;2384:184::-;2436:77;2433:1;2426:88;2533:4;2530:1;2523:15;2557:4;2554:1;2547:15;2573:128;2613:3;2644:1;2640:6;2637:1;2634:13;2631:39;;;2650:18;;:::i;:::-;-1:-1:-1;2686:9:299;;2573:128::o;3055:125::-;3095:4;3123:1;3120;3117:8;3114:34;;;3128:18;;:::i;:::-;-1:-1:-1;3165:9:299;;3055:125::o"

+ var PreimageOracleMetaData = &bind.MetaData

+ var PreimageOracleStorageLayout = new(solc.StorageLayout)

+ var ProtocolVersionsABI = ProtocolVersionsMetaData.ABI

+ var ProtocolVersionsBin = ProtocolVersionsMetaData.Bin

+ var ProtocolVersionsMetaData = &bind.MetaData

+ var ProtocolVersionsStorageLayout = new(solc.StorageLayout)

+ var SafeABI = SafeMetaData.ABI

+ var SafeBin = SafeMetaData.Bin

+ var SafeMetaData = &bind.MetaData

+ var SafeProxyFactoryABI = SafeProxyFactoryMetaData.ABI

+ var SafeProxyFactoryBin = SafeProxyFactoryMetaData.Bin

+ var SafeProxyFactoryMetaData = &bind.MetaData

+ var SafeProxyFactoryStorageLayout = new(solc.StorageLayout)

+ var SafeStorageLayout = new(solc.StorageLayout)

+ var SchemaRegistryABI = SchemaRegistryMetaData.ABI

+ var SchemaRegistryBin = SchemaRegistryMetaData.Bin

+ var SchemaRegistryMetaData = &bind.MetaData

+ var SchemaRegistryStorageLayout = new(solc.StorageLayout)

+ var SequencerFeeVaultABI = SequencerFeeVaultMetaData.ABI

+ var SequencerFeeVaultBin = SequencerFeeVaultMetaData.Bin

+ var SequencerFeeVaultMetaData = &bind.MetaData

+ var SequencerFeeVaultStorageLayout = new(solc.StorageLayout)

+ var StandardBridgeABI = StandardBridgeMetaData.ABI

+ var StandardBridgeDeployedBin = "0x"

+ var StandardBridgeMetaData = &bind.MetaData

+ var StandardBridgeStorageLayout = new(solc.StorageLayout)

+ var StorageSetterABI = StorageSetterMetaData.ABI

+ var StorageSetterBin = StorageSetterMetaData.Bin

+ var StorageSetterDeployedBin = "0x608060405234801561001057600080fd5b506004361061007d5760003560e01c8063a6ed563e1161005b578063a6ed563e1461011c578063bd02d0f51461011c578063ca446dd914610138578063e2a4853a146100bf57600080fd5b806321f8a721146100825780634e91db08146100bf57806354fd4d50146100d3575b600080fd5b610095610090366004610156565b610146565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020015b60405180910390f35b6100d16100cd36600461016f565b9055565b005b61010f6040518060400160405280600581526020017f312e302e3000000000000000000000000000000000000000000000000000000081525081565b6040516100b69190610191565b61012a610090366004610156565b6040519081526020016100b6565b6100d16100cd366004610204565b6000610150825490565b92915050565b60006020828403121561016857600080fd5b5035919050565b6000806040838503121561018257600080fd5b50508035926020909101359150565b600060208083528351808285015260005b818110156101be578581018301518582016040015282016101a2565b818111156101d0576000604083870101525b50601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016929092016040019392505050565b6000806040838503121561021757600080fd5b82359150602083013573ffffffffffffffffffffffffffffffffffffffff8116811461024257600080fd5b80915050925092905056fea164736f6c634300080f000a"

+ var StorageSetterMetaData = &bind.MetaData

+ var StorageSetterStorageLayout = new(solc.StorageLayout)

+ type AddressManager struct

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

+ func NewAddressManager(address common.Address, backend bind.ContractBackend) (*AddressManager, error)

+ type AddressManagerAddressSet struct

+ Name common.Hash

+ NewAddress common.Address

+ OldAddress common.Address

+ Raw types.Log

+ type AddressManagerAddressSetIterator struct

+ Event *AddressManagerAddressSet

+ func (it *AddressManagerAddressSetIterator) Close() error

+ func (it *AddressManagerAddressSetIterator) Error() error

+ func (it *AddressManagerAddressSetIterator) Next() bool

+ type AddressManagerCaller struct

+ func NewAddressManagerCaller(address common.Address, caller bind.ContractCaller) (*AddressManagerCaller, error)

+ func (_AddressManager *AddressManagerCaller) GetAddress(opts *bind.CallOpts, _name string) (common.Address, error)

+ func (_AddressManager *AddressManagerCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ type AddressManagerCallerRaw struct

+ Contract *AddressManagerCaller

+ func (_AddressManager *AddressManagerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type AddressManagerCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *AddressManagerCaller

+ func (_AddressManager *AddressManagerCallerSession) GetAddress(_name string) (common.Address, error)

+ func (_AddressManager *AddressManagerCallerSession) Owner() (common.Address, error)

+ type AddressManagerFilterer struct

+ func NewAddressManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*AddressManagerFilterer, error)

+ func (_AddressManager *AddressManagerFilterer) FilterAddressSet(opts *bind.FilterOpts, name []string) (*AddressManagerAddressSetIterator, error)

+ func (_AddressManager *AddressManagerFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*AddressManagerOwnershipTransferredIterator, error)

+ func (_AddressManager *AddressManagerFilterer) ParseAddressSet(log types.Log) (*AddressManagerAddressSet, error)

+ func (_AddressManager *AddressManagerFilterer) ParseOwnershipTransferred(log types.Log) (*AddressManagerOwnershipTransferred, error)

+ func (_AddressManager *AddressManagerFilterer) WatchAddressSet(opts *bind.WatchOpts, sink chan<- *AddressManagerAddressSet, name []string) (event.Subscription, error)

+ func (_AddressManager *AddressManagerFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *AddressManagerOwnershipTransferred, ...) (event.Subscription, error)

+ type AddressManagerOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type AddressManagerOwnershipTransferredIterator struct

+ Event *AddressManagerOwnershipTransferred

+ func (it *AddressManagerOwnershipTransferredIterator) Close() error

+ func (it *AddressManagerOwnershipTransferredIterator) Error() error

+ func (it *AddressManagerOwnershipTransferredIterator) Next() bool

+ type AddressManagerRaw struct

+ Contract *AddressManager

+ func (_AddressManager *AddressManagerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_AddressManager *AddressManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AddressManagerSession struct

+ CallOpts bind.CallOpts

+ Contract *AddressManager

+ TransactOpts bind.TransactOpts

+ func (_AddressManager *AddressManagerSession) GetAddress(_name string) (common.Address, error)

+ func (_AddressManager *AddressManagerSession) Owner() (common.Address, error)

+ func (_AddressManager *AddressManagerSession) RenounceOwnership() (*types.Transaction, error)

+ func (_AddressManager *AddressManagerSession) SetAddress(_name string, _address common.Address) (*types.Transaction, error)

+ func (_AddressManager *AddressManagerSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type AddressManagerTransactor struct

+ func NewAddressManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*AddressManagerTransactor, error)

+ func (_AddressManager *AddressManagerTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_AddressManager *AddressManagerTransactor) SetAddress(opts *bind.TransactOpts, _name string, _address common.Address) (*types.Transaction, error)

+ func (_AddressManager *AddressManagerTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type AddressManagerTransactorRaw struct

+ Contract *AddressManagerTransactor

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

+ func (_AddressManager *AddressManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AddressManagerTransactorSession struct

+ Contract *AddressManagerTransactor

+ TransactOpts bind.TransactOpts

+ func (_AddressManager *AddressManagerTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_AddressManager *AddressManagerTransactorSession) SetAddress(_name string, _address common.Address) (*types.Transaction, error)

+ func (_AddressManager *AddressManagerTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type AlphabetVM struct

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

+ func NewAlphabetVM(address common.Address, backend bind.ContractBackend) (*AlphabetVM, error)

+ type AlphabetVMCaller struct

+ func NewAlphabetVMCaller(address common.Address, caller bind.ContractCaller) (*AlphabetVMCaller, error)

+ func (_AlphabetVM *AlphabetVMCaller) Oracle(opts *bind.CallOpts) (common.Address, error)

+ func (_AlphabetVM *AlphabetVMCaller) Step(opts *bind.CallOpts, _stateData []byte, arg1 []byte, arg2 *big.Int) ([32]byte, error)

+ type AlphabetVMCallerRaw struct

+ Contract *AlphabetVMCaller

+ func (_AlphabetVM *AlphabetVMCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type AlphabetVMCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *AlphabetVMCaller

+ func (_AlphabetVM *AlphabetVMCallerSession) Oracle() (common.Address, error)

+ func (_AlphabetVM *AlphabetVMCallerSession) Step(_stateData []byte, arg1 []byte, arg2 *big.Int) ([32]byte, error)

+ type AlphabetVMFilterer struct

+ func NewAlphabetVMFilterer(address common.Address, filterer bind.ContractFilterer) (*AlphabetVMFilterer, error)

+ type AlphabetVMRaw struct

+ Contract *AlphabetVM

+ func (_AlphabetVM *AlphabetVMRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_AlphabetVM *AlphabetVMRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AlphabetVMSession struct

+ CallOpts bind.CallOpts

+ Contract *AlphabetVM

+ TransactOpts bind.TransactOpts

+ func (_AlphabetVM *AlphabetVMSession) Oracle() (common.Address, error)

+ func (_AlphabetVM *AlphabetVMSession) Step(_stateData []byte, arg1 []byte, arg2 *big.Int) ([32]byte, error)

+ type AlphabetVMTransactor struct

+ func NewAlphabetVMTransactor(address common.Address, transactor bind.ContractTransactor) (*AlphabetVMTransactor, error)

+ type AlphabetVMTransactorRaw struct

+ Contract *AlphabetVMTransactor

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

+ func (_AlphabetVM *AlphabetVMTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AlphabetVMTransactorSession struct

+ Contract *AlphabetVMTransactor

+ TransactOpts bind.TransactOpts

+ type Attestation struct

+ Attester common.Address

+ Data []byte

+ ExpirationTime uint64

+ Recipient common.Address

+ RefUID [32]byte

+ Revocable bool

+ RevocationTime uint64

+ Schema [32]byte

+ Time uint64

+ Uid [32]byte

+ type AttestationRequest struct

+ Data AttestationRequestData

+ Schema [32]byte

+ type AttestationRequestData struct

+ Data []byte

+ ExpirationTime uint64

+ Recipient common.Address

+ RefUID [32]byte

+ Revocable bool

+ Value *big.Int

+ type BaseFeeVault struct

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

+ func NewBaseFeeVault(address common.Address, backend bind.ContractBackend) (*BaseFeeVault, error)

+ type BaseFeeVaultCaller struct

+ func NewBaseFeeVaultCaller(address common.Address, caller bind.ContractCaller) (*BaseFeeVaultCaller, error)

+ func (_BaseFeeVault *BaseFeeVaultCaller) MINWITHDRAWALAMOUNT(opts *bind.CallOpts) (*big.Int, error)

+ func (_BaseFeeVault *BaseFeeVaultCaller) RECIPIENT(opts *bind.CallOpts) (common.Address, error)

+ func (_BaseFeeVault *BaseFeeVaultCaller) TotalProcessed(opts *bind.CallOpts) (*big.Int, error)

+ func (_BaseFeeVault *BaseFeeVaultCaller) Version(opts *bind.CallOpts) (string, error)

+ func (_BaseFeeVault *BaseFeeVaultCaller) WITHDRAWALNETWORK(opts *bind.CallOpts) (uint8, error)

+ type BaseFeeVaultCallerRaw struct

+ Contract *BaseFeeVaultCaller

+ func (_BaseFeeVault *BaseFeeVaultCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type BaseFeeVaultCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *BaseFeeVaultCaller

+ func (_BaseFeeVault *BaseFeeVaultCallerSession) MINWITHDRAWALAMOUNT() (*big.Int, error)

+ func (_BaseFeeVault *BaseFeeVaultCallerSession) RECIPIENT() (common.Address, error)

+ func (_BaseFeeVault *BaseFeeVaultCallerSession) TotalProcessed() (*big.Int, error)

+ func (_BaseFeeVault *BaseFeeVaultCallerSession) Version() (string, error)

+ func (_BaseFeeVault *BaseFeeVaultCallerSession) WITHDRAWALNETWORK() (uint8, error)

+ type BaseFeeVaultFilterer struct

+ func NewBaseFeeVaultFilterer(address common.Address, filterer bind.ContractFilterer) (*BaseFeeVaultFilterer, error)

+ func (_BaseFeeVault *BaseFeeVaultFilterer) FilterWithdrawal(opts *bind.FilterOpts) (*BaseFeeVaultWithdrawalIterator, error)

+ func (_BaseFeeVault *BaseFeeVaultFilterer) FilterWithdrawal0(opts *bind.FilterOpts) (*BaseFeeVaultWithdrawal0Iterator, error)

+ func (_BaseFeeVault *BaseFeeVaultFilterer) ParseWithdrawal(log types.Log) (*BaseFeeVaultWithdrawal, error)

+ func (_BaseFeeVault *BaseFeeVaultFilterer) ParseWithdrawal0(log types.Log) (*BaseFeeVaultWithdrawal0, error)

+ func (_BaseFeeVault *BaseFeeVaultFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *BaseFeeVaultWithdrawal) (event.Subscription, error)

+ func (_BaseFeeVault *BaseFeeVaultFilterer) WatchWithdrawal0(opts *bind.WatchOpts, sink chan<- *BaseFeeVaultWithdrawal0) (event.Subscription, error)

+ type BaseFeeVaultRaw struct

+ Contract *BaseFeeVault

+ func (_BaseFeeVault *BaseFeeVaultRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_BaseFeeVault *BaseFeeVaultRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BaseFeeVaultSession struct

+ CallOpts bind.CallOpts

+ Contract *BaseFeeVault

+ TransactOpts bind.TransactOpts

+ func (_BaseFeeVault *BaseFeeVaultSession) MINWITHDRAWALAMOUNT() (*big.Int, error)

+ func (_BaseFeeVault *BaseFeeVaultSession) RECIPIENT() (common.Address, error)

+ func (_BaseFeeVault *BaseFeeVaultSession) Receive() (*types.Transaction, error)

+ func (_BaseFeeVault *BaseFeeVaultSession) TotalProcessed() (*big.Int, error)

+ func (_BaseFeeVault *BaseFeeVaultSession) Version() (string, error)

+ func (_BaseFeeVault *BaseFeeVaultSession) WITHDRAWALNETWORK() (uint8, error)

+ func (_BaseFeeVault *BaseFeeVaultSession) Withdraw() (*types.Transaction, error)

+ type BaseFeeVaultTransactor struct

+ func NewBaseFeeVaultTransactor(address common.Address, transactor bind.ContractTransactor) (*BaseFeeVaultTransactor, error)

+ func (_BaseFeeVault *BaseFeeVaultTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_BaseFeeVault *BaseFeeVaultTransactor) Withdraw(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BaseFeeVaultTransactorRaw struct

+ Contract *BaseFeeVaultTransactor

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

+ func (_BaseFeeVault *BaseFeeVaultTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BaseFeeVaultTransactorSession struct

+ Contract *BaseFeeVaultTransactor

+ TransactOpts bind.TransactOpts

+ func (_BaseFeeVault *BaseFeeVaultTransactorSession) Receive() (*types.Transaction, error)

+ func (_BaseFeeVault *BaseFeeVaultTransactorSession) Withdraw() (*types.Transaction, error)

+ type BaseFeeVaultWithdrawal struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type BaseFeeVaultWithdrawal0 struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ WithdrawalNetwork uint8

+ type BaseFeeVaultWithdrawal0Iterator struct

+ Event *BaseFeeVaultWithdrawal0

+ func (it *BaseFeeVaultWithdrawal0Iterator) Close() error

+ func (it *BaseFeeVaultWithdrawal0Iterator) Error() error

+ func (it *BaseFeeVaultWithdrawal0Iterator) Next() bool

+ type BaseFeeVaultWithdrawalIterator struct

+ Event *BaseFeeVaultWithdrawal

+ func (it *BaseFeeVaultWithdrawalIterator) Close() error

+ func (it *BaseFeeVaultWithdrawalIterator) Error() error

+ func (it *BaseFeeVaultWithdrawalIterator) Next() bool

+ type BlockOracle struct

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

+ func NewBlockOracle(address common.Address, backend bind.ContractBackend) (*BlockOracle, error)

+ type BlockOracleBlockInfo struct

+ ChildTimestamp uint64

+ Hash [32]byte

+ type BlockOracleCaller struct

+ func NewBlockOracleCaller(address common.Address, caller bind.ContractCaller) (*BlockOracleCaller, error)

+ func (_BlockOracle *BlockOracleCaller) Load(opts *bind.CallOpts, _blockNumber *big.Int) (BlockOracleBlockInfo, error)

+ func (_BlockOracle *BlockOracleCaller) Version(opts *bind.CallOpts) (string, error)

+ type BlockOracleCallerRaw struct

+ Contract *BlockOracleCaller

+ func (_BlockOracle *BlockOracleCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type BlockOracleCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *BlockOracleCaller

+ func (_BlockOracle *BlockOracleCallerSession) Load(_blockNumber *big.Int) (BlockOracleBlockInfo, error)

+ func (_BlockOracle *BlockOracleCallerSession) Version() (string, error)

+ type BlockOracleCheckpoint struct

+ BlockHash [32]byte

+ BlockNumber *big.Int

+ ChildTimestamp uint64

+ Raw types.Log

+ type BlockOracleCheckpointIterator struct

+ Event *BlockOracleCheckpoint

+ func (it *BlockOracleCheckpointIterator) Close() error

+ func (it *BlockOracleCheckpointIterator) Error() error

+ func (it *BlockOracleCheckpointIterator) Next() bool

+ type BlockOracleFilterer struct

+ func NewBlockOracleFilterer(address common.Address, filterer bind.ContractFilterer) (*BlockOracleFilterer, error)

+ func (_BlockOracle *BlockOracleFilterer) FilterCheckpoint(opts *bind.FilterOpts, blockNumber []*big.Int, blockHash [][32]byte, ...) (*BlockOracleCheckpointIterator, error)

+ func (_BlockOracle *BlockOracleFilterer) ParseCheckpoint(log types.Log) (*BlockOracleCheckpoint, error)

+ func (_BlockOracle *BlockOracleFilterer) WatchCheckpoint(opts *bind.WatchOpts, sink chan<- *BlockOracleCheckpoint, ...) (event.Subscription, error)

+ type BlockOracleRaw struct

+ Contract *BlockOracle

+ func (_BlockOracle *BlockOracleRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_BlockOracle *BlockOracleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BlockOracleSession struct

+ CallOpts bind.CallOpts

+ Contract *BlockOracle

+ TransactOpts bind.TransactOpts

+ func (_BlockOracle *BlockOracleSession) Checkpoint() (*types.Transaction, error)

+ func (_BlockOracle *BlockOracleSession) Load(_blockNumber *big.Int) (BlockOracleBlockInfo, error)

+ func (_BlockOracle *BlockOracleSession) Version() (string, error)

+ type BlockOracleTransactor struct

+ func NewBlockOracleTransactor(address common.Address, transactor bind.ContractTransactor) (*BlockOracleTransactor, error)

+ func (_BlockOracle *BlockOracleTransactor) Checkpoint(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BlockOracleTransactorRaw struct

+ Contract *BlockOracleTransactor

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

+ func (_BlockOracle *BlockOracleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BlockOracleTransactorSession struct

+ Contract *BlockOracleTransactor

+ TransactOpts bind.TransactOpts

+ func (_BlockOracle *BlockOracleTransactorSession) Checkpoint() (*types.Transaction, error)

+ type CrossDomainMessenger struct

+ func NewCrossDomainMessenger(address common.Address, backend bind.ContractBackend) (*CrossDomainMessenger, error)

+ type CrossDomainMessengerCaller struct

+ func NewCrossDomainMessengerCaller(address common.Address, caller bind.ContractCaller) (*CrossDomainMessengerCaller, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCaller) BaseGas(opts *bind.CallOpts, _message []byte, _minGasLimit uint32) (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCaller) FailedMessages(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCaller) MESSAGEVERSION(opts *bind.CallOpts) (uint16, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCaller) MINGASCALLDATAOVERHEAD(opts *bind.CallOpts) (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCaller) MINGASDYNAMICOVERHEADDENOMINATOR(opts *bind.CallOpts) (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCaller) MINGASDYNAMICOVERHEADNUMERATOR(opts *bind.CallOpts) (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCaller) MessageNonce(opts *bind.CallOpts) (*big.Int, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCaller) OTHERMESSENGER(opts *bind.CallOpts) (common.Address, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCaller) RELAYCALLOVERHEAD(opts *bind.CallOpts) (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCaller) RELAYCONSTANTOVERHEAD(opts *bind.CallOpts) (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCaller) RELAYGASCHECKBUFFER(opts *bind.CallOpts) (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCaller) RELAYRESERVEDGAS(opts *bind.CallOpts) (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCaller) SuccessfulMessages(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCaller) XDomainMessageSender(opts *bind.CallOpts) (common.Address, error)

+ type CrossDomainMessengerCallerRaw struct

+ Contract *CrossDomainMessengerCaller

+ func (_CrossDomainMessenger *CrossDomainMessengerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type CrossDomainMessengerCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *CrossDomainMessengerCaller

+ func (_CrossDomainMessenger *CrossDomainMessengerCallerSession) BaseGas(_message []byte, _minGasLimit uint32) (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCallerSession) FailedMessages(arg0 [32]byte) (bool, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCallerSession) MESSAGEVERSION() (uint16, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCallerSession) MINGASCALLDATAOVERHEAD() (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCallerSession) MINGASDYNAMICOVERHEADDENOMINATOR() (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCallerSession) MINGASDYNAMICOVERHEADNUMERATOR() (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCallerSession) MessageNonce() (*big.Int, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCallerSession) OTHERMESSENGER() (common.Address, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCallerSession) RELAYCALLOVERHEAD() (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCallerSession) RELAYCONSTANTOVERHEAD() (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCallerSession) RELAYGASCHECKBUFFER() (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCallerSession) RELAYRESERVEDGAS() (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCallerSession) SuccessfulMessages(arg0 [32]byte) (bool, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerCallerSession) XDomainMessageSender() (common.Address, error)

+ type CrossDomainMessengerFailedRelayedMessage struct

+ MsgHash [32]byte

+ Raw types.Log

+ type CrossDomainMessengerFailedRelayedMessageIterator struct

+ Event *CrossDomainMessengerFailedRelayedMessage

+ func (it *CrossDomainMessengerFailedRelayedMessageIterator) Close() error

+ func (it *CrossDomainMessengerFailedRelayedMessageIterator) Error() error

+ func (it *CrossDomainMessengerFailedRelayedMessageIterator) Next() bool

+ type CrossDomainMessengerFilterer struct

+ func NewCrossDomainMessengerFilterer(address common.Address, filterer bind.ContractFilterer) (*CrossDomainMessengerFilterer, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerFilterer) FilterFailedRelayedMessage(opts *bind.FilterOpts, msgHash [][32]byte) (*CrossDomainMessengerFailedRelayedMessageIterator, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerFilterer) FilterInitialized(opts *bind.FilterOpts) (*CrossDomainMessengerInitializedIterator, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerFilterer) FilterRelayedMessage(opts *bind.FilterOpts, msgHash [][32]byte) (*CrossDomainMessengerRelayedMessageIterator, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerFilterer) FilterSentMessage(opts *bind.FilterOpts, target []common.Address) (*CrossDomainMessengerSentMessageIterator, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerFilterer) FilterSentMessageExtension1(opts *bind.FilterOpts, sender []common.Address) (*CrossDomainMessengerSentMessageExtension1Iterator, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerFilterer) ParseFailedRelayedMessage(log types.Log) (*CrossDomainMessengerFailedRelayedMessage, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerFilterer) ParseInitialized(log types.Log) (*CrossDomainMessengerInitialized, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerFilterer) ParseRelayedMessage(log types.Log) (*CrossDomainMessengerRelayedMessage, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerFilterer) ParseSentMessage(log types.Log) (*CrossDomainMessengerSentMessage, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerFilterer) ParseSentMessageExtension1(log types.Log) (*CrossDomainMessengerSentMessageExtension1, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerFilterer) WatchFailedRelayedMessage(opts *bind.WatchOpts, sink chan<- *CrossDomainMessengerFailedRelayedMessage, ...) (event.Subscription, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *CrossDomainMessengerInitialized) (event.Subscription, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerFilterer) WatchRelayedMessage(opts *bind.WatchOpts, sink chan<- *CrossDomainMessengerRelayedMessage, ...) (event.Subscription, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerFilterer) WatchSentMessage(opts *bind.WatchOpts, sink chan<- *CrossDomainMessengerSentMessage, ...) (event.Subscription, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerFilterer) WatchSentMessageExtension1(opts *bind.WatchOpts, sink chan<- *CrossDomainMessengerSentMessageExtension1, ...) (event.Subscription, error)

+ type CrossDomainMessengerInitialized struct

+ Raw types.Log

+ Version uint8

+ type CrossDomainMessengerInitializedIterator struct

+ Event *CrossDomainMessengerInitialized

+ func (it *CrossDomainMessengerInitializedIterator) Close() error

+ func (it *CrossDomainMessengerInitializedIterator) Error() error

+ func (it *CrossDomainMessengerInitializedIterator) Next() bool

+ type CrossDomainMessengerRaw struct

+ Contract *CrossDomainMessenger

+ func (_CrossDomainMessenger *CrossDomainMessengerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_CrossDomainMessenger *CrossDomainMessengerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type CrossDomainMessengerRelayedMessage struct

+ MsgHash [32]byte

+ Raw types.Log

+ type CrossDomainMessengerRelayedMessageIterator struct

+ Event *CrossDomainMessengerRelayedMessage

+ func (it *CrossDomainMessengerRelayedMessageIterator) Close() error

+ func (it *CrossDomainMessengerRelayedMessageIterator) Error() error

+ func (it *CrossDomainMessengerRelayedMessageIterator) Next() bool

+ type CrossDomainMessengerSentMessage struct

+ GasLimit *big.Int

+ Message []byte

+ MessageNonce *big.Int

+ Raw types.Log

+ Sender common.Address

+ Target common.Address

+ type CrossDomainMessengerSentMessageExtension1 struct

+ Raw types.Log

+ Sender common.Address

+ Value *big.Int

+ type CrossDomainMessengerSentMessageExtension1Iterator struct

+ Event *CrossDomainMessengerSentMessageExtension1

+ func (it *CrossDomainMessengerSentMessageExtension1Iterator) Close() error

+ func (it *CrossDomainMessengerSentMessageExtension1Iterator) Error() error

+ func (it *CrossDomainMessengerSentMessageExtension1Iterator) Next() bool

+ type CrossDomainMessengerSentMessageIterator struct

+ Event *CrossDomainMessengerSentMessage

+ func (it *CrossDomainMessengerSentMessageIterator) Close() error

+ func (it *CrossDomainMessengerSentMessageIterator) Error() error

+ func (it *CrossDomainMessengerSentMessageIterator) Next() bool

+ type CrossDomainMessengerSession struct

+ CallOpts bind.CallOpts

+ Contract *CrossDomainMessenger

+ TransactOpts bind.TransactOpts

+ func (_CrossDomainMessenger *CrossDomainMessengerSession) BaseGas(_message []byte, _minGasLimit uint32) (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerSession) FailedMessages(arg0 [32]byte) (bool, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerSession) MESSAGEVERSION() (uint16, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerSession) MINGASCALLDATAOVERHEAD() (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerSession) MINGASDYNAMICOVERHEADDENOMINATOR() (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerSession) MINGASDYNAMICOVERHEADNUMERATOR() (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerSession) MessageNonce() (*big.Int, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerSession) OTHERMESSENGER() (common.Address, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerSession) RELAYCALLOVERHEAD() (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerSession) RELAYCONSTANTOVERHEAD() (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerSession) RELAYGASCHECKBUFFER() (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerSession) RELAYRESERVEDGAS() (uint64, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerSession) RelayMessage(_nonce *big.Int, _sender common.Address, _target common.Address, ...) (*types.Transaction, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerSession) SendMessage(_target common.Address, _message []byte, _minGasLimit uint32) (*types.Transaction, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerSession) SuccessfulMessages(arg0 [32]byte) (bool, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerSession) XDomainMessageSender() (common.Address, error)

+ type CrossDomainMessengerTransactor struct

+ func NewCrossDomainMessengerTransactor(address common.Address, transactor bind.ContractTransactor) (*CrossDomainMessengerTransactor, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerTransactor) RelayMessage(opts *bind.TransactOpts, _nonce *big.Int, _sender common.Address, ...) (*types.Transaction, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerTransactor) SendMessage(opts *bind.TransactOpts, _target common.Address, _message []byte, ...) (*types.Transaction, error)

+ type CrossDomainMessengerTransactorRaw struct

+ Contract *CrossDomainMessengerTransactor

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

+ func (_CrossDomainMessenger *CrossDomainMessengerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type CrossDomainMessengerTransactorSession struct

+ Contract *CrossDomainMessengerTransactor

+ TransactOpts bind.TransactOpts

+ func (_CrossDomainMessenger *CrossDomainMessengerTransactorSession) RelayMessage(_nonce *big.Int, _sender common.Address, _target common.Address, ...) (*types.Transaction, error)

+ func (_CrossDomainMessenger *CrossDomainMessengerTransactorSession) SendMessage(_target common.Address, _message []byte, _minGasLimit uint32) (*types.Transaction, error)

+ type DelayedVetoable struct

+ func DeployDelayedVetoable(auth *bind.TransactOpts, backend bind.ContractBackend, vetoer_ common.Address, ...) (common.Address, *types.Transaction, *DelayedVetoable, error)

+ func NewDelayedVetoable(address common.Address, backend bind.ContractBackend) (*DelayedVetoable, error)

+ type DelayedVetoableCaller struct

+ func NewDelayedVetoableCaller(address common.Address, caller bind.ContractCaller) (*DelayedVetoableCaller, error)

+ func (_DelayedVetoable *DelayedVetoableCaller) Version(opts *bind.CallOpts) (string, error)

+ type DelayedVetoableCallerRaw struct

+ Contract *DelayedVetoableCaller

+ func (_DelayedVetoable *DelayedVetoableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type DelayedVetoableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *DelayedVetoableCaller

+ func (_DelayedVetoable *DelayedVetoableCallerSession) Version() (string, error)

+ type DelayedVetoableDelayActivated struct

+ Delay *big.Int

+ Raw types.Log

+ type DelayedVetoableDelayActivatedIterator struct

+ Event *DelayedVetoableDelayActivated

+ func (it *DelayedVetoableDelayActivatedIterator) Close() error

+ func (it *DelayedVetoableDelayActivatedIterator) Error() error

+ func (it *DelayedVetoableDelayActivatedIterator) Next() bool

+ type DelayedVetoableFilterer struct

+ func NewDelayedVetoableFilterer(address common.Address, filterer bind.ContractFilterer) (*DelayedVetoableFilterer, error)

+ func (_DelayedVetoable *DelayedVetoableFilterer) FilterDelayActivated(opts *bind.FilterOpts) (*DelayedVetoableDelayActivatedIterator, error)

+ func (_DelayedVetoable *DelayedVetoableFilterer) FilterForwarded(opts *bind.FilterOpts, callHash [][32]byte) (*DelayedVetoableForwardedIterator, error)

+ func (_DelayedVetoable *DelayedVetoableFilterer) FilterInitiated(opts *bind.FilterOpts, callHash [][32]byte) (*DelayedVetoableInitiatedIterator, error)

+ func (_DelayedVetoable *DelayedVetoableFilterer) FilterVetoed(opts *bind.FilterOpts, callHash [][32]byte) (*DelayedVetoableVetoedIterator, error)

+ func (_DelayedVetoable *DelayedVetoableFilterer) ParseDelayActivated(log types.Log) (*DelayedVetoableDelayActivated, error)

+ func (_DelayedVetoable *DelayedVetoableFilterer) ParseForwarded(log types.Log) (*DelayedVetoableForwarded, error)

+ func (_DelayedVetoable *DelayedVetoableFilterer) ParseInitiated(log types.Log) (*DelayedVetoableInitiated, error)

+ func (_DelayedVetoable *DelayedVetoableFilterer) ParseVetoed(log types.Log) (*DelayedVetoableVetoed, error)

+ func (_DelayedVetoable *DelayedVetoableFilterer) WatchDelayActivated(opts *bind.WatchOpts, sink chan<- *DelayedVetoableDelayActivated) (event.Subscription, error)

+ func (_DelayedVetoable *DelayedVetoableFilterer) WatchForwarded(opts *bind.WatchOpts, sink chan<- *DelayedVetoableForwarded, ...) (event.Subscription, error)

+ func (_DelayedVetoable *DelayedVetoableFilterer) WatchInitiated(opts *bind.WatchOpts, sink chan<- *DelayedVetoableInitiated, ...) (event.Subscription, error)

+ func (_DelayedVetoable *DelayedVetoableFilterer) WatchVetoed(opts *bind.WatchOpts, sink chan<- *DelayedVetoableVetoed, callHash [][32]byte) (event.Subscription, error)

+ type DelayedVetoableForwarded struct

+ CallHash [32]byte

+ Data []byte

+ Raw types.Log

+ type DelayedVetoableForwardedIterator struct

+ Event *DelayedVetoableForwarded

+ func (it *DelayedVetoableForwardedIterator) Close() error

+ func (it *DelayedVetoableForwardedIterator) Error() error

+ func (it *DelayedVetoableForwardedIterator) Next() bool

+ type DelayedVetoableInitiated struct

+ CallHash [32]byte

+ Data []byte

+ Raw types.Log

+ type DelayedVetoableInitiatedIterator struct

+ Event *DelayedVetoableInitiated

+ func (it *DelayedVetoableInitiatedIterator) Close() error

+ func (it *DelayedVetoableInitiatedIterator) Error() error

+ func (it *DelayedVetoableInitiatedIterator) Next() bool

+ type DelayedVetoableRaw struct

+ Contract *DelayedVetoable

+ func (_DelayedVetoable *DelayedVetoableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_DelayedVetoable *DelayedVetoableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DelayedVetoableSession struct

+ CallOpts bind.CallOpts

+ Contract *DelayedVetoable

+ TransactOpts bind.TransactOpts

+ func (_DelayedVetoable *DelayedVetoableSession) Delay() (*types.Transaction, error)

+ func (_DelayedVetoable *DelayedVetoableSession) Fallback(calldata []byte) (*types.Transaction, error)

+ func (_DelayedVetoable *DelayedVetoableSession) Initiator() (*types.Transaction, error)

+ func (_DelayedVetoable *DelayedVetoableSession) QueuedAt(callHash [32]byte) (*types.Transaction, error)

+ func (_DelayedVetoable *DelayedVetoableSession) Target() (*types.Transaction, error)

+ func (_DelayedVetoable *DelayedVetoableSession) Version() (string, error)

+ func (_DelayedVetoable *DelayedVetoableSession) Vetoer() (*types.Transaction, error)

+ type DelayedVetoableTransactor struct

+ func NewDelayedVetoableTransactor(address common.Address, transactor bind.ContractTransactor) (*DelayedVetoableTransactor, error)

+ func (_DelayedVetoable *DelayedVetoableTransactor) Delay(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DelayedVetoable *DelayedVetoableTransactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error)

+ func (_DelayedVetoable *DelayedVetoableTransactor) Initiator(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DelayedVetoable *DelayedVetoableTransactor) QueuedAt(opts *bind.TransactOpts, callHash [32]byte) (*types.Transaction, error)

+ func (_DelayedVetoable *DelayedVetoableTransactor) Target(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DelayedVetoable *DelayedVetoableTransactor) Vetoer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DelayedVetoableTransactorRaw struct

+ Contract *DelayedVetoableTransactor

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

+ func (_DelayedVetoable *DelayedVetoableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DelayedVetoableTransactorSession struct

+ Contract *DelayedVetoableTransactor

+ TransactOpts bind.TransactOpts

+ func (_DelayedVetoable *DelayedVetoableTransactorSession) Delay() (*types.Transaction, error)

+ func (_DelayedVetoable *DelayedVetoableTransactorSession) Fallback(calldata []byte) (*types.Transaction, error)

+ func (_DelayedVetoable *DelayedVetoableTransactorSession) Initiator() (*types.Transaction, error)

+ func (_DelayedVetoable *DelayedVetoableTransactorSession) QueuedAt(callHash [32]byte) (*types.Transaction, error)

+ func (_DelayedVetoable *DelayedVetoableTransactorSession) Target() (*types.Transaction, error)

+ func (_DelayedVetoable *DelayedVetoableTransactorSession) Vetoer() (*types.Transaction, error)

+ type DelayedVetoableVetoed struct

+ CallHash [32]byte

+ Data []byte

+ Raw types.Log

+ type DelayedVetoableVetoedIterator struct

+ Event *DelayedVetoableVetoed

+ func (it *DelayedVetoableVetoedIterator) Close() error

+ func (it *DelayedVetoableVetoedIterator) Error() error

+ func (it *DelayedVetoableVetoedIterator) Next() bool

+ type DelegatedAttestationRequest struct

+ Attester common.Address

+ Data AttestationRequestData

+ Deadline uint64

+ Schema [32]byte

+ Signature Signature

+ type DelegatedRevocationRequest struct

+ Data RevocationRequestData

+ Deadline uint64

+ Revoker common.Address

+ Schema [32]byte

+ Signature Signature

+ type DeployerWhitelist struct

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

+ func NewDeployerWhitelist(address common.Address, backend bind.ContractBackend) (*DeployerWhitelist, error)

+ type DeployerWhitelistCaller struct

+ func NewDeployerWhitelistCaller(address common.Address, caller bind.ContractCaller) (*DeployerWhitelistCaller, error)

+ func (_DeployerWhitelist *DeployerWhitelistCaller) IsDeployerAllowed(opts *bind.CallOpts, _deployer common.Address) (bool, error)

+ func (_DeployerWhitelist *DeployerWhitelistCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_DeployerWhitelist *DeployerWhitelistCaller) Version(opts *bind.CallOpts) (string, error)

+ func (_DeployerWhitelist *DeployerWhitelistCaller) Whitelist(opts *bind.CallOpts, arg0 common.Address) (bool, error)

+ type DeployerWhitelistCallerRaw struct

+ Contract *DeployerWhitelistCaller

+ func (_DeployerWhitelist *DeployerWhitelistCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type DeployerWhitelistCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *DeployerWhitelistCaller

+ func (_DeployerWhitelist *DeployerWhitelistCallerSession) IsDeployerAllowed(_deployer common.Address) (bool, error)

+ func (_DeployerWhitelist *DeployerWhitelistCallerSession) Owner() (common.Address, error)

+ func (_DeployerWhitelist *DeployerWhitelistCallerSession) Version() (string, error)

+ func (_DeployerWhitelist *DeployerWhitelistCallerSession) Whitelist(arg0 common.Address) (bool, error)

+ type DeployerWhitelistFilterer struct

+ func NewDeployerWhitelistFilterer(address common.Address, filterer bind.ContractFilterer) (*DeployerWhitelistFilterer, error)

+ func (_DeployerWhitelist *DeployerWhitelistFilterer) FilterOwnerChanged(opts *bind.FilterOpts) (*DeployerWhitelistOwnerChangedIterator, error)

+ func (_DeployerWhitelist *DeployerWhitelistFilterer) FilterWhitelistDisabled(opts *bind.FilterOpts) (*DeployerWhitelistWhitelistDisabledIterator, error)

+ func (_DeployerWhitelist *DeployerWhitelistFilterer) FilterWhitelistStatusChanged(opts *bind.FilterOpts) (*DeployerWhitelistWhitelistStatusChangedIterator, error)

+ func (_DeployerWhitelist *DeployerWhitelistFilterer) ParseOwnerChanged(log types.Log) (*DeployerWhitelistOwnerChanged, error)

+ func (_DeployerWhitelist *DeployerWhitelistFilterer) ParseWhitelistDisabled(log types.Log) (*DeployerWhitelistWhitelistDisabled, error)

+ func (_DeployerWhitelist *DeployerWhitelistFilterer) ParseWhitelistStatusChanged(log types.Log) (*DeployerWhitelistWhitelistStatusChanged, error)

+ func (_DeployerWhitelist *DeployerWhitelistFilterer) WatchOwnerChanged(opts *bind.WatchOpts, sink chan<- *DeployerWhitelistOwnerChanged) (event.Subscription, error)

+ func (_DeployerWhitelist *DeployerWhitelistFilterer) WatchWhitelistDisabled(opts *bind.WatchOpts, sink chan<- *DeployerWhitelistWhitelistDisabled) (event.Subscription, error)

+ func (_DeployerWhitelist *DeployerWhitelistFilterer) WatchWhitelistStatusChanged(opts *bind.WatchOpts, sink chan<- *DeployerWhitelistWhitelistStatusChanged) (event.Subscription, error)

+ type DeployerWhitelistOwnerChanged struct

+ NewOwner common.Address

+ OldOwner common.Address

+ Raw types.Log

+ type DeployerWhitelistOwnerChangedIterator struct

+ Event *DeployerWhitelistOwnerChanged

+ func (it *DeployerWhitelistOwnerChangedIterator) Close() error

+ func (it *DeployerWhitelistOwnerChangedIterator) Error() error

+ func (it *DeployerWhitelistOwnerChangedIterator) Next() bool

+ type DeployerWhitelistRaw struct

+ Contract *DeployerWhitelist

+ func (_DeployerWhitelist *DeployerWhitelistRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_DeployerWhitelist *DeployerWhitelistRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DeployerWhitelistSession struct

+ CallOpts bind.CallOpts

+ Contract *DeployerWhitelist

+ TransactOpts bind.TransactOpts

+ func (_DeployerWhitelist *DeployerWhitelistSession) EnableArbitraryContractDeployment() (*types.Transaction, error)

+ func (_DeployerWhitelist *DeployerWhitelistSession) IsDeployerAllowed(_deployer common.Address) (bool, error)

+ func (_DeployerWhitelist *DeployerWhitelistSession) Owner() (common.Address, error)

+ func (_DeployerWhitelist *DeployerWhitelistSession) SetOwner(_owner common.Address) (*types.Transaction, error)

+ func (_DeployerWhitelist *DeployerWhitelistSession) SetWhitelistedDeployer(_deployer common.Address, _isWhitelisted bool) (*types.Transaction, error)

+ func (_DeployerWhitelist *DeployerWhitelistSession) Version() (string, error)

+ func (_DeployerWhitelist *DeployerWhitelistSession) Whitelist(arg0 common.Address) (bool, error)

+ type DeployerWhitelistTransactor struct

+ func NewDeployerWhitelistTransactor(address common.Address, transactor bind.ContractTransactor) (*DeployerWhitelistTransactor, error)

+ func (_DeployerWhitelist *DeployerWhitelistTransactor) EnableArbitraryContractDeployment(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DeployerWhitelist *DeployerWhitelistTransactor) SetOwner(opts *bind.TransactOpts, _owner common.Address) (*types.Transaction, error)

+ func (_DeployerWhitelist *DeployerWhitelistTransactor) SetWhitelistedDeployer(opts *bind.TransactOpts, _deployer common.Address, _isWhitelisted bool) (*types.Transaction, error)

+ type DeployerWhitelistTransactorRaw struct

+ Contract *DeployerWhitelistTransactor

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

+ func (_DeployerWhitelist *DeployerWhitelistTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DeployerWhitelistTransactorSession struct

+ Contract *DeployerWhitelistTransactor

+ TransactOpts bind.TransactOpts

+ func (_DeployerWhitelist *DeployerWhitelistTransactorSession) EnableArbitraryContractDeployment() (*types.Transaction, error)

+ func (_DeployerWhitelist *DeployerWhitelistTransactorSession) SetOwner(_owner common.Address) (*types.Transaction, error)

+ func (_DeployerWhitelist *DeployerWhitelistTransactorSession) SetWhitelistedDeployer(_deployer common.Address, _isWhitelisted bool) (*types.Transaction, error)

+ type DeployerWhitelistWhitelistDisabled struct

+ OldOwner common.Address

+ Raw types.Log

+ type DeployerWhitelistWhitelistDisabledIterator struct

+ Event *DeployerWhitelistWhitelistDisabled

+ func (it *DeployerWhitelistWhitelistDisabledIterator) Close() error

+ func (it *DeployerWhitelistWhitelistDisabledIterator) Error() error

+ func (it *DeployerWhitelistWhitelistDisabledIterator) Next() bool

+ type DeployerWhitelistWhitelistStatusChanged struct

+ Deployer common.Address

+ Raw types.Log

+ Whitelisted bool

+ type DeployerWhitelistWhitelistStatusChangedIterator struct

+ Event *DeployerWhitelistWhitelistStatusChanged

+ func (it *DeployerWhitelistWhitelistStatusChangedIterator) Close() error

+ func (it *DeployerWhitelistWhitelistStatusChangedIterator) Error() error

+ func (it *DeployerWhitelistWhitelistStatusChangedIterator) Next() bool

+ type DisputeGameFactory struct

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

+ func NewDisputeGameFactory(address common.Address, backend bind.ContractBackend) (*DisputeGameFactory, error)

+ type DisputeGameFactoryCaller struct

+ func NewDisputeGameFactoryCaller(address common.Address, caller bind.ContractCaller) (*DisputeGameFactoryCaller, error)

+ func (_DisputeGameFactory *DisputeGameFactoryCaller) GameAtIndex(opts *bind.CallOpts, _index *big.Int) (struct{ ... }, error)

+ func (_DisputeGameFactory *DisputeGameFactoryCaller) GameCount(opts *bind.CallOpts) (*big.Int, error)

+ func (_DisputeGameFactory *DisputeGameFactoryCaller) GameImpls(opts *bind.CallOpts, arg0 uint8) (common.Address, error)

+ func (_DisputeGameFactory *DisputeGameFactoryCaller) Games(opts *bind.CallOpts, _gameType uint8, _rootClaim [32]byte, _extraData []byte) (struct{ ... }, error)

+ func (_DisputeGameFactory *DisputeGameFactoryCaller) GetGameUUID(opts *bind.CallOpts, _gameType uint8, _rootClaim [32]byte, _extraData []byte) ([32]byte, error)

+ func (_DisputeGameFactory *DisputeGameFactoryCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_DisputeGameFactory *DisputeGameFactoryCaller) Version(opts *bind.CallOpts) (string, error)

+ type DisputeGameFactoryCallerRaw struct

+ Contract *DisputeGameFactoryCaller

+ func (_DisputeGameFactory *DisputeGameFactoryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type DisputeGameFactoryCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *DisputeGameFactoryCaller

+ func (_DisputeGameFactory *DisputeGameFactoryCallerSession) GameAtIndex(_index *big.Int) (struct{ ... }, error)

+ func (_DisputeGameFactory *DisputeGameFactoryCallerSession) GameCount() (*big.Int, error)

+ func (_DisputeGameFactory *DisputeGameFactoryCallerSession) GameImpls(arg0 uint8) (common.Address, error)

+ func (_DisputeGameFactory *DisputeGameFactoryCallerSession) Games(_gameType uint8, _rootClaim [32]byte, _extraData []byte) (struct{ ... }, error)

+ func (_DisputeGameFactory *DisputeGameFactoryCallerSession) GetGameUUID(_gameType uint8, _rootClaim [32]byte, _extraData []byte) ([32]byte, error)

+ func (_DisputeGameFactory *DisputeGameFactoryCallerSession) Owner() (common.Address, error)

+ func (_DisputeGameFactory *DisputeGameFactoryCallerSession) Version() (string, error)

+ type DisputeGameFactoryDisputeGameCreated struct

+ DisputeProxy common.Address

+ GameType uint8

+ Raw types.Log

+ RootClaim [32]byte

+ type DisputeGameFactoryDisputeGameCreatedIterator struct

+ Event *DisputeGameFactoryDisputeGameCreated

+ func (it *DisputeGameFactoryDisputeGameCreatedIterator) Close() error

+ func (it *DisputeGameFactoryDisputeGameCreatedIterator) Error() error

+ func (it *DisputeGameFactoryDisputeGameCreatedIterator) Next() bool

+ type DisputeGameFactoryFilterer struct

+ func NewDisputeGameFactoryFilterer(address common.Address, filterer bind.ContractFilterer) (*DisputeGameFactoryFilterer, error)

+ func (_DisputeGameFactory *DisputeGameFactoryFilterer) FilterDisputeGameCreated(opts *bind.FilterOpts, disputeProxy []common.Address, gameType []uint8, ...) (*DisputeGameFactoryDisputeGameCreatedIterator, error)

+ func (_DisputeGameFactory *DisputeGameFactoryFilterer) FilterImplementationSet(opts *bind.FilterOpts, impl []common.Address, gameType []uint8) (*DisputeGameFactoryImplementationSetIterator, error)

+ func (_DisputeGameFactory *DisputeGameFactoryFilterer) FilterInitialized(opts *bind.FilterOpts) (*DisputeGameFactoryInitializedIterator, error)

+ func (_DisputeGameFactory *DisputeGameFactoryFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*DisputeGameFactoryOwnershipTransferredIterator, error)

+ func (_DisputeGameFactory *DisputeGameFactoryFilterer) ParseDisputeGameCreated(log types.Log) (*DisputeGameFactoryDisputeGameCreated, error)

+ func (_DisputeGameFactory *DisputeGameFactoryFilterer) ParseImplementationSet(log types.Log) (*DisputeGameFactoryImplementationSet, error)

+ func (_DisputeGameFactory *DisputeGameFactoryFilterer) ParseInitialized(log types.Log) (*DisputeGameFactoryInitialized, error)

+ func (_DisputeGameFactory *DisputeGameFactoryFilterer) ParseOwnershipTransferred(log types.Log) (*DisputeGameFactoryOwnershipTransferred, error)

+ func (_DisputeGameFactory *DisputeGameFactoryFilterer) WatchDisputeGameCreated(opts *bind.WatchOpts, sink chan<- *DisputeGameFactoryDisputeGameCreated, ...) (event.Subscription, error)

+ func (_DisputeGameFactory *DisputeGameFactoryFilterer) WatchImplementationSet(opts *bind.WatchOpts, sink chan<- *DisputeGameFactoryImplementationSet, ...) (event.Subscription, error)

+ func (_DisputeGameFactory *DisputeGameFactoryFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *DisputeGameFactoryInitialized) (event.Subscription, error)

+ func (_DisputeGameFactory *DisputeGameFactoryFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *DisputeGameFactoryOwnershipTransferred, ...) (event.Subscription, error)

+ type DisputeGameFactoryImplementationSet struct

+ GameType uint8

+ Impl common.Address

+ Raw types.Log

+ type DisputeGameFactoryImplementationSetIterator struct

+ Event *DisputeGameFactoryImplementationSet

+ func (it *DisputeGameFactoryImplementationSetIterator) Close() error

+ func (it *DisputeGameFactoryImplementationSetIterator) Error() error

+ func (it *DisputeGameFactoryImplementationSetIterator) Next() bool

+ type DisputeGameFactoryInitialized struct

+ Raw types.Log

+ Version uint8

+ type DisputeGameFactoryInitializedIterator struct

+ Event *DisputeGameFactoryInitialized

+ func (it *DisputeGameFactoryInitializedIterator) Close() error

+ func (it *DisputeGameFactoryInitializedIterator) Error() error

+ func (it *DisputeGameFactoryInitializedIterator) Next() bool

+ type DisputeGameFactoryOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type DisputeGameFactoryOwnershipTransferredIterator struct

+ Event *DisputeGameFactoryOwnershipTransferred

+ func (it *DisputeGameFactoryOwnershipTransferredIterator) Close() error

+ func (it *DisputeGameFactoryOwnershipTransferredIterator) Error() error

+ func (it *DisputeGameFactoryOwnershipTransferredIterator) Next() bool

+ type DisputeGameFactoryRaw struct

+ Contract *DisputeGameFactory

+ func (_DisputeGameFactory *DisputeGameFactoryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_DisputeGameFactory *DisputeGameFactoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DisputeGameFactorySession struct

+ CallOpts bind.CallOpts

+ Contract *DisputeGameFactory

+ TransactOpts bind.TransactOpts

+ func (_DisputeGameFactory *DisputeGameFactorySession) Create(_gameType uint8, _rootClaim [32]byte, _extraData []byte) (*types.Transaction, error)

+ func (_DisputeGameFactory *DisputeGameFactorySession) GameAtIndex(_index *big.Int) (struct{ ... }, error)

+ func (_DisputeGameFactory *DisputeGameFactorySession) GameCount() (*big.Int, error)

+ func (_DisputeGameFactory *DisputeGameFactorySession) GameImpls(arg0 uint8) (common.Address, error)

+ func (_DisputeGameFactory *DisputeGameFactorySession) Games(_gameType uint8, _rootClaim [32]byte, _extraData []byte) (struct{ ... }, error)

+ func (_DisputeGameFactory *DisputeGameFactorySession) GetGameUUID(_gameType uint8, _rootClaim [32]byte, _extraData []byte) ([32]byte, error)

+ func (_DisputeGameFactory *DisputeGameFactorySession) Initialize(_owner common.Address) (*types.Transaction, error)

+ func (_DisputeGameFactory *DisputeGameFactorySession) Owner() (common.Address, error)

+ func (_DisputeGameFactory *DisputeGameFactorySession) RenounceOwnership() (*types.Transaction, error)

+ func (_DisputeGameFactory *DisputeGameFactorySession) SetImplementation(_gameType uint8, _impl common.Address) (*types.Transaction, error)

+ func (_DisputeGameFactory *DisputeGameFactorySession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_DisputeGameFactory *DisputeGameFactorySession) Version() (string, error)

+ type DisputeGameFactoryTransactor struct

+ func NewDisputeGameFactoryTransactor(address common.Address, transactor bind.ContractTransactor) (*DisputeGameFactoryTransactor, error)

+ func (_DisputeGameFactory *DisputeGameFactoryTransactor) Create(opts *bind.TransactOpts, _gameType uint8, _rootClaim [32]byte, ...) (*types.Transaction, error)

+ func (_DisputeGameFactory *DisputeGameFactoryTransactor) Initialize(opts *bind.TransactOpts, _owner common.Address) (*types.Transaction, error)

+ func (_DisputeGameFactory *DisputeGameFactoryTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DisputeGameFactory *DisputeGameFactoryTransactor) SetImplementation(opts *bind.TransactOpts, _gameType uint8, _impl common.Address) (*types.Transaction, error)

+ func (_DisputeGameFactory *DisputeGameFactoryTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type DisputeGameFactoryTransactorRaw struct

+ Contract *DisputeGameFactoryTransactor

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

+ func (_DisputeGameFactory *DisputeGameFactoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DisputeGameFactoryTransactorSession struct

+ Contract *DisputeGameFactoryTransactor

+ TransactOpts bind.TransactOpts

+ func (_DisputeGameFactory *DisputeGameFactoryTransactorSession) Create(_gameType uint8, _rootClaim [32]byte, _extraData []byte) (*types.Transaction, error)

+ func (_DisputeGameFactory *DisputeGameFactoryTransactorSession) Initialize(_owner common.Address) (*types.Transaction, error)

+ func (_DisputeGameFactory *DisputeGameFactoryTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_DisputeGameFactory *DisputeGameFactoryTransactorSession) SetImplementation(_gameType uint8, _impl common.Address) (*types.Transaction, error)

+ func (_DisputeGameFactory *DisputeGameFactoryTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type EAS struct

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

+ func NewEAS(address common.Address, backend bind.ContractBackend) (*EAS, error)

+ type EASAttested struct

+ Attester common.Address

+ Raw types.Log

+ Recipient common.Address

+ SchemaUID [32]byte

+ Uid [32]byte

+ type EASAttestedIterator struct

+ Event *EASAttested

+ func (it *EASAttestedIterator) Close() error

+ func (it *EASAttestedIterator) Error() error

+ func (it *EASAttestedIterator) Next() bool

+ type EASCaller struct

+ func NewEASCaller(address common.Address, caller bind.ContractCaller) (*EASCaller, error)

+ func (_EAS *EASCaller) GetAttestTypeHash(opts *bind.CallOpts) ([32]byte, error)

+ func (_EAS *EASCaller) GetAttestation(opts *bind.CallOpts, uid [32]byte) (Attestation, error)

+ func (_EAS *EASCaller) GetDomainSeparator(opts *bind.CallOpts) ([32]byte, error)

+ func (_EAS *EASCaller) GetName(opts *bind.CallOpts) (string, error)

+ func (_EAS *EASCaller) GetNonce(opts *bind.CallOpts, account common.Address) (*big.Int, error)

+ func (_EAS *EASCaller) GetRevokeOffchain(opts *bind.CallOpts, revoker common.Address, data [32]byte) (uint64, error)

+ func (_EAS *EASCaller) GetRevokeTypeHash(opts *bind.CallOpts) ([32]byte, error)

+ func (_EAS *EASCaller) GetSchemaRegistry(opts *bind.CallOpts) (common.Address, error)

+ func (_EAS *EASCaller) GetTimestamp(opts *bind.CallOpts, data [32]byte) (uint64, error)

+ func (_EAS *EASCaller) IsAttestationValid(opts *bind.CallOpts, uid [32]byte) (bool, error)

+ func (_EAS *EASCaller) Version(opts *bind.CallOpts) (string, error)

+ type EASCallerRaw struct

+ Contract *EASCaller

+ func (_EAS *EASCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type EASCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *EASCaller

+ func (_EAS *EASCallerSession) GetAttestTypeHash() ([32]byte, error)

+ func (_EAS *EASCallerSession) GetAttestation(uid [32]byte) (Attestation, error)

+ func (_EAS *EASCallerSession) GetDomainSeparator() ([32]byte, error)

+ func (_EAS *EASCallerSession) GetName() (string, error)

+ func (_EAS *EASCallerSession) GetNonce(account common.Address) (*big.Int, error)

+ func (_EAS *EASCallerSession) GetRevokeOffchain(revoker common.Address, data [32]byte) (uint64, error)

+ func (_EAS *EASCallerSession) GetRevokeTypeHash() ([32]byte, error)

+ func (_EAS *EASCallerSession) GetSchemaRegistry() (common.Address, error)

+ func (_EAS *EASCallerSession) GetTimestamp(data [32]byte) (uint64, error)

+ func (_EAS *EASCallerSession) IsAttestationValid(uid [32]byte) (bool, error)

+ func (_EAS *EASCallerSession) Version() (string, error)

+ type EASFilterer struct

+ func NewEASFilterer(address common.Address, filterer bind.ContractFilterer) (*EASFilterer, error)

+ func (_EAS *EASFilterer) FilterAttested(opts *bind.FilterOpts, recipient []common.Address, attester []common.Address, ...) (*EASAttestedIterator, error)

+ func (_EAS *EASFilterer) FilterNonceIncreased(opts *bind.FilterOpts) (*EASNonceIncreasedIterator, error)

+ func (_EAS *EASFilterer) FilterRevoked(opts *bind.FilterOpts, recipient []common.Address, attester []common.Address, ...) (*EASRevokedIterator, error)

+ func (_EAS *EASFilterer) FilterRevokedOffchain(opts *bind.FilterOpts, revoker []common.Address, data [][32]byte, ...) (*EASRevokedOffchainIterator, error)

+ func (_EAS *EASFilterer) FilterTimestamped(opts *bind.FilterOpts, data [][32]byte, timestamp []uint64) (*EASTimestampedIterator, error)

+ func (_EAS *EASFilterer) ParseAttested(log types.Log) (*EASAttested, error)

+ func (_EAS *EASFilterer) ParseNonceIncreased(log types.Log) (*EASNonceIncreased, error)

+ func (_EAS *EASFilterer) ParseRevoked(log types.Log) (*EASRevoked, error)

+ func (_EAS *EASFilterer) ParseRevokedOffchain(log types.Log) (*EASRevokedOffchain, error)

+ func (_EAS *EASFilterer) ParseTimestamped(log types.Log) (*EASTimestamped, error)

+ func (_EAS *EASFilterer) WatchAttested(opts *bind.WatchOpts, sink chan<- *EASAttested, recipient []common.Address, ...) (event.Subscription, error)

+ func (_EAS *EASFilterer) WatchNonceIncreased(opts *bind.WatchOpts, sink chan<- *EASNonceIncreased) (event.Subscription, error)

+ func (_EAS *EASFilterer) WatchRevoked(opts *bind.WatchOpts, sink chan<- *EASRevoked, recipient []common.Address, ...) (event.Subscription, error)

+ func (_EAS *EASFilterer) WatchRevokedOffchain(opts *bind.WatchOpts, sink chan<- *EASRevokedOffchain, ...) (event.Subscription, error)

+ func (_EAS *EASFilterer) WatchTimestamped(opts *bind.WatchOpts, sink chan<- *EASTimestamped, data [][32]byte, ...) (event.Subscription, error)

+ type EASNonceIncreased struct

+ NewNonce *big.Int

+ OldNonce *big.Int

+ Raw types.Log

+ type EASNonceIncreasedIterator struct

+ Event *EASNonceIncreased

+ func (it *EASNonceIncreasedIterator) Close() error

+ func (it *EASNonceIncreasedIterator) Error() error

+ func (it *EASNonceIncreasedIterator) Next() bool

+ type EASRaw struct

+ Contract *EAS

+ func (_EAS *EASRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_EAS *EASRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type EASRevoked struct

+ Attester common.Address

+ Raw types.Log

+ Recipient common.Address

+ SchemaUID [32]byte

+ Uid [32]byte

+ type EASRevokedIterator struct

+ Event *EASRevoked

+ func (it *EASRevokedIterator) Close() error

+ func (it *EASRevokedIterator) Error() error

+ func (it *EASRevokedIterator) Next() bool

+ type EASRevokedOffchain struct

+ Data [32]byte

+ Raw types.Log

+ Revoker common.Address

+ Timestamp uint64

+ type EASRevokedOffchainIterator struct

+ Event *EASRevokedOffchain

+ func (it *EASRevokedOffchainIterator) Close() error

+ func (it *EASRevokedOffchainIterator) Error() error

+ func (it *EASRevokedOffchainIterator) Next() bool

+ type EASSession struct

+ CallOpts bind.CallOpts

+ Contract *EAS

+ TransactOpts bind.TransactOpts

+ func (_EAS *EASSession) Attest(request AttestationRequest) (*types.Transaction, error)

+ func (_EAS *EASSession) AttestByDelegation(delegatedRequest DelegatedAttestationRequest) (*types.Transaction, error)

+ func (_EAS *EASSession) GetAttestTypeHash() ([32]byte, error)

+ func (_EAS *EASSession) GetAttestation(uid [32]byte) (Attestation, error)

+ func (_EAS *EASSession) GetDomainSeparator() ([32]byte, error)

+ func (_EAS *EASSession) GetName() (string, error)

+ func (_EAS *EASSession) GetNonce(account common.Address) (*big.Int, error)

+ func (_EAS *EASSession) GetRevokeOffchain(revoker common.Address, data [32]byte) (uint64, error)

+ func (_EAS *EASSession) GetRevokeTypeHash() ([32]byte, error)

+ func (_EAS *EASSession) GetSchemaRegistry() (common.Address, error)

+ func (_EAS *EASSession) GetTimestamp(data [32]byte) (uint64, error)

+ func (_EAS *EASSession) IncreaseNonce(newNonce *big.Int) (*types.Transaction, error)

+ func (_EAS *EASSession) IsAttestationValid(uid [32]byte) (bool, error)

+ func (_EAS *EASSession) MultiAttest(multiRequests []MultiAttestationRequest) (*types.Transaction, error)

+ func (_EAS *EASSession) MultiAttestByDelegation(multiDelegatedRequests []MultiDelegatedAttestationRequest) (*types.Transaction, error)

+ func (_EAS *EASSession) MultiRevoke(multiRequests []MultiRevocationRequest) (*types.Transaction, error)

+ func (_EAS *EASSession) MultiRevokeByDelegation(multiDelegatedRequests []MultiDelegatedRevocationRequest) (*types.Transaction, error)

+ func (_EAS *EASSession) MultiRevokeOffchain(data [][32]byte) (*types.Transaction, error)

+ func (_EAS *EASSession) MultiTimestamp(data [][32]byte) (*types.Transaction, error)

+ func (_EAS *EASSession) Revoke(request RevocationRequest) (*types.Transaction, error)

+ func (_EAS *EASSession) RevokeByDelegation(delegatedRequest DelegatedRevocationRequest) (*types.Transaction, error)

+ func (_EAS *EASSession) RevokeOffchain(data [32]byte) (*types.Transaction, error)

+ func (_EAS *EASSession) Timestamp(data [32]byte) (*types.Transaction, error)

+ func (_EAS *EASSession) Version() (string, error)

+ type EASTimestamped struct

+ Data [32]byte

+ Raw types.Log

+ Timestamp uint64

+ type EASTimestampedIterator struct

+ Event *EASTimestamped

+ func (it *EASTimestampedIterator) Close() error

+ func (it *EASTimestampedIterator) Error() error

+ func (it *EASTimestampedIterator) Next() bool

+ type EASTransactor struct

+ func NewEASTransactor(address common.Address, transactor bind.ContractTransactor) (*EASTransactor, error)

+ func (_EAS *EASTransactor) Attest(opts *bind.TransactOpts, request AttestationRequest) (*types.Transaction, error)

+ func (_EAS *EASTransactor) AttestByDelegation(opts *bind.TransactOpts, delegatedRequest DelegatedAttestationRequest) (*types.Transaction, error)

+ func (_EAS *EASTransactor) IncreaseNonce(opts *bind.TransactOpts, newNonce *big.Int) (*types.Transaction, error)

+ func (_EAS *EASTransactor) MultiAttest(opts *bind.TransactOpts, multiRequests []MultiAttestationRequest) (*types.Transaction, error)

+ func (_EAS *EASTransactor) MultiAttestByDelegation(opts *bind.TransactOpts, ...) (*types.Transaction, error)

+ func (_EAS *EASTransactor) MultiRevoke(opts *bind.TransactOpts, multiRequests []MultiRevocationRequest) (*types.Transaction, error)

+ func (_EAS *EASTransactor) MultiRevokeByDelegation(opts *bind.TransactOpts, ...) (*types.Transaction, error)

+ func (_EAS *EASTransactor) MultiRevokeOffchain(opts *bind.TransactOpts, data [][32]byte) (*types.Transaction, error)

+ func (_EAS *EASTransactor) MultiTimestamp(opts *bind.TransactOpts, data [][32]byte) (*types.Transaction, error)

+ func (_EAS *EASTransactor) Revoke(opts *bind.TransactOpts, request RevocationRequest) (*types.Transaction, error)

+ func (_EAS *EASTransactor) RevokeByDelegation(opts *bind.TransactOpts, delegatedRequest DelegatedRevocationRequest) (*types.Transaction, error)

+ func (_EAS *EASTransactor) RevokeOffchain(opts *bind.TransactOpts, data [32]byte) (*types.Transaction, error)

+ func (_EAS *EASTransactor) Timestamp(opts *bind.TransactOpts, data [32]byte) (*types.Transaction, error)

+ type EASTransactorRaw struct

+ Contract *EASTransactor

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

+ func (_EAS *EASTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type EASTransactorSession struct

+ Contract *EASTransactor

+ TransactOpts bind.TransactOpts

+ func (_EAS *EASTransactorSession) Attest(request AttestationRequest) (*types.Transaction, error)

+ func (_EAS *EASTransactorSession) AttestByDelegation(delegatedRequest DelegatedAttestationRequest) (*types.Transaction, error)

+ func (_EAS *EASTransactorSession) IncreaseNonce(newNonce *big.Int) (*types.Transaction, error)

+ func (_EAS *EASTransactorSession) MultiAttest(multiRequests []MultiAttestationRequest) (*types.Transaction, error)

+ func (_EAS *EASTransactorSession) MultiAttestByDelegation(multiDelegatedRequests []MultiDelegatedAttestationRequest) (*types.Transaction, error)

+ func (_EAS *EASTransactorSession) MultiRevoke(multiRequests []MultiRevocationRequest) (*types.Transaction, error)

+ func (_EAS *EASTransactorSession) MultiRevokeByDelegation(multiDelegatedRequests []MultiDelegatedRevocationRequest) (*types.Transaction, error)

+ func (_EAS *EASTransactorSession) MultiRevokeOffchain(data [][32]byte) (*types.Transaction, error)

+ func (_EAS *EASTransactorSession) MultiTimestamp(data [][32]byte) (*types.Transaction, error)

+ func (_EAS *EASTransactorSession) Revoke(request RevocationRequest) (*types.Transaction, error)

+ func (_EAS *EASTransactorSession) RevokeByDelegation(delegatedRequest DelegatedRevocationRequest) (*types.Transaction, error)

+ func (_EAS *EASTransactorSession) RevokeOffchain(data [32]byte) (*types.Transaction, error)

+ func (_EAS *EASTransactorSession) Timestamp(data [32]byte) (*types.Transaction, error)

+ type ERC20VotesCheckpoint struct

+ FromBlock uint32

+ Votes *big.Int

+ type FaultDisputeGame struct

+ func DeployFaultDisputeGame(auth *bind.TransactOpts, backend bind.ContractBackend, _gameType uint8, ...) (common.Address, *types.Transaction, *FaultDisputeGame, error)

+ func NewFaultDisputeGame(address common.Address, backend bind.ContractBackend) (*FaultDisputeGame, error)

+ type FaultDisputeGameCaller struct

+ func NewFaultDisputeGameCaller(address common.Address, caller bind.ContractCaller) (*FaultDisputeGameCaller, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) ABSOLUTEPRESTATE(opts *bind.CallOpts) ([32]byte, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) BLOCKORACLE(opts *bind.CallOpts) (common.Address, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) BondManager(opts *bind.CallOpts) (common.Address, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) ClaimData(opts *bind.CallOpts, arg0 *big.Int) (struct{ ... }, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) ClaimDataLen(opts *bind.CallOpts) (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) CreatedAt(opts *bind.CallOpts) (uint64, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) ExtraData(opts *bind.CallOpts) ([]byte, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) GAMEDURATION(opts *bind.CallOpts) (uint64, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) GameData(opts *bind.CallOpts) (struct{ ... }, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) GameType(opts *bind.CallOpts) (uint8, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) L1BlockNumber(opts *bind.CallOpts) (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) L1Head(opts *bind.CallOpts) ([32]byte, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) L2BlockNumber(opts *bind.CallOpts) (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) L2OUTPUTORACLE(opts *bind.CallOpts) (common.Address, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) MAXGAMEDEPTH(opts *bind.CallOpts) (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) Proposals(opts *bind.CallOpts) (struct{ ... }, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) RootClaim(opts *bind.CallOpts) ([32]byte, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) Status(opts *bind.CallOpts) (uint8, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) VM(opts *bind.CallOpts) (common.Address, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) Version(opts *bind.CallOpts) (string, error)

+ type FaultDisputeGameCallerRaw struct

+ Contract *FaultDisputeGameCaller

+ func (_FaultDisputeGame *FaultDisputeGameCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type FaultDisputeGameCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *FaultDisputeGameCaller

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) ABSOLUTEPRESTATE() ([32]byte, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) BLOCKORACLE() (common.Address, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) BondManager() (common.Address, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) ClaimData(arg0 *big.Int) (struct{ ... }, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) ClaimDataLen() (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) CreatedAt() (uint64, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) ExtraData() ([]byte, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) GAMEDURATION() (uint64, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) GameData() (struct{ ... }, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) GameType() (uint8, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) L1BlockNumber() (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) L1Head() ([32]byte, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) L2BlockNumber() (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) L2OUTPUTORACLE() (common.Address, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) MAXGAMEDEPTH() (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) Proposals() (struct{ ... }, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) RootClaim() ([32]byte, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) Status() (uint8, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) VM() (common.Address, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) Version() (string, error)

+ type FaultDisputeGameFilterer struct

+ func NewFaultDisputeGameFilterer(address common.Address, filterer bind.ContractFilterer) (*FaultDisputeGameFilterer, error)

+ func (_FaultDisputeGame *FaultDisputeGameFilterer) FilterMove(opts *bind.FilterOpts, parentIndex []*big.Int, claim [][32]byte, ...) (*FaultDisputeGameMoveIterator, error)

+ func (_FaultDisputeGame *FaultDisputeGameFilterer) FilterResolved(opts *bind.FilterOpts, status []uint8) (*FaultDisputeGameResolvedIterator, error)

+ func (_FaultDisputeGame *FaultDisputeGameFilterer) ParseMove(log types.Log) (*FaultDisputeGameMove, error)

+ func (_FaultDisputeGame *FaultDisputeGameFilterer) ParseResolved(log types.Log) (*FaultDisputeGameResolved, error)

+ func (_FaultDisputeGame *FaultDisputeGameFilterer) WatchMove(opts *bind.WatchOpts, sink chan<- *FaultDisputeGameMove, ...) (event.Subscription, error)

+ func (_FaultDisputeGame *FaultDisputeGameFilterer) WatchResolved(opts *bind.WatchOpts, sink chan<- *FaultDisputeGameResolved, status []uint8) (event.Subscription, error)

+ type FaultDisputeGameMove struct

+ Claim [32]byte

+ Claimant common.Address

+ ParentIndex *big.Int

+ Raw types.Log

+ type FaultDisputeGameMoveIterator struct

+ Event *FaultDisputeGameMove

+ func (it *FaultDisputeGameMoveIterator) Close() error

+ func (it *FaultDisputeGameMoveIterator) Error() error

+ func (it *FaultDisputeGameMoveIterator) Next() bool

+ type FaultDisputeGameRaw struct

+ Contract *FaultDisputeGame

+ func (_FaultDisputeGame *FaultDisputeGameRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_FaultDisputeGame *FaultDisputeGameRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type FaultDisputeGameResolved struct

+ Raw types.Log

+ Status uint8

+ type FaultDisputeGameResolvedIterator struct

+ Event *FaultDisputeGameResolved

+ func (it *FaultDisputeGameResolvedIterator) Close() error

+ func (it *FaultDisputeGameResolvedIterator) Error() error

+ func (it *FaultDisputeGameResolvedIterator) Next() bool

+ type FaultDisputeGameSession struct

+ CallOpts bind.CallOpts

+ Contract *FaultDisputeGame

+ TransactOpts bind.TransactOpts

+ func (_FaultDisputeGame *FaultDisputeGameSession) ABSOLUTEPRESTATE() ([32]byte, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) AddLocalData(_ident *big.Int, _l2BlockNumber *big.Int, _partOffset *big.Int) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) Attack(_parentIndex *big.Int, _claim [32]byte) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) BLOCKORACLE() (common.Address, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) BondManager() (common.Address, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) ClaimData(arg0 *big.Int) (struct{ ... }, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) ClaimDataLen() (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) CreatedAt() (uint64, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) Defend(_parentIndex *big.Int, _claim [32]byte) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) ExtraData() ([]byte, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) GAMEDURATION() (uint64, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) GameData() (struct{ ... }, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) GameType() (uint8, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) Initialize() (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) L1BlockNumber() (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) L1Head() ([32]byte, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) L2BlockNumber() (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) L2OUTPUTORACLE() (common.Address, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) MAXGAMEDEPTH() (*big.Int, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) Move(_challengeIndex *big.Int, _claim [32]byte, _isAttack bool) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) Proposals() (struct{ ... }, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) Resolve() (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) ResolveClaim(_claimIndex *big.Int) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) RootClaim() ([32]byte, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) Status() (uint8, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) Step(_claimIndex *big.Int, _isAttack bool, _stateData []byte, _proof []byte) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) VM() (common.Address, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) Version() (string, error)

+ type FaultDisputeGameTransactor struct

+ func NewFaultDisputeGameTransactor(address common.Address, transactor bind.ContractTransactor) (*FaultDisputeGameTransactor, error)

+ func (_FaultDisputeGame *FaultDisputeGameTransactor) AddLocalData(opts *bind.TransactOpts, _ident *big.Int, _l2BlockNumber *big.Int, ...) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameTransactor) Attack(opts *bind.TransactOpts, _parentIndex *big.Int, _claim [32]byte) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameTransactor) Defend(opts *bind.TransactOpts, _parentIndex *big.Int, _claim [32]byte) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameTransactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameTransactor) Move(opts *bind.TransactOpts, _challengeIndex *big.Int, _claim [32]byte, ...) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameTransactor) Resolve(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameTransactor) ResolveClaim(opts *bind.TransactOpts, _claimIndex *big.Int) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameTransactor) Step(opts *bind.TransactOpts, _claimIndex *big.Int, _isAttack bool, ...) (*types.Transaction, error)

+ type FaultDisputeGameTransactorRaw struct

+ Contract *FaultDisputeGameTransactor

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

+ func (_FaultDisputeGame *FaultDisputeGameTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type FaultDisputeGameTransactorSession struct

+ Contract *FaultDisputeGameTransactor

+ TransactOpts bind.TransactOpts

+ func (_FaultDisputeGame *FaultDisputeGameTransactorSession) AddLocalData(_ident *big.Int, _l2BlockNumber *big.Int, _partOffset *big.Int) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameTransactorSession) Attack(_parentIndex *big.Int, _claim [32]byte) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameTransactorSession) Defend(_parentIndex *big.Int, _claim [32]byte) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameTransactorSession) Initialize() (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameTransactorSession) Move(_challengeIndex *big.Int, _claim [32]byte, _isAttack bool) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameTransactorSession) Resolve() (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameTransactorSession) ResolveClaim(_claimIndex *big.Int) (*types.Transaction, error)

+ func (_FaultDisputeGame *FaultDisputeGameTransactorSession) Step(_claimIndex *big.Int, _isAttack bool, _stateData []byte, _proof []byte) (*types.Transaction, error)

type GasPriceOracleCaller

+ func (_GasPriceOracle *GasPriceOracleCaller) Decimals(opts *bind.CallOpts) (*big.Int, error)

type GasPriceOracleCallerSession

+ func (_GasPriceOracle *GasPriceOracleCallerSession) Decimals() (*big.Int, error)

type GasPriceOracleSession

+ func (_GasPriceOracle *GasPriceOracleSession) Decimals() (*big.Int, error)

+ type GovernanceToken struct

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

+ func NewGovernanceToken(address common.Address, backend bind.ContractBackend) (*GovernanceToken, error)

+ type GovernanceTokenApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type GovernanceTokenApprovalIterator struct

+ Event *GovernanceTokenApproval

+ func (it *GovernanceTokenApprovalIterator) Close() error

+ func (it *GovernanceTokenApprovalIterator) Error() error

+ func (it *GovernanceTokenApprovalIterator) Next() bool

+ type GovernanceTokenCaller struct

+ func NewGovernanceTokenCaller(address common.Address, caller bind.ContractCaller) (*GovernanceTokenCaller, error)

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

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

+ func (_GovernanceToken *GovernanceTokenCaller) Checkpoints(opts *bind.CallOpts, account common.Address, pos uint32) (ERC20VotesCheckpoint, error)

+ func (_GovernanceToken *GovernanceTokenCaller) DOMAINSEPARATOR(opts *bind.CallOpts) ([32]byte, error)

+ func (_GovernanceToken *GovernanceTokenCaller) Decimals(opts *bind.CallOpts) (uint8, error)

+ func (_GovernanceToken *GovernanceTokenCaller) Delegates(opts *bind.CallOpts, account common.Address) (common.Address, error)

+ func (_GovernanceToken *GovernanceTokenCaller) GetPastTotalSupply(opts *bind.CallOpts, blockNumber *big.Int) (*big.Int, error)

+ func (_GovernanceToken *GovernanceTokenCaller) GetPastVotes(opts *bind.CallOpts, account common.Address, blockNumber *big.Int) (*big.Int, error)

+ func (_GovernanceToken *GovernanceTokenCaller) GetVotes(opts *bind.CallOpts, account common.Address) (*big.Int, error)

+ func (_GovernanceToken *GovernanceTokenCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_GovernanceToken *GovernanceTokenCaller) Nonces(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_GovernanceToken *GovernanceTokenCaller) NumCheckpoints(opts *bind.CallOpts, account common.Address) (uint32, error)

+ func (_GovernanceToken *GovernanceTokenCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_GovernanceToken *GovernanceTokenCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_GovernanceToken *GovernanceTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type GovernanceTokenCallerRaw struct

+ Contract *GovernanceTokenCaller

+ func (_GovernanceToken *GovernanceTokenCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type GovernanceTokenCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *GovernanceTokenCaller

+ func (_GovernanceToken *GovernanceTokenCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_GovernanceToken *GovernanceTokenCallerSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_GovernanceToken *GovernanceTokenCallerSession) Checkpoints(account common.Address, pos uint32) (ERC20VotesCheckpoint, error)

+ func (_GovernanceToken *GovernanceTokenCallerSession) DOMAINSEPARATOR() ([32]byte, error)

+ func (_GovernanceToken *GovernanceTokenCallerSession) Decimals() (uint8, error)

+ func (_GovernanceToken *GovernanceTokenCallerSession) Delegates(account common.Address) (common.Address, error)

+ func (_GovernanceToken *GovernanceTokenCallerSession) GetPastTotalSupply(blockNumber *big.Int) (*big.Int, error)

+ func (_GovernanceToken *GovernanceTokenCallerSession) GetPastVotes(account common.Address, blockNumber *big.Int) (*big.Int, error)

+ func (_GovernanceToken *GovernanceTokenCallerSession) GetVotes(account common.Address) (*big.Int, error)

+ func (_GovernanceToken *GovernanceTokenCallerSession) Name() (string, error)

+ func (_GovernanceToken *GovernanceTokenCallerSession) Nonces(owner common.Address) (*big.Int, error)

+ func (_GovernanceToken *GovernanceTokenCallerSession) NumCheckpoints(account common.Address) (uint32, error)

+ func (_GovernanceToken *GovernanceTokenCallerSession) Owner() (common.Address, error)

+ func (_GovernanceToken *GovernanceTokenCallerSession) Symbol() (string, error)

+ func (_GovernanceToken *GovernanceTokenCallerSession) TotalSupply() (*big.Int, error)

+ type GovernanceTokenDelegateChanged struct

+ Delegator common.Address

+ FromDelegate common.Address

+ Raw types.Log

+ ToDelegate common.Address

+ type GovernanceTokenDelegateChangedIterator struct

+ Event *GovernanceTokenDelegateChanged

+ func (it *GovernanceTokenDelegateChangedIterator) Close() error

+ func (it *GovernanceTokenDelegateChangedIterator) Error() error

+ func (it *GovernanceTokenDelegateChangedIterator) Next() bool

+ type GovernanceTokenDelegateVotesChanged struct

+ Delegate common.Address

+ NewBalance *big.Int

+ PreviousBalance *big.Int

+ Raw types.Log

+ type GovernanceTokenDelegateVotesChangedIterator struct

+ Event *GovernanceTokenDelegateVotesChanged

+ func (it *GovernanceTokenDelegateVotesChangedIterator) Close() error

+ func (it *GovernanceTokenDelegateVotesChangedIterator) Error() error

+ func (it *GovernanceTokenDelegateVotesChangedIterator) Next() bool

+ type GovernanceTokenFilterer struct

+ func NewGovernanceTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*GovernanceTokenFilterer, error)

+ func (_GovernanceToken *GovernanceTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*GovernanceTokenApprovalIterator, error)

+ func (_GovernanceToken *GovernanceTokenFilterer) FilterDelegateChanged(opts *bind.FilterOpts, delegator []common.Address, ...) (*GovernanceTokenDelegateChangedIterator, error)

+ func (_GovernanceToken *GovernanceTokenFilterer) FilterDelegateVotesChanged(opts *bind.FilterOpts, delegate []common.Address) (*GovernanceTokenDelegateVotesChangedIterator, error)

+ func (_GovernanceToken *GovernanceTokenFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*GovernanceTokenOwnershipTransferredIterator, error)

+ func (_GovernanceToken *GovernanceTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*GovernanceTokenTransferIterator, error)

+ func (_GovernanceToken *GovernanceTokenFilterer) ParseApproval(log types.Log) (*GovernanceTokenApproval, error)

+ func (_GovernanceToken *GovernanceTokenFilterer) ParseDelegateChanged(log types.Log) (*GovernanceTokenDelegateChanged, error)

+ func (_GovernanceToken *GovernanceTokenFilterer) ParseDelegateVotesChanged(log types.Log) (*GovernanceTokenDelegateVotesChanged, error)

+ func (_GovernanceToken *GovernanceTokenFilterer) ParseOwnershipTransferred(log types.Log) (*GovernanceTokenOwnershipTransferred, error)

+ func (_GovernanceToken *GovernanceTokenFilterer) ParseTransfer(log types.Log) (*GovernanceTokenTransfer, error)

+ func (_GovernanceToken *GovernanceTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *GovernanceTokenApproval, ...) (event.Subscription, error)

+ func (_GovernanceToken *GovernanceTokenFilterer) WatchDelegateChanged(opts *bind.WatchOpts, sink chan<- *GovernanceTokenDelegateChanged, ...) (event.Subscription, error)

+ func (_GovernanceToken *GovernanceTokenFilterer) WatchDelegateVotesChanged(opts *bind.WatchOpts, sink chan<- *GovernanceTokenDelegateVotesChanged, ...) (event.Subscription, error)

+ func (_GovernanceToken *GovernanceTokenFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *GovernanceTokenOwnershipTransferred, ...) (event.Subscription, error)

+ func (_GovernanceToken *GovernanceTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *GovernanceTokenTransfer, ...) (event.Subscription, error)

+ type GovernanceTokenOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type GovernanceTokenOwnershipTransferredIterator struct

+ Event *GovernanceTokenOwnershipTransferred

+ func (it *GovernanceTokenOwnershipTransferredIterator) Close() error

+ func (it *GovernanceTokenOwnershipTransferredIterator) Error() error

+ func (it *GovernanceTokenOwnershipTransferredIterator) Next() bool

+ type GovernanceTokenRaw struct

+ Contract *GovernanceToken

+ func (_GovernanceToken *GovernanceTokenRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_GovernanceToken *GovernanceTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type GovernanceTokenSession struct

+ CallOpts bind.CallOpts

+ Contract *GovernanceToken

+ TransactOpts bind.TransactOpts

+ func (_GovernanceToken *GovernanceTokenSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

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

+ func (_GovernanceToken *GovernanceTokenSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_GovernanceToken *GovernanceTokenSession) Burn(amount *big.Int) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenSession) Checkpoints(account common.Address, pos uint32) (ERC20VotesCheckpoint, error)

+ func (_GovernanceToken *GovernanceTokenSession) DOMAINSEPARATOR() ([32]byte, error)

+ func (_GovernanceToken *GovernanceTokenSession) Decimals() (uint8, error)

+ func (_GovernanceToken *GovernanceTokenSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenSession) Delegate(delegatee common.Address) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenSession) DelegateBySig(delegatee common.Address, nonce *big.Int, expiry *big.Int, v uint8, r [32]byte, ...) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenSession) Delegates(account common.Address) (common.Address, error)

+ func (_GovernanceToken *GovernanceTokenSession) GetPastTotalSupply(blockNumber *big.Int) (*big.Int, error)

+ func (_GovernanceToken *GovernanceTokenSession) GetPastVotes(account common.Address, blockNumber *big.Int) (*big.Int, error)

+ func (_GovernanceToken *GovernanceTokenSession) GetVotes(account common.Address) (*big.Int, error)

+ func (_GovernanceToken *GovernanceTokenSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenSession) Mint(_account common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenSession) Name() (string, error)

+ func (_GovernanceToken *GovernanceTokenSession) Nonces(owner common.Address) (*big.Int, error)

+ func (_GovernanceToken *GovernanceTokenSession) NumCheckpoints(account common.Address) (uint32, error)

+ func (_GovernanceToken *GovernanceTokenSession) Owner() (common.Address, error)

+ func (_GovernanceToken *GovernanceTokenSession) Permit(owner common.Address, spender common.Address, value *big.Int, ...) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenSession) RenounceOwnership() (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenSession) Symbol() (string, error)

+ func (_GovernanceToken *GovernanceTokenSession) TotalSupply() (*big.Int, error)

+ func (_GovernanceToken *GovernanceTokenSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type GovernanceTokenTransactor struct

+ func NewGovernanceTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*GovernanceTokenTransactor, error)

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

+ func (_GovernanceToken *GovernanceTokenTransactor) Burn(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactor) BurnFrom(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactor) Delegate(opts *bind.TransactOpts, delegatee common.Address) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactor) DelegateBySig(opts *bind.TransactOpts, delegatee common.Address, nonce *big.Int, ...) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactor) Mint(opts *bind.TransactOpts, _account common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactor) Permit(opts *bind.TransactOpts, owner common.Address, spender common.Address, ...) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactor) Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type GovernanceTokenTransactorRaw struct

+ Contract *GovernanceTokenTransactor

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

+ func (_GovernanceToken *GovernanceTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type GovernanceTokenTransactorSession struct

+ Contract *GovernanceTokenTransactor

+ TransactOpts bind.TransactOpts

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

+ func (_GovernanceToken *GovernanceTokenTransactorSession) Burn(amount *big.Int) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactorSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactorSession) Delegate(delegatee common.Address) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactorSession) DelegateBySig(delegatee common.Address, nonce *big.Int, expiry *big.Int, v uint8, r [32]byte, ...) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactorSession) Mint(_account common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactorSession) Permit(owner common.Address, spender common.Address, value *big.Int, ...) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactorSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactorSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_GovernanceToken *GovernanceTokenTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type GovernanceTokenTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type GovernanceTokenTransferIterator struct

+ Event *GovernanceTokenTransfer

+ func (it *GovernanceTokenTransferIterator) Close() error

+ func (it *GovernanceTokenTransferIterator) Error() error

+ func (it *GovernanceTokenTransferIterator) Next() bool

+ type IFaultDisputeGameOutputProposal struct

+ Index *big.Int

+ L2BlockNumber *big.Int

+ OutputRoot [32]byte

+ type ISemver struct

+ func NewISemver(address common.Address, backend bind.ContractBackend) (*ISemver, error)

+ type ISemverCaller struct

+ func NewISemverCaller(address common.Address, caller bind.ContractCaller) (*ISemverCaller, error)

+ func (_ISemver *ISemverCaller) Version(opts *bind.CallOpts) (string, error)

+ type ISemverCallerRaw struct

+ Contract *ISemverCaller

+ func (_ISemver *ISemverCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type ISemverCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ISemverCaller

+ func (_ISemver *ISemverCallerSession) Version() (string, error)

+ type ISemverFilterer struct

+ func NewISemverFilterer(address common.Address, filterer bind.ContractFilterer) (*ISemverFilterer, error)

+ type ISemverRaw struct

+ Contract *ISemver

+ func (_ISemver *ISemverRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_ISemver *ISemverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ISemverSession struct

+ CallOpts bind.CallOpts

+ Contract *ISemver

+ TransactOpts bind.TransactOpts

+ func (_ISemver *ISemverSession) Version() (string, error)

+ type ISemverTransactor struct

+ func NewISemverTransactor(address common.Address, transactor bind.ContractTransactor) (*ISemverTransactor, error)

+ type ISemverTransactorRaw struct

+ Contract *ISemverTransactor

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

+ func (_ISemver *ISemverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ISemverTransactorSession struct

+ Contract *ISemverTransactor

+ TransactOpts bind.TransactOpts

+ type L1BlockNumber struct

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

+ func NewL1BlockNumber(address common.Address, backend bind.ContractBackend) (*L1BlockNumber, error)

+ type L1BlockNumberCaller struct

+ func NewL1BlockNumberCaller(address common.Address, caller bind.ContractCaller) (*L1BlockNumberCaller, error)

+ func (_L1BlockNumber *L1BlockNumberCaller) GetL1BlockNumber(opts *bind.CallOpts) (*big.Int, error)

+ func (_L1BlockNumber *L1BlockNumberCaller) Version(opts *bind.CallOpts) (string, error)

+ type L1BlockNumberCallerRaw struct

+ Contract *L1BlockNumberCaller

+ func (_L1BlockNumber *L1BlockNumberCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type L1BlockNumberCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *L1BlockNumberCaller

+ func (_L1BlockNumber *L1BlockNumberCallerSession) GetL1BlockNumber() (*big.Int, error)

+ func (_L1BlockNumber *L1BlockNumberCallerSession) Version() (string, error)

+ type L1BlockNumberFilterer struct

+ func NewL1BlockNumberFilterer(address common.Address, filterer bind.ContractFilterer) (*L1BlockNumberFilterer, error)

+ type L1BlockNumberRaw struct

+ Contract *L1BlockNumber

+ func (_L1BlockNumber *L1BlockNumberRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_L1BlockNumber *L1BlockNumberRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L1BlockNumberSession struct

+ CallOpts bind.CallOpts

+ Contract *L1BlockNumber

+ TransactOpts bind.TransactOpts

+ func (_L1BlockNumber *L1BlockNumberSession) Fallback(calldata []byte) (*types.Transaction, error)

+ func (_L1BlockNumber *L1BlockNumberSession) GetL1BlockNumber() (*big.Int, error)

+ func (_L1BlockNumber *L1BlockNumberSession) Receive() (*types.Transaction, error)

+ func (_L1BlockNumber *L1BlockNumberSession) Version() (string, error)

+ type L1BlockNumberTransactor struct

+ func NewL1BlockNumberTransactor(address common.Address, transactor bind.ContractTransactor) (*L1BlockNumberTransactor, error)

+ func (_L1BlockNumber *L1BlockNumberTransactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error)

+ func (_L1BlockNumber *L1BlockNumberTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L1BlockNumberTransactorRaw struct

+ Contract *L1BlockNumberTransactor

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

+ func (_L1BlockNumber *L1BlockNumberTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L1BlockNumberTransactorSession struct

+ Contract *L1BlockNumberTransactor

+ TransactOpts bind.TransactOpts

+ func (_L1BlockNumber *L1BlockNumberTransactorSession) Fallback(calldata []byte) (*types.Transaction, error)

+ func (_L1BlockNumber *L1BlockNumberTransactorSession) Receive() (*types.Transaction, error)

type L1CrossDomainMessengerCaller

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCaller) Portal(opts *bind.CallOpts) (common.Address, error)

type L1CrossDomainMessengerCallerSession

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) Portal() (common.Address, error)

type L1CrossDomainMessengerFilterer

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) FilterSentMessageExtension1(opts *bind.FilterOpts, sender []common.Address) (*L1CrossDomainMessengerSentMessageExtension1Iterator, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) ParseSentMessageExtension1(log types.Log) (*L1CrossDomainMessengerSentMessageExtension1, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) WatchSentMessageExtension1(opts *bind.WatchOpts, sink chan<- *L1CrossDomainMessengerSentMessageExtension1, ...) (event.Subscription, error)

+ type L1CrossDomainMessengerSentMessageExtension1 struct

+ Raw types.Log

+ Sender common.Address

+ Value *big.Int

+ type L1CrossDomainMessengerSentMessageExtension1Iterator struct

+ Event *L1CrossDomainMessengerSentMessageExtension1

+ func (it *L1CrossDomainMessengerSentMessageExtension1Iterator) Close() error

+ func (it *L1CrossDomainMessengerSentMessageExtension1Iterator) Error() error

+ func (it *L1CrossDomainMessengerSentMessageExtension1Iterator) Next() bool

type L1CrossDomainMessengerSession

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) Portal() (common.Address, error)

type L1ERC721BridgeCaller

+ func (_L1ERC721Bridge *L1ERC721BridgeCaller) Messenger(opts *bind.CallOpts) (common.Address, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeCaller) OtherBridge(opts *bind.CallOpts) (common.Address, error)

type L1ERC721BridgeCallerSession

+ func (_L1ERC721Bridge *L1ERC721BridgeCallerSession) Messenger() (common.Address, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeCallerSession) OtherBridge() (common.Address, error)

type L1ERC721BridgeFilterer

+ func (_L1ERC721Bridge *L1ERC721BridgeFilterer) FilterInitialized(opts *bind.FilterOpts) (*L1ERC721BridgeInitializedIterator, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeFilterer) ParseInitialized(log types.Log) (*L1ERC721BridgeInitialized, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *L1ERC721BridgeInitialized) (event.Subscription, error)

+ type L1ERC721BridgeInitialized struct

+ Raw types.Log

+ Version uint8

+ type L1ERC721BridgeInitializedIterator struct

+ Event *L1ERC721BridgeInitialized

+ func (it *L1ERC721BridgeInitializedIterator) Close() error

+ func (it *L1ERC721BridgeInitializedIterator) Error() error

+ func (it *L1ERC721BridgeInitializedIterator) Next() bool

type L1ERC721BridgeSession

+ func (_L1ERC721Bridge *L1ERC721BridgeSession) Initialize(_messenger common.Address) (*types.Transaction, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeSession) Messenger() (common.Address, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeSession) OtherBridge() (common.Address, error)

type L1ERC721BridgeTransactor

+ func (_L1ERC721Bridge *L1ERC721BridgeTransactor) Initialize(opts *bind.TransactOpts, _messenger common.Address) (*types.Transaction, error)

type L1ERC721BridgeTransactorSession

+ func (_L1ERC721Bridge *L1ERC721BridgeTransactorSession) Initialize(_messenger common.Address) (*types.Transaction, error)

type L1FeeVaultCaller

+ func (_L1FeeVault *L1FeeVaultCaller) WITHDRAWALNETWORK(opts *bind.CallOpts) (uint8, error)

type L1FeeVaultCallerSession

+ func (_L1FeeVault *L1FeeVaultCallerSession) WITHDRAWALNETWORK() (uint8, error)

type L1FeeVaultFilterer

+ func (_L1FeeVault *L1FeeVaultFilterer) FilterWithdrawal0(opts *bind.FilterOpts) (*L1FeeVaultWithdrawal0Iterator, error)

+ func (_L1FeeVault *L1FeeVaultFilterer) ParseWithdrawal0(log types.Log) (*L1FeeVaultWithdrawal0, error)

+ func (_L1FeeVault *L1FeeVaultFilterer) WatchWithdrawal0(opts *bind.WatchOpts, sink chan<- *L1FeeVaultWithdrawal0) (event.Subscription, error)

type L1FeeVaultSession

+ func (_L1FeeVault *L1FeeVaultSession) WITHDRAWALNETWORK() (uint8, error)

+ type L1FeeVaultWithdrawal0 struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ WithdrawalNetwork uint8

+ type L1FeeVaultWithdrawal0Iterator struct

+ Event *L1FeeVaultWithdrawal0

+ func (it *L1FeeVaultWithdrawal0Iterator) Close() error

+ func (it *L1FeeVaultWithdrawal0Iterator) Error() error

+ func (it *L1FeeVaultWithdrawal0Iterator) Next() bool

type L1StandardBridgeCaller

+ func (_L1StandardBridge *L1StandardBridgeCaller) L2TokenBridge(opts *bind.CallOpts) (common.Address, error)

+ func (_L1StandardBridge *L1StandardBridgeCaller) Messenger(opts *bind.CallOpts) (common.Address, error)

+ func (_L1StandardBridge *L1StandardBridgeCaller) OtherBridge(opts *bind.CallOpts) (common.Address, error)

type L1StandardBridgeCallerSession

+ func (_L1StandardBridge *L1StandardBridgeCallerSession) L2TokenBridge() (common.Address, error)

+ func (_L1StandardBridge *L1StandardBridgeCallerSession) Messenger() (common.Address, error)

+ func (_L1StandardBridge *L1StandardBridgeCallerSession) OtherBridge() (common.Address, error)

+ type L1StandardBridgeERC20DepositInitiated struct

+ Amount *big.Int

+ ExtraData []byte

+ From common.Address

+ L1Token common.Address

+ L2Token common.Address

+ Raw types.Log

+ To common.Address

+ type L1StandardBridgeERC20DepositInitiatedIterator struct

+ Event *L1StandardBridgeERC20DepositInitiated

+ func (it *L1StandardBridgeERC20DepositInitiatedIterator) Close() error

+ func (it *L1StandardBridgeERC20DepositInitiatedIterator) Error() error

+ func (it *L1StandardBridgeERC20DepositInitiatedIterator) Next() bool

+ type L1StandardBridgeERC20WithdrawalFinalized struct

+ Amount *big.Int

+ ExtraData []byte

+ From common.Address

+ L1Token common.Address

+ L2Token common.Address

+ Raw types.Log

+ To common.Address

+ type L1StandardBridgeERC20WithdrawalFinalizedIterator struct

+ Event *L1StandardBridgeERC20WithdrawalFinalized

+ func (it *L1StandardBridgeERC20WithdrawalFinalizedIterator) Close() error

+ func (it *L1StandardBridgeERC20WithdrawalFinalizedIterator) Error() error

+ func (it *L1StandardBridgeERC20WithdrawalFinalizedIterator) Next() bool

+ type L1StandardBridgeETHDepositInitiated struct

+ Amount *big.Int

+ ExtraData []byte

+ From common.Address

+ Raw types.Log

+ To common.Address

+ type L1StandardBridgeETHDepositInitiatedIterator struct

+ Event *L1StandardBridgeETHDepositInitiated

+ func (it *L1StandardBridgeETHDepositInitiatedIterator) Close() error

+ func (it *L1StandardBridgeETHDepositInitiatedIterator) Error() error

+ func (it *L1StandardBridgeETHDepositInitiatedIterator) Next() bool

+ type L1StandardBridgeETHWithdrawalFinalized struct

+ Amount *big.Int

+ ExtraData []byte

+ From common.Address

+ Raw types.Log

+ To common.Address

+ type L1StandardBridgeETHWithdrawalFinalizedIterator struct

+ Event *L1StandardBridgeETHWithdrawalFinalized

+ func (it *L1StandardBridgeETHWithdrawalFinalizedIterator) Close() error

+ func (it *L1StandardBridgeETHWithdrawalFinalizedIterator) Error() error

+ func (it *L1StandardBridgeETHWithdrawalFinalizedIterator) Next() bool

type L1StandardBridgeFilterer

+ func (_L1StandardBridge *L1StandardBridgeFilterer) FilterERC20DepositInitiated(opts *bind.FilterOpts, l1Token []common.Address, l2Token []common.Address, ...) (*L1StandardBridgeERC20DepositInitiatedIterator, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) FilterERC20WithdrawalFinalized(opts *bind.FilterOpts, l1Token []common.Address, l2Token []common.Address, ...) (*L1StandardBridgeERC20WithdrawalFinalizedIterator, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) FilterETHDepositInitiated(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*L1StandardBridgeETHDepositInitiatedIterator, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) FilterETHWithdrawalFinalized(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*L1StandardBridgeETHWithdrawalFinalizedIterator, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) FilterInitialized(opts *bind.FilterOpts) (*L1StandardBridgeInitializedIterator, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) ParseERC20DepositInitiated(log types.Log) (*L1StandardBridgeERC20DepositInitiated, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) ParseERC20WithdrawalFinalized(log types.Log) (*L1StandardBridgeERC20WithdrawalFinalized, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) ParseETHDepositInitiated(log types.Log) (*L1StandardBridgeETHDepositInitiated, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) ParseETHWithdrawalFinalized(log types.Log) (*L1StandardBridgeETHWithdrawalFinalized, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) ParseInitialized(log types.Log) (*L1StandardBridgeInitialized, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) WatchERC20DepositInitiated(opts *bind.WatchOpts, sink chan<- *L1StandardBridgeERC20DepositInitiated, ...) (event.Subscription, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) WatchERC20WithdrawalFinalized(opts *bind.WatchOpts, sink chan<- *L1StandardBridgeERC20WithdrawalFinalized, ...) (event.Subscription, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) WatchETHDepositInitiated(opts *bind.WatchOpts, sink chan<- *L1StandardBridgeETHDepositInitiated, ...) (event.Subscription, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) WatchETHWithdrawalFinalized(opts *bind.WatchOpts, sink chan<- *L1StandardBridgeETHWithdrawalFinalized, ...) (event.Subscription, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *L1StandardBridgeInitialized) (event.Subscription, error)

+ type L1StandardBridgeInitialized struct

+ Raw types.Log

+ Version uint8

+ type L1StandardBridgeInitializedIterator struct

+ Event *L1StandardBridgeInitialized

+ func (it *L1StandardBridgeInitializedIterator) Close() error

+ func (it *L1StandardBridgeInitializedIterator) Error() error

+ func (it *L1StandardBridgeInitializedIterator) Next() bool

type L1StandardBridgeSession

+ func (_L1StandardBridge *L1StandardBridgeSession) DepositERC20(_l1Token common.Address, _l2Token common.Address, _amount *big.Int, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) DepositERC20To(_l1Token common.Address, _l2Token common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) DepositETH(_minGasLimit uint32, _extraData []byte) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) DepositETHTo(_to common.Address, _minGasLimit uint32, _extraData []byte) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) FinalizeERC20Withdrawal(_l1Token common.Address, _l2Token common.Address, _from common.Address, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) FinalizeETHWithdrawal(_from common.Address, _to common.Address, _amount *big.Int, _extraData []byte) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) Initialize(_messenger common.Address) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) L2TokenBridge() (common.Address, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) Messenger() (common.Address, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) OtherBridge() (common.Address, error)

type L1StandardBridgeTransactor

+ func (_L1StandardBridge *L1StandardBridgeTransactor) DepositERC20(opts *bind.TransactOpts, _l1Token common.Address, _l2Token common.Address, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactor) DepositERC20To(opts *bind.TransactOpts, _l1Token common.Address, _l2Token common.Address, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactor) DepositETH(opts *bind.TransactOpts, _minGasLimit uint32, _extraData []byte) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactor) DepositETHTo(opts *bind.TransactOpts, _to common.Address, _minGasLimit uint32, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactor) FinalizeERC20Withdrawal(opts *bind.TransactOpts, _l1Token common.Address, _l2Token common.Address, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactor) FinalizeETHWithdrawal(opts *bind.TransactOpts, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactor) Initialize(opts *bind.TransactOpts, _messenger common.Address) (*types.Transaction, error)

type L1StandardBridgeTransactorSession

+ func (_L1StandardBridge *L1StandardBridgeTransactorSession) DepositERC20(_l1Token common.Address, _l2Token common.Address, _amount *big.Int, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactorSession) DepositERC20To(_l1Token common.Address, _l2Token common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactorSession) DepositETH(_minGasLimit uint32, _extraData []byte) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactorSession) DepositETHTo(_to common.Address, _minGasLimit uint32, _extraData []byte) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactorSession) FinalizeERC20Withdrawal(_l1Token common.Address, _l2Token common.Address, _from common.Address, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactorSession) FinalizeETHWithdrawal(_from common.Address, _to common.Address, _amount *big.Int, _extraData []byte) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactorSession) Initialize(_messenger common.Address) (*types.Transaction, error)

type L2CrossDomainMessengerCaller

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) L1CrossDomainMessenger(opts *bind.CallOpts) (common.Address, error)

type L2CrossDomainMessengerCallerSession

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) L1CrossDomainMessenger() (common.Address, error)

type L2CrossDomainMessengerFilterer

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) FilterSentMessageExtension1(opts *bind.FilterOpts, sender []common.Address) (*L2CrossDomainMessengerSentMessageExtension1Iterator, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) ParseSentMessageExtension1(log types.Log) (*L2CrossDomainMessengerSentMessageExtension1, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) WatchSentMessageExtension1(opts *bind.WatchOpts, sink chan<- *L2CrossDomainMessengerSentMessageExtension1, ...) (event.Subscription, error)

+ type L2CrossDomainMessengerSentMessageExtension1 struct

+ Raw types.Log

+ Sender common.Address

+ Value *big.Int

+ type L2CrossDomainMessengerSentMessageExtension1Iterator struct

+ Event *L2CrossDomainMessengerSentMessageExtension1

+ func (it *L2CrossDomainMessengerSentMessageExtension1Iterator) Close() error

+ func (it *L2CrossDomainMessengerSentMessageExtension1Iterator) Error() error

+ func (it *L2CrossDomainMessengerSentMessageExtension1Iterator) Next() bool

type L2CrossDomainMessengerSession

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) L1CrossDomainMessenger() (common.Address, error)

type L2ERC721BridgeCaller

+ func (_L2ERC721Bridge *L2ERC721BridgeCaller) Messenger(opts *bind.CallOpts) (common.Address, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeCaller) OtherBridge(opts *bind.CallOpts) (common.Address, error)

type L2ERC721BridgeCallerSession

+ func (_L2ERC721Bridge *L2ERC721BridgeCallerSession) Messenger() (common.Address, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeCallerSession) OtherBridge() (common.Address, error)

type L2ERC721BridgeFilterer

+ func (_L2ERC721Bridge *L2ERC721BridgeFilterer) FilterInitialized(opts *bind.FilterOpts) (*L2ERC721BridgeInitializedIterator, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeFilterer) ParseInitialized(log types.Log) (*L2ERC721BridgeInitialized, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *L2ERC721BridgeInitialized) (event.Subscription, error)

+ type L2ERC721BridgeInitialized struct

+ Raw types.Log

+ Version uint8

+ type L2ERC721BridgeInitializedIterator struct

+ Event *L2ERC721BridgeInitialized

+ func (it *L2ERC721BridgeInitializedIterator) Close() error

+ func (it *L2ERC721BridgeInitializedIterator) Error() error

+ func (it *L2ERC721BridgeInitializedIterator) Next() bool

type L2ERC721BridgeSession

+ func (_L2ERC721Bridge *L2ERC721BridgeSession) Initialize() (*types.Transaction, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeSession) Messenger() (common.Address, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeSession) OtherBridge() (common.Address, error)

type L2ERC721BridgeTransactor

+ func (_L2ERC721Bridge *L2ERC721BridgeTransactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error)

type L2ERC721BridgeTransactorSession

+ func (_L2ERC721Bridge *L2ERC721BridgeTransactorSession) Initialize() (*types.Transaction, error)

type L2OutputOracleCaller

+ func (_L2OutputOracle *L2OutputOracleCaller) CHALLENGER(opts *bind.CallOpts) (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) Challenger(opts *bind.CallOpts) (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) FinalizationPeriodSeconds(opts *bind.CallOpts) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) L2BlockTime(opts *bind.CallOpts) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) PROPOSER(opts *bind.CallOpts) (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) Proposer(opts *bind.CallOpts) (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) SubmissionInterval(opts *bind.CallOpts) (*big.Int, error)

type L2OutputOracleCallerSession

+ func (_L2OutputOracle *L2OutputOracleCallerSession) CHALLENGER() (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) Challenger() (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) FinalizationPeriodSeconds() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) L2BlockTime() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) PROPOSER() (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) Proposer() (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) SubmissionInterval() (*big.Int, error)

type L2OutputOracleFilterer

+ func (_L2OutputOracle *L2OutputOracleFilterer) FilterOutputProposed(opts *bind.FilterOpts, outputRoot [][32]byte, l2OutputIndex []*big.Int, ...) (*L2OutputOracleOutputProposedIterator, error)

+ func (_L2OutputOracle *L2OutputOracleFilterer) FilterOutputsDeleted(opts *bind.FilterOpts, prevNextOutputIndex []*big.Int, ...) (*L2OutputOracleOutputsDeletedIterator, error)

+ func (_L2OutputOracle *L2OutputOracleFilterer) ParseOutputProposed(log types.Log) (*L2OutputOracleOutputProposed, error)

+ func (_L2OutputOracle *L2OutputOracleFilterer) ParseOutputsDeleted(log types.Log) (*L2OutputOracleOutputsDeleted, error)

+ func (_L2OutputOracle *L2OutputOracleFilterer) WatchOutputProposed(opts *bind.WatchOpts, sink chan<- *L2OutputOracleOutputProposed, ...) (event.Subscription, error)

+ func (_L2OutputOracle *L2OutputOracleFilterer) WatchOutputsDeleted(opts *bind.WatchOpts, sink chan<- *L2OutputOracleOutputsDeleted, ...) (event.Subscription, error)

+ type L2OutputOracleOutputProposed struct

+ L1Timestamp *big.Int

+ L2BlockNumber *big.Int

+ L2OutputIndex *big.Int

+ OutputRoot [32]byte

+ Raw types.Log

+ type L2OutputOracleOutputProposedIterator struct

+ Event *L2OutputOracleOutputProposed

+ func (it *L2OutputOracleOutputProposedIterator) Close() error

+ func (it *L2OutputOracleOutputProposedIterator) Error() error

+ func (it *L2OutputOracleOutputProposedIterator) Next() bool

+ type L2OutputOracleOutputsDeleted struct

+ NewNextOutputIndex *big.Int

+ PrevNextOutputIndex *big.Int

+ Raw types.Log

+ type L2OutputOracleOutputsDeletedIterator struct

+ Event *L2OutputOracleOutputsDeleted

+ func (it *L2OutputOracleOutputsDeletedIterator) Close() error

+ func (it *L2OutputOracleOutputsDeletedIterator) Error() error

+ func (it *L2OutputOracleOutputsDeletedIterator) Next() bool

type L2OutputOracleSession

+ func (_L2OutputOracle *L2OutputOracleSession) CHALLENGER() (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleSession) Challenger() (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleSession) DeleteL2Outputs(_l2OutputIndex *big.Int) (*types.Transaction, error)

+ func (_L2OutputOracle *L2OutputOracleSession) FinalizationPeriodSeconds() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleSession) L2BlockTime() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleSession) PROPOSER() (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleSession) ProposeL2Output(_outputRoot [32]byte, _l2BlockNumber *big.Int, _l1BlockHash [32]byte, ...) (*types.Transaction, error)

+ func (_L2OutputOracle *L2OutputOracleSession) Proposer() (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleSession) SubmissionInterval() (*big.Int, error)

type L2OutputOracleTransactor

+ func (_L2OutputOracle *L2OutputOracleTransactor) DeleteL2Outputs(opts *bind.TransactOpts, _l2OutputIndex *big.Int) (*types.Transaction, error)

+ func (_L2OutputOracle *L2OutputOracleTransactor) ProposeL2Output(opts *bind.TransactOpts, _outputRoot [32]byte, _l2BlockNumber *big.Int, ...) (*types.Transaction, error)

type L2OutputOracleTransactorSession

+ func (_L2OutputOracle *L2OutputOracleTransactorSession) DeleteL2Outputs(_l2OutputIndex *big.Int) (*types.Transaction, error)

+ func (_L2OutputOracle *L2OutputOracleTransactorSession) ProposeL2Output(_outputRoot [32]byte, _l2BlockNumber *big.Int, _l1BlockHash [32]byte, ...) (*types.Transaction, error)

type L2StandardBridgeCaller

+ func (_L2StandardBridge *L2StandardBridgeCaller) L1TokenBridge(opts *bind.CallOpts) (common.Address, error)

+ func (_L2StandardBridge *L2StandardBridgeCaller) Messenger(opts *bind.CallOpts) (common.Address, error)

+ func (_L2StandardBridge *L2StandardBridgeCaller) OtherBridge(opts *bind.CallOpts) (common.Address, error)

type L2StandardBridgeCallerSession

+ func (_L2StandardBridge *L2StandardBridgeCallerSession) L1TokenBridge() (common.Address, error)

+ func (_L2StandardBridge *L2StandardBridgeCallerSession) Messenger() (common.Address, error)

+ func (_L2StandardBridge *L2StandardBridgeCallerSession) OtherBridge() (common.Address, error)

+ type L2StandardBridgeDepositFinalized struct

+ Amount *big.Int

+ ExtraData []byte

+ From common.Address

+ L1Token common.Address

+ L2Token common.Address

+ Raw types.Log

+ To common.Address

+ type L2StandardBridgeDepositFinalizedIterator struct

+ Event *L2StandardBridgeDepositFinalized

+ func (it *L2StandardBridgeDepositFinalizedIterator) Close() error

+ func (it *L2StandardBridgeDepositFinalizedIterator) Error() error

+ func (it *L2StandardBridgeDepositFinalizedIterator) Next() bool

type L2StandardBridgeFilterer

+ func (_L2StandardBridge *L2StandardBridgeFilterer) FilterDepositFinalized(opts *bind.FilterOpts, l1Token []common.Address, l2Token []common.Address, ...) (*L2StandardBridgeDepositFinalizedIterator, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) FilterInitialized(opts *bind.FilterOpts) (*L2StandardBridgeInitializedIterator, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) FilterWithdrawalInitiated(opts *bind.FilterOpts, l1Token []common.Address, l2Token []common.Address, ...) (*L2StandardBridgeWithdrawalInitiatedIterator, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) ParseDepositFinalized(log types.Log) (*L2StandardBridgeDepositFinalized, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) ParseInitialized(log types.Log) (*L2StandardBridgeInitialized, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) ParseWithdrawalInitiated(log types.Log) (*L2StandardBridgeWithdrawalInitiated, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) WatchDepositFinalized(opts *bind.WatchOpts, sink chan<- *L2StandardBridgeDepositFinalized, ...) (event.Subscription, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *L2StandardBridgeInitialized) (event.Subscription, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) WatchWithdrawalInitiated(opts *bind.WatchOpts, sink chan<- *L2StandardBridgeWithdrawalInitiated, ...) (event.Subscription, error)

+ type L2StandardBridgeInitialized struct

+ Raw types.Log

+ Version uint8

+ type L2StandardBridgeInitializedIterator struct

+ Event *L2StandardBridgeInitialized

+ func (it *L2StandardBridgeInitializedIterator) Close() error

+ func (it *L2StandardBridgeInitializedIterator) Error() error

+ func (it *L2StandardBridgeInitializedIterator) Next() bool

type L2StandardBridgeSession

+ func (_L2StandardBridge *L2StandardBridgeSession) FinalizeDeposit(_l1Token common.Address, _l2Token common.Address, _from common.Address, ...) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeSession) Initialize() (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeSession) L1TokenBridge() (common.Address, error)

+ func (_L2StandardBridge *L2StandardBridgeSession) Messenger() (common.Address, error)

+ func (_L2StandardBridge *L2StandardBridgeSession) OtherBridge() (common.Address, error)

+ func (_L2StandardBridge *L2StandardBridgeSession) Withdraw(_l2Token common.Address, _amount *big.Int, _minGasLimit uint32, ...) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeSession) WithdrawTo(_l2Token common.Address, _to common.Address, _amount *big.Int, ...) (*types.Transaction, error)

type L2StandardBridgeTransactor

+ func (_L2StandardBridge *L2StandardBridgeTransactor) FinalizeDeposit(opts *bind.TransactOpts, _l1Token common.Address, _l2Token common.Address, ...) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeTransactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeTransactor) Withdraw(opts *bind.TransactOpts, _l2Token common.Address, _amount *big.Int, ...) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeTransactor) WithdrawTo(opts *bind.TransactOpts, _l2Token common.Address, _to common.Address, ...) (*types.Transaction, error)

type L2StandardBridgeTransactorSession

+ func (_L2StandardBridge *L2StandardBridgeTransactorSession) FinalizeDeposit(_l1Token common.Address, _l2Token common.Address, _from common.Address, ...) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeTransactorSession) Initialize() (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeTransactorSession) Withdraw(_l2Token common.Address, _amount *big.Int, _minGasLimit uint32, ...) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeTransactorSession) WithdrawTo(_l2Token common.Address, _to common.Address, _amount *big.Int, ...) (*types.Transaction, error)

+ type L2StandardBridgeWithdrawalInitiated struct

+ Amount *big.Int

+ ExtraData []byte

+ From common.Address

+ L1Token common.Address

+ L2Token common.Address

+ Raw types.Log

+ To common.Address

+ type L2StandardBridgeWithdrawalInitiatedIterator struct

+ Event *L2StandardBridgeWithdrawalInitiated

+ func (it *L2StandardBridgeWithdrawalInitiatedIterator) Close() error

+ func (it *L2StandardBridgeWithdrawalInitiatedIterator) Error() error

+ func (it *L2StandardBridgeWithdrawalInitiatedIterator) Next() bool

+ type LegacyERC20ETH struct

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

+ func NewLegacyERC20ETH(address common.Address, backend bind.ContractBackend) (*LegacyERC20ETH, error)

+ type LegacyERC20ETHApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type LegacyERC20ETHApprovalIterator struct

+ Event *LegacyERC20ETHApproval

+ func (it *LegacyERC20ETHApprovalIterator) Close() error

+ func (it *LegacyERC20ETHApprovalIterator) Error() error

+ func (it *LegacyERC20ETHApprovalIterator) Next() bool

+ type LegacyERC20ETHBurn struct

+ Account common.Address

+ Amount *big.Int

+ Raw types.Log

+ type LegacyERC20ETHBurnIterator struct

+ Event *LegacyERC20ETHBurn

+ func (it *LegacyERC20ETHBurnIterator) Close() error

+ func (it *LegacyERC20ETHBurnIterator) Error() error

+ func (it *LegacyERC20ETHBurnIterator) Next() bool

+ type LegacyERC20ETHCaller struct

+ func NewLegacyERC20ETHCaller(address common.Address, caller bind.ContractCaller) (*LegacyERC20ETHCaller, error)

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

+ func (_LegacyERC20ETH *LegacyERC20ETHCaller) BRIDGE(opts *bind.CallOpts) (common.Address, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCaller) BalanceOf(opts *bind.CallOpts, _who common.Address) (*big.Int, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCaller) Bridge(opts *bind.CallOpts) (common.Address, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCaller) Decimals(opts *bind.CallOpts) (uint8, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCaller) L1Token(opts *bind.CallOpts) (common.Address, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCaller) L2Bridge(opts *bind.CallOpts) (common.Address, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCaller) REMOTETOKEN(opts *bind.CallOpts) (common.Address, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCaller) RemoteToken(opts *bind.CallOpts) (common.Address, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCaller) SupportsInterface(opts *bind.CallOpts, _interfaceId [4]byte) (bool, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCaller) Version(opts *bind.CallOpts) (string, error)

+ type LegacyERC20ETHCallerRaw struct

+ Contract *LegacyERC20ETHCaller

+ func (_LegacyERC20ETH *LegacyERC20ETHCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type LegacyERC20ETHCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *LegacyERC20ETHCaller

+ func (_LegacyERC20ETH *LegacyERC20ETHCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCallerSession) BRIDGE() (common.Address, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCallerSession) BalanceOf(_who common.Address) (*big.Int, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCallerSession) Bridge() (common.Address, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCallerSession) Decimals() (uint8, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCallerSession) L1Token() (common.Address, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCallerSession) L2Bridge() (common.Address, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCallerSession) Name() (string, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCallerSession) REMOTETOKEN() (common.Address, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCallerSession) RemoteToken() (common.Address, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCallerSession) SupportsInterface(_interfaceId [4]byte) (bool, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCallerSession) Symbol() (string, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCallerSession) TotalSupply() (*big.Int, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHCallerSession) Version() (string, error)

+ type LegacyERC20ETHFilterer struct

+ func NewLegacyERC20ETHFilterer(address common.Address, filterer bind.ContractFilterer) (*LegacyERC20ETHFilterer, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*LegacyERC20ETHApprovalIterator, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHFilterer) FilterBurn(opts *bind.FilterOpts, account []common.Address) (*LegacyERC20ETHBurnIterator, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHFilterer) FilterMint(opts *bind.FilterOpts, account []common.Address) (*LegacyERC20ETHMintIterator, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*LegacyERC20ETHTransferIterator, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHFilterer) ParseApproval(log types.Log) (*LegacyERC20ETHApproval, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHFilterer) ParseBurn(log types.Log) (*LegacyERC20ETHBurn, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHFilterer) ParseMint(log types.Log) (*LegacyERC20ETHMint, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHFilterer) ParseTransfer(log types.Log) (*LegacyERC20ETHTransfer, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *LegacyERC20ETHApproval, ...) (event.Subscription, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHFilterer) WatchBurn(opts *bind.WatchOpts, sink chan<- *LegacyERC20ETHBurn, ...) (event.Subscription, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHFilterer) WatchMint(opts *bind.WatchOpts, sink chan<- *LegacyERC20ETHMint, ...) (event.Subscription, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *LegacyERC20ETHTransfer, ...) (event.Subscription, error)

+ type LegacyERC20ETHMint struct

+ Account common.Address

+ Amount *big.Int

+ Raw types.Log

+ type LegacyERC20ETHMintIterator struct

+ Event *LegacyERC20ETHMint

+ func (it *LegacyERC20ETHMintIterator) Close() error

+ func (it *LegacyERC20ETHMintIterator) Error() error

+ func (it *LegacyERC20ETHMintIterator) Next() bool

+ type LegacyERC20ETHRaw struct

+ Contract *LegacyERC20ETH

+ func (_LegacyERC20ETH *LegacyERC20ETHRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_LegacyERC20ETH *LegacyERC20ETHRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type LegacyERC20ETHSession struct

+ CallOpts bind.CallOpts

+ Contract *LegacyERC20ETH

+ TransactOpts bind.TransactOpts

+ func (_LegacyERC20ETH *LegacyERC20ETHSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHSession) Approve(arg0 common.Address, arg1 *big.Int) (*types.Transaction, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHSession) BRIDGE() (common.Address, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHSession) BalanceOf(_who common.Address) (*big.Int, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHSession) Bridge() (common.Address, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHSession) Burn(arg0 common.Address, arg1 *big.Int) (*types.Transaction, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHSession) Decimals() (uint8, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHSession) DecreaseAllowance(arg0 common.Address, arg1 *big.Int) (*types.Transaction, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHSession) IncreaseAllowance(arg0 common.Address, arg1 *big.Int) (*types.Transaction, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHSession) L1Token() (common.Address, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHSession) L2Bridge() (common.Address, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHSession) Mint(arg0 common.Address, arg1 *big.Int) (*types.Transaction, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHSession) Name() (string, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHSession) REMOTETOKEN() (common.Address, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHSession) RemoteToken() (common.Address, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHSession) SupportsInterface(_interfaceId [4]byte) (bool, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHSession) Symbol() (string, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHSession) TotalSupply() (*big.Int, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHSession) Transfer(arg0 common.Address, arg1 *big.Int) (*types.Transaction, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHSession) TransferFrom(arg0 common.Address, arg1 common.Address, arg2 *big.Int) (*types.Transaction, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHSession) Version() (string, error)

+ type LegacyERC20ETHTransactor struct

+ func NewLegacyERC20ETHTransactor(address common.Address, transactor bind.ContractTransactor) (*LegacyERC20ETHTransactor, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHTransactor) Approve(opts *bind.TransactOpts, arg0 common.Address, arg1 *big.Int) (*types.Transaction, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHTransactor) Burn(opts *bind.TransactOpts, arg0 common.Address, arg1 *big.Int) (*types.Transaction, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHTransactor) DecreaseAllowance(opts *bind.TransactOpts, arg0 common.Address, arg1 *big.Int) (*types.Transaction, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHTransactor) IncreaseAllowance(opts *bind.TransactOpts, arg0 common.Address, arg1 *big.Int) (*types.Transaction, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHTransactor) Mint(opts *bind.TransactOpts, arg0 common.Address, arg1 *big.Int) (*types.Transaction, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHTransactor) Transfer(opts *bind.TransactOpts, arg0 common.Address, arg1 *big.Int) (*types.Transaction, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHTransactor) TransferFrom(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, ...) (*types.Transaction, error)

+ type LegacyERC20ETHTransactorRaw struct

+ Contract *LegacyERC20ETHTransactor

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

+ func (_LegacyERC20ETH *LegacyERC20ETHTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type LegacyERC20ETHTransactorSession struct

+ Contract *LegacyERC20ETHTransactor

+ TransactOpts bind.TransactOpts

+ func (_LegacyERC20ETH *LegacyERC20ETHTransactorSession) Approve(arg0 common.Address, arg1 *big.Int) (*types.Transaction, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHTransactorSession) Burn(arg0 common.Address, arg1 *big.Int) (*types.Transaction, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHTransactorSession) DecreaseAllowance(arg0 common.Address, arg1 *big.Int) (*types.Transaction, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHTransactorSession) IncreaseAllowance(arg0 common.Address, arg1 *big.Int) (*types.Transaction, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHTransactorSession) Mint(arg0 common.Address, arg1 *big.Int) (*types.Transaction, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHTransactorSession) Transfer(arg0 common.Address, arg1 *big.Int) (*types.Transaction, error)

+ func (_LegacyERC20ETH *LegacyERC20ETHTransactorSession) TransferFrom(arg0 common.Address, arg1 common.Address, arg2 *big.Int) (*types.Transaction, error)

+ type LegacyERC20ETHTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type LegacyERC20ETHTransferIterator struct

+ Event *LegacyERC20ETHTransfer

+ func (it *LegacyERC20ETHTransferIterator) Close() error

+ func (it *LegacyERC20ETHTransferIterator) Error() error

+ func (it *LegacyERC20ETHTransferIterator) Next() bool

+ type LegacyMessagePasser struct

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

+ func NewLegacyMessagePasser(address common.Address, backend bind.ContractBackend) (*LegacyMessagePasser, error)

+ type LegacyMessagePasserCaller struct

+ func NewLegacyMessagePasserCaller(address common.Address, caller bind.ContractCaller) (*LegacyMessagePasserCaller, error)

+ func (_LegacyMessagePasser *LegacyMessagePasserCaller) SentMessages(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ func (_LegacyMessagePasser *LegacyMessagePasserCaller) Version(opts *bind.CallOpts) (string, error)

+ type LegacyMessagePasserCallerRaw struct

+ Contract *LegacyMessagePasserCaller

+ func (_LegacyMessagePasser *LegacyMessagePasserCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type LegacyMessagePasserCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *LegacyMessagePasserCaller

+ func (_LegacyMessagePasser *LegacyMessagePasserCallerSession) SentMessages(arg0 [32]byte) (bool, error)

+ func (_LegacyMessagePasser *LegacyMessagePasserCallerSession) Version() (string, error)

+ type LegacyMessagePasserFilterer struct

+ func NewLegacyMessagePasserFilterer(address common.Address, filterer bind.ContractFilterer) (*LegacyMessagePasserFilterer, error)

+ type LegacyMessagePasserRaw struct

+ Contract *LegacyMessagePasser

+ func (_LegacyMessagePasser *LegacyMessagePasserRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_LegacyMessagePasser *LegacyMessagePasserRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type LegacyMessagePasserSession struct

+ CallOpts bind.CallOpts

+ Contract *LegacyMessagePasser

+ TransactOpts bind.TransactOpts

+ func (_LegacyMessagePasser *LegacyMessagePasserSession) PassMessageToL1(_message []byte) (*types.Transaction, error)

+ func (_LegacyMessagePasser *LegacyMessagePasserSession) SentMessages(arg0 [32]byte) (bool, error)

+ func (_LegacyMessagePasser *LegacyMessagePasserSession) Version() (string, error)

+ type LegacyMessagePasserTransactor struct

+ func NewLegacyMessagePasserTransactor(address common.Address, transactor bind.ContractTransactor) (*LegacyMessagePasserTransactor, error)

+ func (_LegacyMessagePasser *LegacyMessagePasserTransactor) PassMessageToL1(opts *bind.TransactOpts, _message []byte) (*types.Transaction, error)

+ type LegacyMessagePasserTransactorRaw struct

+ Contract *LegacyMessagePasserTransactor

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

+ func (_LegacyMessagePasser *LegacyMessagePasserTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type LegacyMessagePasserTransactorSession struct

+ Contract *LegacyMessagePasserTransactor

+ TransactOpts bind.TransactOpts

+ func (_LegacyMessagePasser *LegacyMessagePasserTransactorSession) PassMessageToL1(_message []byte) (*types.Transaction, error)

+ type MIPS struct

+ func DeployMIPS(auth *bind.TransactOpts, backend bind.ContractBackend, _oracle common.Address) (common.Address, *types.Transaction, *MIPS, error)

+ func NewMIPS(address common.Address, backend bind.ContractBackend) (*MIPS, error)

+ type MIPSCaller struct

+ func NewMIPSCaller(address common.Address, caller bind.ContractCaller) (*MIPSCaller, error)

+ func (_MIPS *MIPSCaller) BRKSTART(opts *bind.CallOpts) (uint32, error)

+ func (_MIPS *MIPSCaller) Oracle(opts *bind.CallOpts) (common.Address, error)

+ type MIPSCallerRaw struct

+ Contract *MIPSCaller

+ func (_MIPS *MIPSCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type MIPSCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *MIPSCaller

+ func (_MIPS *MIPSCallerSession) BRKSTART() (uint32, error)

+ func (_MIPS *MIPSCallerSession) Oracle() (common.Address, error)

+ type MIPSFilterer struct

+ func NewMIPSFilterer(address common.Address, filterer bind.ContractFilterer) (*MIPSFilterer, error)

+ type MIPSRaw struct

+ Contract *MIPS

+ func (_MIPS *MIPSRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_MIPS *MIPSRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MIPSSession struct

+ CallOpts bind.CallOpts

+ Contract *MIPS

+ TransactOpts bind.TransactOpts

+ func (_MIPS *MIPSSession) BRKSTART() (uint32, error)

+ func (_MIPS *MIPSSession) Oracle() (common.Address, error)

+ func (_MIPS *MIPSSession) Step(_stateData []byte, _proof []byte, _localContext *big.Int) (*types.Transaction, error)

+ type MIPSTransactor struct

+ func NewMIPSTransactor(address common.Address, transactor bind.ContractTransactor) (*MIPSTransactor, error)

+ func (_MIPS *MIPSTransactor) Step(opts *bind.TransactOpts, _stateData []byte, _proof []byte, ...) (*types.Transaction, error)

+ type MIPSTransactorRaw struct

+ Contract *MIPSTransactor

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

+ func (_MIPS *MIPSTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MIPSTransactorSession struct

+ Contract *MIPSTransactor

+ TransactOpts bind.TransactOpts

+ func (_MIPS *MIPSTransactorSession) Step(_stateData []byte, _proof []byte, _localContext *big.Int) (*types.Transaction, error)

+ type MultiAttestationRequest struct

+ Data []AttestationRequestData

+ Schema [32]byte

+ type MultiDelegatedAttestationRequest struct

+ Attester common.Address

+ Data []AttestationRequestData

+ Deadline uint64

+ Schema [32]byte

+ Signatures []Signature

+ type MultiDelegatedRevocationRequest struct

+ Data []RevocationRequestData

+ Deadline uint64

+ Revoker common.Address

+ Schema [32]byte

+ Signatures []Signature

+ type MultiRevocationRequest struct

+ Data []RevocationRequestData

+ Schema [32]byte

+ type OptimismMintableERC20 struct

+ func DeployOptimismMintableERC20(auth *bind.TransactOpts, backend bind.ContractBackend, _bridge common.Address, ...) (common.Address, *types.Transaction, *OptimismMintableERC20, error)

+ func NewOptimismMintableERC20(address common.Address, backend bind.ContractBackend) (*OptimismMintableERC20, error)

+ type OptimismMintableERC20Approval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type OptimismMintableERC20ApprovalIterator struct

+ Event *OptimismMintableERC20Approval

+ func (it *OptimismMintableERC20ApprovalIterator) Close() error

+ func (it *OptimismMintableERC20ApprovalIterator) Error() error

+ func (it *OptimismMintableERC20ApprovalIterator) Next() bool

+ type OptimismMintableERC20Burn struct

+ Account common.Address

+ Amount *big.Int

+ Raw types.Log

+ type OptimismMintableERC20BurnIterator struct

+ Event *OptimismMintableERC20Burn

+ func (it *OptimismMintableERC20BurnIterator) Close() error

+ func (it *OptimismMintableERC20BurnIterator) Error() error

+ func (it *OptimismMintableERC20BurnIterator) Next() bool

+ type OptimismMintableERC20Caller struct

+ func NewOptimismMintableERC20Caller(address common.Address, caller bind.ContractCaller) (*OptimismMintableERC20Caller, error)

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

+ func (_OptimismMintableERC20 *OptimismMintableERC20Caller) BRIDGE(opts *bind.CallOpts) (common.Address, error)

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

+ func (_OptimismMintableERC20 *OptimismMintableERC20Caller) Bridge(opts *bind.CallOpts) (common.Address, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Caller) Decimals(opts *bind.CallOpts) (uint8, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Caller) L1Token(opts *bind.CallOpts) (common.Address, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Caller) L2Bridge(opts *bind.CallOpts) (common.Address, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Caller) Name(opts *bind.CallOpts) (string, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Caller) REMOTETOKEN(opts *bind.CallOpts) (common.Address, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Caller) RemoteToken(opts *bind.CallOpts) (common.Address, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Caller) SupportsInterface(opts *bind.CallOpts, _interfaceId [4]byte) (bool, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Caller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Caller) Version(opts *bind.CallOpts) (string, error)

+ type OptimismMintableERC20CallerRaw struct

+ Contract *OptimismMintableERC20Caller

+ func (_OptimismMintableERC20 *OptimismMintableERC20CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type OptimismMintableERC20CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OptimismMintableERC20Caller

+ func (_OptimismMintableERC20 *OptimismMintableERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20CallerSession) BRIDGE() (common.Address, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20CallerSession) Bridge() (common.Address, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20CallerSession) Decimals() (uint8, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20CallerSession) L1Token() (common.Address, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20CallerSession) L2Bridge() (common.Address, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20CallerSession) Name() (string, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20CallerSession) REMOTETOKEN() (common.Address, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20CallerSession) RemoteToken() (common.Address, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20CallerSession) SupportsInterface(_interfaceId [4]byte) (bool, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20CallerSession) Symbol() (string, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20CallerSession) TotalSupply() (*big.Int, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20CallerSession) Version() (string, error)

+ type OptimismMintableERC20Factory struct

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

+ func NewOptimismMintableERC20Factory(address common.Address, backend bind.ContractBackend) (*OptimismMintableERC20Factory, error)

+ type OptimismMintableERC20FactoryCaller struct

+ func NewOptimismMintableERC20FactoryCaller(address common.Address, caller bind.ContractCaller) (*OptimismMintableERC20FactoryCaller, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryCaller) BRIDGE(opts *bind.CallOpts) (common.Address, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryCaller) Bridge(opts *bind.CallOpts) (common.Address, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryCaller) Version(opts *bind.CallOpts) (string, error)

+ type OptimismMintableERC20FactoryCallerRaw struct

+ Contract *OptimismMintableERC20FactoryCaller

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type OptimismMintableERC20FactoryCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OptimismMintableERC20FactoryCaller

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryCallerSession) BRIDGE() (common.Address, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryCallerSession) Bridge() (common.Address, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryCallerSession) Version() (string, error)

+ type OptimismMintableERC20FactoryFilterer struct

+ func NewOptimismMintableERC20FactoryFilterer(address common.Address, filterer bind.ContractFilterer) (*OptimismMintableERC20FactoryFilterer, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryFilterer) FilterInitialized(opts *bind.FilterOpts) (*OptimismMintableERC20FactoryInitializedIterator, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryFilterer) FilterOptimismMintableERC20Created(opts *bind.FilterOpts, localToken []common.Address, ...) (*OptimismMintableERC20FactoryOptimismMintableERC20CreatedIterator, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryFilterer) FilterStandardL2TokenCreated(opts *bind.FilterOpts, remoteToken []common.Address, ...) (*OptimismMintableERC20FactoryStandardL2TokenCreatedIterator, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryFilterer) ParseInitialized(log types.Log) (*OptimismMintableERC20FactoryInitialized, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryFilterer) ParseOptimismMintableERC20Created(log types.Log) (*OptimismMintableERC20FactoryOptimismMintableERC20Created, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryFilterer) ParseStandardL2TokenCreated(log types.Log) (*OptimismMintableERC20FactoryStandardL2TokenCreated, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *OptimismMintableERC20FactoryInitialized) (event.Subscription, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryFilterer) WatchOptimismMintableERC20Created(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryFilterer) WatchStandardL2TokenCreated(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ type OptimismMintableERC20FactoryInitialized struct

+ Raw types.Log

+ Version uint8

+ type OptimismMintableERC20FactoryInitializedIterator struct

+ Event *OptimismMintableERC20FactoryInitialized

+ func (it *OptimismMintableERC20FactoryInitializedIterator) Close() error

+ func (it *OptimismMintableERC20FactoryInitializedIterator) Error() error

+ func (it *OptimismMintableERC20FactoryInitializedIterator) Next() bool

+ type OptimismMintableERC20FactoryOptimismMintableERC20Created struct

+ Deployer common.Address

+ LocalToken common.Address

+ Raw types.Log

+ RemoteToken common.Address

+ type OptimismMintableERC20FactoryOptimismMintableERC20CreatedIterator struct

+ Event *OptimismMintableERC20FactoryOptimismMintableERC20Created

+ func (it *OptimismMintableERC20FactoryOptimismMintableERC20CreatedIterator) Close() error

+ func (it *OptimismMintableERC20FactoryOptimismMintableERC20CreatedIterator) Error() error

+ func (it *OptimismMintableERC20FactoryOptimismMintableERC20CreatedIterator) Next() bool

+ type OptimismMintableERC20FactoryRaw struct

+ Contract *OptimismMintableERC20Factory

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OptimismMintableERC20FactorySession struct

+ CallOpts bind.CallOpts

+ Contract *OptimismMintableERC20Factory

+ TransactOpts bind.TransactOpts

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactorySession) BRIDGE() (common.Address, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactorySession) Bridge() (common.Address, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactorySession) CreateOptimismMintableERC20(_remoteToken common.Address, _name string, _symbol string) (*types.Transaction, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactorySession) CreateOptimismMintableERC20WithDecimals(_remoteToken common.Address, _name string, _symbol string, _decimals uint8) (*types.Transaction, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactorySession) CreateStandardL2Token(_remoteToken common.Address, _name string, _symbol string) (*types.Transaction, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactorySession) Initialize(_bridge common.Address) (*types.Transaction, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactorySession) Version() (string, error)

+ type OptimismMintableERC20FactoryStandardL2TokenCreated struct

+ LocalToken common.Address

+ Raw types.Log

+ RemoteToken common.Address

+ type OptimismMintableERC20FactoryStandardL2TokenCreatedIterator struct

+ Event *OptimismMintableERC20FactoryStandardL2TokenCreated

+ func (it *OptimismMintableERC20FactoryStandardL2TokenCreatedIterator) Close() error

+ func (it *OptimismMintableERC20FactoryStandardL2TokenCreatedIterator) Error() error

+ func (it *OptimismMintableERC20FactoryStandardL2TokenCreatedIterator) Next() bool

+ type OptimismMintableERC20FactoryTransactor struct

+ func NewOptimismMintableERC20FactoryTransactor(address common.Address, transactor bind.ContractTransactor) (*OptimismMintableERC20FactoryTransactor, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryTransactor) CreateOptimismMintableERC20(opts *bind.TransactOpts, _remoteToken common.Address, _name string, ...) (*types.Transaction, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryTransactor) CreateOptimismMintableERC20WithDecimals(opts *bind.TransactOpts, _remoteToken common.Address, _name string, ...) (*types.Transaction, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryTransactor) CreateStandardL2Token(opts *bind.TransactOpts, _remoteToken common.Address, _name string, ...) (*types.Transaction, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryTransactor) Initialize(opts *bind.TransactOpts, _bridge common.Address) (*types.Transaction, error)

+ type OptimismMintableERC20FactoryTransactorRaw struct

+ Contract *OptimismMintableERC20FactoryTransactor

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

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OptimismMintableERC20FactoryTransactorSession struct

+ Contract *OptimismMintableERC20FactoryTransactor

+ TransactOpts bind.TransactOpts

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryTransactorSession) CreateOptimismMintableERC20(_remoteToken common.Address, _name string, _symbol string) (*types.Transaction, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryTransactorSession) CreateOptimismMintableERC20WithDecimals(_remoteToken common.Address, _name string, _symbol string, _decimals uint8) (*types.Transaction, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryTransactorSession) CreateStandardL2Token(_remoteToken common.Address, _name string, _symbol string) (*types.Transaction, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryTransactorSession) Initialize(_bridge common.Address) (*types.Transaction, error)

+ type OptimismMintableERC20Filterer struct

+ func NewOptimismMintableERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*OptimismMintableERC20Filterer, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*OptimismMintableERC20ApprovalIterator, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Filterer) FilterBurn(opts *bind.FilterOpts, account []common.Address) (*OptimismMintableERC20BurnIterator, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Filterer) FilterMint(opts *bind.FilterOpts, account []common.Address) (*OptimismMintableERC20MintIterator, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*OptimismMintableERC20TransferIterator, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Filterer) ParseApproval(log types.Log) (*OptimismMintableERC20Approval, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Filterer) ParseBurn(log types.Log) (*OptimismMintableERC20Burn, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Filterer) ParseMint(log types.Log) (*OptimismMintableERC20Mint, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Filterer) ParseTransfer(log types.Log) (*OptimismMintableERC20Transfer, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *OptimismMintableERC20Approval, ...) (event.Subscription, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Filterer) WatchBurn(opts *bind.WatchOpts, sink chan<- *OptimismMintableERC20Burn, ...) (event.Subscription, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Filterer) WatchMint(opts *bind.WatchOpts, sink chan<- *OptimismMintableERC20Mint, ...) (event.Subscription, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *OptimismMintableERC20Transfer, ...) (event.Subscription, error)

+ type OptimismMintableERC20Mint struct

+ Account common.Address

+ Amount *big.Int

+ Raw types.Log

+ type OptimismMintableERC20MintIterator struct

+ Event *OptimismMintableERC20Mint

+ func (it *OptimismMintableERC20MintIterator) Close() error

+ func (it *OptimismMintableERC20MintIterator) Error() error

+ func (it *OptimismMintableERC20MintIterator) Next() bool

+ type OptimismMintableERC20Raw struct

+ Contract *OptimismMintableERC20

+ func (_OptimismMintableERC20 *OptimismMintableERC20Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_OptimismMintableERC20 *OptimismMintableERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OptimismMintableERC20Session struct

+ CallOpts bind.CallOpts

+ Contract *OptimismMintableERC20

+ TransactOpts bind.TransactOpts

+ func (_OptimismMintableERC20 *OptimismMintableERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

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

+ func (_OptimismMintableERC20 *OptimismMintableERC20Session) BRIDGE() (common.Address, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Session) BalanceOf(account common.Address) (*big.Int, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Session) Bridge() (common.Address, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Session) Burn(_from common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Session) Decimals() (uint8, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Session) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Session) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Session) L1Token() (common.Address, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Session) L2Bridge() (common.Address, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Session) Mint(_to common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Session) Name() (string, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Session) REMOTETOKEN() (common.Address, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Session) RemoteToken() (common.Address, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Session) SupportsInterface(_interfaceId [4]byte) (bool, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Session) Symbol() (string, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Session) TotalSupply() (*big.Int, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Session) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Session) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Session) Version() (string, error)

+ type OptimismMintableERC20Transactor struct

+ func NewOptimismMintableERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*OptimismMintableERC20Transactor, error)

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

+ func (_OptimismMintableERC20 *OptimismMintableERC20Transactor) Burn(opts *bind.TransactOpts, _from common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Transactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Transactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Transactor) Mint(opts *bind.TransactOpts, _to common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Transactor) Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ type OptimismMintableERC20TransactorRaw struct

+ Contract *OptimismMintableERC20Transactor

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

+ func (_OptimismMintableERC20 *OptimismMintableERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OptimismMintableERC20TransactorSession struct

+ Contract *OptimismMintableERC20Transactor

+ TransactOpts bind.TransactOpts

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

+ func (_OptimismMintableERC20 *OptimismMintableERC20TransactorSession) Burn(_from common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20TransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20TransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20TransactorSession) Mint(_to common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20TransactorSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_OptimismMintableERC20 *OptimismMintableERC20TransactorSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error)

+ type OptimismMintableERC20Transfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type OptimismMintableERC20TransferIterator struct

+ Event *OptimismMintableERC20Transfer

+ func (it *OptimismMintableERC20TransferIterator) Close() error

+ func (it *OptimismMintableERC20TransferIterator) Error() error

+ func (it *OptimismMintableERC20TransferIterator) Next() bool

+ type OptimismMintableERC721Factory struct

+ func DeployOptimismMintableERC721Factory(auth *bind.TransactOpts, backend bind.ContractBackend, _bridge common.Address, ...) (common.Address, *types.Transaction, *OptimismMintableERC721Factory, error)

+ func NewOptimismMintableERC721Factory(address common.Address, backend bind.ContractBackend) (*OptimismMintableERC721Factory, error)

+ type OptimismMintableERC721FactoryCaller struct

+ func NewOptimismMintableERC721FactoryCaller(address common.Address, caller bind.ContractCaller) (*OptimismMintableERC721FactoryCaller, error)

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactoryCaller) BRIDGE(opts *bind.CallOpts) (common.Address, error)

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactoryCaller) IsOptimismMintableERC721(opts *bind.CallOpts, arg0 common.Address) (bool, error)

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactoryCaller) REMOTECHAINID(opts *bind.CallOpts) (*big.Int, error)

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactoryCaller) Version(opts *bind.CallOpts) (string, error)

+ type OptimismMintableERC721FactoryCallerRaw struct

+ Contract *OptimismMintableERC721FactoryCaller

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactoryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type OptimismMintableERC721FactoryCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OptimismMintableERC721FactoryCaller

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactoryCallerSession) BRIDGE() (common.Address, error)

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactoryCallerSession) IsOptimismMintableERC721(arg0 common.Address) (bool, error)

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactoryCallerSession) REMOTECHAINID() (*big.Int, error)

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactoryCallerSession) Version() (string, error)

+ type OptimismMintableERC721FactoryFilterer struct

+ func NewOptimismMintableERC721FactoryFilterer(address common.Address, filterer bind.ContractFilterer) (*OptimismMintableERC721FactoryFilterer, error)

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactoryFilterer) FilterOptimismMintableERC721Created(opts *bind.FilterOpts, localToken []common.Address, ...) (*OptimismMintableERC721FactoryOptimismMintableERC721CreatedIterator, error)

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactoryFilterer) ParseOptimismMintableERC721Created(log types.Log) (*OptimismMintableERC721FactoryOptimismMintableERC721Created, error)

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactoryFilterer) WatchOptimismMintableERC721Created(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ type OptimismMintableERC721FactoryOptimismMintableERC721Created struct

+ Deployer common.Address

+ LocalToken common.Address

+ Raw types.Log

+ RemoteToken common.Address

+ type OptimismMintableERC721FactoryOptimismMintableERC721CreatedIterator struct

+ Event *OptimismMintableERC721FactoryOptimismMintableERC721Created

+ func (it *OptimismMintableERC721FactoryOptimismMintableERC721CreatedIterator) Close() error

+ func (it *OptimismMintableERC721FactoryOptimismMintableERC721CreatedIterator) Error() error

+ func (it *OptimismMintableERC721FactoryOptimismMintableERC721CreatedIterator) Next() bool

+ type OptimismMintableERC721FactoryRaw struct

+ Contract *OptimismMintableERC721Factory

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactoryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OptimismMintableERC721FactorySession struct

+ CallOpts bind.CallOpts

+ Contract *OptimismMintableERC721Factory

+ TransactOpts bind.TransactOpts

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactorySession) BRIDGE() (common.Address, error)

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactorySession) CreateOptimismMintableERC721(_remoteToken common.Address, _name string, _symbol string) (*types.Transaction, error)

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactorySession) IsOptimismMintableERC721(arg0 common.Address) (bool, error)

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactorySession) REMOTECHAINID() (*big.Int, error)

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactorySession) Version() (string, error)

+ type OptimismMintableERC721FactoryTransactor struct

+ func NewOptimismMintableERC721FactoryTransactor(address common.Address, transactor bind.ContractTransactor) (*OptimismMintableERC721FactoryTransactor, error)

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactoryTransactor) CreateOptimismMintableERC721(opts *bind.TransactOpts, _remoteToken common.Address, _name string, ...) (*types.Transaction, error)

+ type OptimismMintableERC721FactoryTransactorRaw struct

+ Contract *OptimismMintableERC721FactoryTransactor

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

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OptimismMintableERC721FactoryTransactorSession struct

+ Contract *OptimismMintableERC721FactoryTransactor

+ TransactOpts bind.TransactOpts

+ func (_OptimismMintableERC721Factory *OptimismMintableERC721FactoryTransactorSession) CreateOptimismMintableERC721(_remoteToken common.Address, _name string, _symbol string) (*types.Transaction, error)

+ type OptimismPortal struct

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

+ func NewOptimismPortal(address common.Address, backend bind.ContractBackend) (*OptimismPortal, error)

+ type OptimismPortalCaller struct

+ func NewOptimismPortalCaller(address common.Address, caller bind.ContractCaller) (*OptimismPortalCaller, error)

+ func (_OptimismPortal *OptimismPortalCaller) FinalizedWithdrawals(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ func (_OptimismPortal *OptimismPortalCaller) GUARDIAN(opts *bind.CallOpts) (common.Address, error)

+ func (_OptimismPortal *OptimismPortalCaller) Guardian(opts *bind.CallOpts) (common.Address, error)

+ func (_OptimismPortal *OptimismPortalCaller) IsOutputFinalized(opts *bind.CallOpts, _l2OutputIndex *big.Int) (bool, error)

+ func (_OptimismPortal *OptimismPortalCaller) L2ORACLE(opts *bind.CallOpts) (common.Address, error)

+ func (_OptimismPortal *OptimismPortalCaller) L2Oracle(opts *bind.CallOpts) (common.Address, error)

+ func (_OptimismPortal *OptimismPortalCaller) L2Sender(opts *bind.CallOpts) (common.Address, error)

+ func (_OptimismPortal *OptimismPortalCaller) MinimumGasLimit(opts *bind.CallOpts, _byteCount uint64) (uint64, error)

+ func (_OptimismPortal *OptimismPortalCaller) Params(opts *bind.CallOpts) (struct{ ... }, error)

+ func (_OptimismPortal *OptimismPortalCaller) Paused(opts *bind.CallOpts) (bool, error)

+ func (_OptimismPortal *OptimismPortalCaller) ProvenWithdrawals(opts *bind.CallOpts, arg0 [32]byte) (struct{ ... }, error)

+ func (_OptimismPortal *OptimismPortalCaller) SYSTEMCONFIG(opts *bind.CallOpts) (common.Address, error)

+ func (_OptimismPortal *OptimismPortalCaller) SystemConfig(opts *bind.CallOpts) (common.Address, error)

+ func (_OptimismPortal *OptimismPortalCaller) Version(opts *bind.CallOpts) (string, error)

+ type OptimismPortalCallerRaw struct

+ Contract *OptimismPortalCaller

+ func (_OptimismPortal *OptimismPortalCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type OptimismPortalCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OptimismPortalCaller

+ func (_OptimismPortal *OptimismPortalCallerSession) FinalizedWithdrawals(arg0 [32]byte) (bool, error)

+ func (_OptimismPortal *OptimismPortalCallerSession) GUARDIAN() (common.Address, error)

+ func (_OptimismPortal *OptimismPortalCallerSession) Guardian() (common.Address, error)

+ func (_OptimismPortal *OptimismPortalCallerSession) IsOutputFinalized(_l2OutputIndex *big.Int) (bool, error)

+ func (_OptimismPortal *OptimismPortalCallerSession) L2ORACLE() (common.Address, error)

+ func (_OptimismPortal *OptimismPortalCallerSession) L2Oracle() (common.Address, error)

+ func (_OptimismPortal *OptimismPortalCallerSession) L2Sender() (common.Address, error)

+ func (_OptimismPortal *OptimismPortalCallerSession) MinimumGasLimit(_byteCount uint64) (uint64, error)

+ func (_OptimismPortal *OptimismPortalCallerSession) Params() (struct{ ... }, error)

+ func (_OptimismPortal *OptimismPortalCallerSession) Paused() (bool, error)

+ func (_OptimismPortal *OptimismPortalCallerSession) ProvenWithdrawals(arg0 [32]byte) (struct{ ... }, error)

+ func (_OptimismPortal *OptimismPortalCallerSession) SYSTEMCONFIG() (common.Address, error)

+ func (_OptimismPortal *OptimismPortalCallerSession) SystemConfig() (common.Address, error)

+ func (_OptimismPortal *OptimismPortalCallerSession) Version() (string, error)

+ type OptimismPortalFilterer struct

+ func NewOptimismPortalFilterer(address common.Address, filterer bind.ContractFilterer) (*OptimismPortalFilterer, error)

+ func (_OptimismPortal *OptimismPortalFilterer) FilterInitialized(opts *bind.FilterOpts) (*OptimismPortalInitializedIterator, error)

+ func (_OptimismPortal *OptimismPortalFilterer) FilterPaused(opts *bind.FilterOpts) (*OptimismPortalPausedIterator, error)

+ func (_OptimismPortal *OptimismPortalFilterer) FilterTransactionDeposited(opts *bind.FilterOpts, from []common.Address, to []common.Address, ...) (*OptimismPortalTransactionDepositedIterator, error)

+ func (_OptimismPortal *OptimismPortalFilterer) FilterUnpaused(opts *bind.FilterOpts) (*OptimismPortalUnpausedIterator, error)

+ func (_OptimismPortal *OptimismPortalFilterer) FilterWithdrawalFinalized(opts *bind.FilterOpts, withdrawalHash [][32]byte) (*OptimismPortalWithdrawalFinalizedIterator, error)

+ func (_OptimismPortal *OptimismPortalFilterer) FilterWithdrawalProven(opts *bind.FilterOpts, withdrawalHash [][32]byte, from []common.Address, ...) (*OptimismPortalWithdrawalProvenIterator, error)

+ func (_OptimismPortal *OptimismPortalFilterer) ParseInitialized(log types.Log) (*OptimismPortalInitialized, error)

+ func (_OptimismPortal *OptimismPortalFilterer) ParsePaused(log types.Log) (*OptimismPortalPaused, error)

+ func (_OptimismPortal *OptimismPortalFilterer) ParseTransactionDeposited(log types.Log) (*OptimismPortalTransactionDeposited, error)

+ func (_OptimismPortal *OptimismPortalFilterer) ParseUnpaused(log types.Log) (*OptimismPortalUnpaused, error)

+ func (_OptimismPortal *OptimismPortalFilterer) ParseWithdrawalFinalized(log types.Log) (*OptimismPortalWithdrawalFinalized, error)

+ func (_OptimismPortal *OptimismPortalFilterer) ParseWithdrawalProven(log types.Log) (*OptimismPortalWithdrawalProven, error)

+ func (_OptimismPortal *OptimismPortalFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *OptimismPortalInitialized) (event.Subscription, error)

+ func (_OptimismPortal *OptimismPortalFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *OptimismPortalPaused) (event.Subscription, error)

+ func (_OptimismPortal *OptimismPortalFilterer) WatchTransactionDeposited(opts *bind.WatchOpts, sink chan<- *OptimismPortalTransactionDeposited, ...) (event.Subscription, error)

+ func (_OptimismPortal *OptimismPortalFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *OptimismPortalUnpaused) (event.Subscription, error)

+ func (_OptimismPortal *OptimismPortalFilterer) WatchWithdrawalFinalized(opts *bind.WatchOpts, sink chan<- *OptimismPortalWithdrawalFinalized, ...) (event.Subscription, error)

+ func (_OptimismPortal *OptimismPortalFilterer) WatchWithdrawalProven(opts *bind.WatchOpts, sink chan<- *OptimismPortalWithdrawalProven, ...) (event.Subscription, error)

+ type OptimismPortalInitialized struct

+ Raw types.Log

+ Version uint8

+ type OptimismPortalInitializedIterator struct

+ Event *OptimismPortalInitialized

+ func (it *OptimismPortalInitializedIterator) Close() error

+ func (it *OptimismPortalInitializedIterator) Error() error

+ func (it *OptimismPortalInitializedIterator) Next() bool

+ type OptimismPortalPaused struct

+ Account common.Address

+ Raw types.Log

+ type OptimismPortalPausedIterator struct

+ Event *OptimismPortalPaused

+ func (it *OptimismPortalPausedIterator) Close() error

+ func (it *OptimismPortalPausedIterator) Error() error

+ func (it *OptimismPortalPausedIterator) Next() bool

+ type OptimismPortalRaw struct

+ Contract *OptimismPortal

+ func (_OptimismPortal *OptimismPortalRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_OptimismPortal *OptimismPortalRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OptimismPortalSession struct

+ CallOpts bind.CallOpts

+ Contract *OptimismPortal

+ TransactOpts bind.TransactOpts

+ func (_OptimismPortal *OptimismPortalSession) DepositTransaction(_to common.Address, _value *big.Int, _gasLimit uint64, _isCreation bool, ...) (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalSession) DonateETH() (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalSession) FinalizeWithdrawalTransaction(_tx TypesWithdrawalTransaction) (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalSession) FinalizedWithdrawals(arg0 [32]byte) (bool, error)

+ func (_OptimismPortal *OptimismPortalSession) GUARDIAN() (common.Address, error)

+ func (_OptimismPortal *OptimismPortalSession) Guardian() (common.Address, error)

+ func (_OptimismPortal *OptimismPortalSession) Initialize(_l2Oracle common.Address, _guardian common.Address, ...) (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalSession) IsOutputFinalized(_l2OutputIndex *big.Int) (bool, error)

+ func (_OptimismPortal *OptimismPortalSession) L2ORACLE() (common.Address, error)

+ func (_OptimismPortal *OptimismPortalSession) L2Oracle() (common.Address, error)

+ func (_OptimismPortal *OptimismPortalSession) L2Sender() (common.Address, error)

+ func (_OptimismPortal *OptimismPortalSession) MinimumGasLimit(_byteCount uint64) (uint64, error)

+ func (_OptimismPortal *OptimismPortalSession) Params() (struct{ ... }, error)

+ func (_OptimismPortal *OptimismPortalSession) Pause() (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalSession) Paused() (bool, error)

+ func (_OptimismPortal *OptimismPortalSession) ProveWithdrawalTransaction(_tx TypesWithdrawalTransaction, _l2OutputIndex *big.Int, ...) (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalSession) ProvenWithdrawals(arg0 [32]byte) (struct{ ... }, error)

+ func (_OptimismPortal *OptimismPortalSession) Receive() (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalSession) SYSTEMCONFIG() (common.Address, error)

+ func (_OptimismPortal *OptimismPortalSession) SystemConfig() (common.Address, error)

+ func (_OptimismPortal *OptimismPortalSession) Unpause() (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalSession) Version() (string, error)

+ type OptimismPortalTransactionDeposited struct

+ From common.Address

+ OpaqueData []byte

+ Raw types.Log

+ To common.Address

+ Version *big.Int

+ type OptimismPortalTransactionDepositedIterator struct

+ Event *OptimismPortalTransactionDeposited

+ func (it *OptimismPortalTransactionDepositedIterator) Close() error

+ func (it *OptimismPortalTransactionDepositedIterator) Error() error

+ func (it *OptimismPortalTransactionDepositedIterator) Next() bool

+ type OptimismPortalTransactor struct

+ func NewOptimismPortalTransactor(address common.Address, transactor bind.ContractTransactor) (*OptimismPortalTransactor, error)

+ func (_OptimismPortal *OptimismPortalTransactor) DepositTransaction(opts *bind.TransactOpts, _to common.Address, _value *big.Int, _gasLimit uint64, ...) (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalTransactor) DonateETH(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalTransactor) FinalizeWithdrawalTransaction(opts *bind.TransactOpts, _tx TypesWithdrawalTransaction) (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalTransactor) Initialize(opts *bind.TransactOpts, _l2Oracle common.Address, _guardian common.Address, ...) (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalTransactor) ProveWithdrawalTransaction(opts *bind.TransactOpts, _tx TypesWithdrawalTransaction, ...) (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OptimismPortalTransactorRaw struct

+ Contract *OptimismPortalTransactor

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

+ func (_OptimismPortal *OptimismPortalTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OptimismPortalTransactorSession struct

+ Contract *OptimismPortalTransactor

+ TransactOpts bind.TransactOpts

+ func (_OptimismPortal *OptimismPortalTransactorSession) DepositTransaction(_to common.Address, _value *big.Int, _gasLimit uint64, _isCreation bool, ...) (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalTransactorSession) DonateETH() (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalTransactorSession) FinalizeWithdrawalTransaction(_tx TypesWithdrawalTransaction) (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalTransactorSession) Initialize(_l2Oracle common.Address, _guardian common.Address, ...) (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalTransactorSession) Pause() (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalTransactorSession) ProveWithdrawalTransaction(_tx TypesWithdrawalTransaction, _l2OutputIndex *big.Int, ...) (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalTransactorSession) Receive() (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalTransactorSession) Unpause() (*types.Transaction, error)

+ type OptimismPortalUnpaused struct

+ Account common.Address

+ Raw types.Log

+ type OptimismPortalUnpausedIterator struct

+ Event *OptimismPortalUnpaused

+ func (it *OptimismPortalUnpausedIterator) Close() error

+ func (it *OptimismPortalUnpausedIterator) Error() error

+ func (it *OptimismPortalUnpausedIterator) Next() bool

+ type OptimismPortalWithdrawalFinalized struct

+ Raw types.Log

+ Success bool

+ WithdrawalHash [32]byte

+ type OptimismPortalWithdrawalFinalizedIterator struct

+ Event *OptimismPortalWithdrawalFinalized

+ func (it *OptimismPortalWithdrawalFinalizedIterator) Close() error

+ func (it *OptimismPortalWithdrawalFinalizedIterator) Error() error

+ func (it *OptimismPortalWithdrawalFinalizedIterator) Next() bool

+ type OptimismPortalWithdrawalProven struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ WithdrawalHash [32]byte

+ type OptimismPortalWithdrawalProvenIterator struct

+ Event *OptimismPortalWithdrawalProven

+ func (it *OptimismPortalWithdrawalProvenIterator) Close() error

+ func (it *OptimismPortalWithdrawalProvenIterator) Error() error

+ func (it *OptimismPortalWithdrawalProvenIterator) Next() bool

+ type PreimageOracle struct

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

+ func NewPreimageOracle(address common.Address, backend bind.ContractBackend) (*PreimageOracle, error)

+ type PreimageOracleCaller struct

+ func NewPreimageOracleCaller(address common.Address, caller bind.ContractCaller) (*PreimageOracleCaller, error)

+ func (_PreimageOracle *PreimageOracleCaller) PreimageLengths(opts *bind.CallOpts, arg0 [32]byte) (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleCaller) PreimagePartOk(opts *bind.CallOpts, arg0 [32]byte, arg1 *big.Int) (bool, error)

+ func (_PreimageOracle *PreimageOracleCaller) PreimageParts(opts *bind.CallOpts, arg0 [32]byte, arg1 *big.Int) ([32]byte, error)

+ func (_PreimageOracle *PreimageOracleCaller) ReadPreimage(opts *bind.CallOpts, _key [32]byte, _offset *big.Int) (struct{ ... }, error)

+ type PreimageOracleCallerRaw struct

+ Contract *PreimageOracleCaller

+ func (_PreimageOracle *PreimageOracleCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type PreimageOracleCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *PreimageOracleCaller

+ func (_PreimageOracle *PreimageOracleCallerSession) PreimageLengths(arg0 [32]byte) (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleCallerSession) PreimagePartOk(arg0 [32]byte, arg1 *big.Int) (bool, error)

+ func (_PreimageOracle *PreimageOracleCallerSession) PreimageParts(arg0 [32]byte, arg1 *big.Int) ([32]byte, error)

+ func (_PreimageOracle *PreimageOracleCallerSession) ReadPreimage(_key [32]byte, _offset *big.Int) (struct{ ... }, error)

+ type PreimageOracleFilterer struct

+ func NewPreimageOracleFilterer(address common.Address, filterer bind.ContractFilterer) (*PreimageOracleFilterer, error)

+ type PreimageOracleRaw struct

+ Contract *PreimageOracle

+ func (_PreimageOracle *PreimageOracleRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_PreimageOracle *PreimageOracleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type PreimageOracleSession struct

+ CallOpts bind.CallOpts

+ Contract *PreimageOracle

+ TransactOpts bind.TransactOpts

+ func (_PreimageOracle *PreimageOracleSession) LoadKeccak256PreimagePart(_partOffset *big.Int, _preimage []byte) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleSession) LoadLocalData(_ident *big.Int, _localContext *big.Int, _word [32]byte, _size *big.Int, ...) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleSession) PreimageLengths(arg0 [32]byte) (*big.Int, error)

+ func (_PreimageOracle *PreimageOracleSession) PreimagePartOk(arg0 [32]byte, arg1 *big.Int) (bool, error)

+ func (_PreimageOracle *PreimageOracleSession) PreimageParts(arg0 [32]byte, arg1 *big.Int) ([32]byte, error)

+ func (_PreimageOracle *PreimageOracleSession) ReadPreimage(_key [32]byte, _offset *big.Int) (struct{ ... }, error)

+ type PreimageOracleTransactor struct

+ func NewPreimageOracleTransactor(address common.Address, transactor bind.ContractTransactor) (*PreimageOracleTransactor, error)

+ func (_PreimageOracle *PreimageOracleTransactor) LoadKeccak256PreimagePart(opts *bind.TransactOpts, _partOffset *big.Int, _preimage []byte) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleTransactor) LoadLocalData(opts *bind.TransactOpts, _ident *big.Int, _localContext *big.Int, ...) (*types.Transaction, error)

+ type PreimageOracleTransactorRaw struct

+ Contract *PreimageOracleTransactor

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

+ func (_PreimageOracle *PreimageOracleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type PreimageOracleTransactorSession struct

+ Contract *PreimageOracleTransactor

+ TransactOpts bind.TransactOpts

+ func (_PreimageOracle *PreimageOracleTransactorSession) LoadKeccak256PreimagePart(_partOffset *big.Int, _preimage []byte) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleTransactorSession) LoadLocalData(_ident *big.Int, _localContext *big.Int, _word [32]byte, _size *big.Int, ...) (*types.Transaction, error)

+ type ProtocolVersions struct

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

+ func NewProtocolVersions(address common.Address, backend bind.ContractBackend) (*ProtocolVersions, error)

+ type ProtocolVersionsCaller struct

+ func NewProtocolVersionsCaller(address common.Address, caller bind.ContractCaller) (*ProtocolVersionsCaller, error)

+ func (_ProtocolVersions *ProtocolVersionsCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_ProtocolVersions *ProtocolVersionsCaller) RECOMMENDEDSLOT(opts *bind.CallOpts) ([32]byte, error)

+ func (_ProtocolVersions *ProtocolVersionsCaller) REQUIREDSLOT(opts *bind.CallOpts) ([32]byte, error)

+ func (_ProtocolVersions *ProtocolVersionsCaller) Recommended(opts *bind.CallOpts) (*big.Int, error)

+ func (_ProtocolVersions *ProtocolVersionsCaller) Required(opts *bind.CallOpts) (*big.Int, error)

+ func (_ProtocolVersions *ProtocolVersionsCaller) VERSION(opts *bind.CallOpts) (*big.Int, error)

+ func (_ProtocolVersions *ProtocolVersionsCaller) Version(opts *bind.CallOpts) (string, error)

+ type ProtocolVersionsCallerRaw struct

+ Contract *ProtocolVersionsCaller

+ func (_ProtocolVersions *ProtocolVersionsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type ProtocolVersionsCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ProtocolVersionsCaller

+ func (_ProtocolVersions *ProtocolVersionsCallerSession) Owner() (common.Address, error)

+ func (_ProtocolVersions *ProtocolVersionsCallerSession) RECOMMENDEDSLOT() ([32]byte, error)

+ func (_ProtocolVersions *ProtocolVersionsCallerSession) REQUIREDSLOT() ([32]byte, error)

+ func (_ProtocolVersions *ProtocolVersionsCallerSession) Recommended() (*big.Int, error)

+ func (_ProtocolVersions *ProtocolVersionsCallerSession) Required() (*big.Int, error)

+ func (_ProtocolVersions *ProtocolVersionsCallerSession) VERSION() (*big.Int, error)

+ func (_ProtocolVersions *ProtocolVersionsCallerSession) Version() (string, error)

+ type ProtocolVersionsConfigUpdate struct

+ Data []byte

+ Raw types.Log

+ UpdateType uint8

+ Version *big.Int

+ type ProtocolVersionsConfigUpdateIterator struct

+ Event *ProtocolVersionsConfigUpdate

+ func (it *ProtocolVersionsConfigUpdateIterator) Close() error

+ func (it *ProtocolVersionsConfigUpdateIterator) Error() error

+ func (it *ProtocolVersionsConfigUpdateIterator) Next() bool

+ type ProtocolVersionsFilterer struct

+ func NewProtocolVersionsFilterer(address common.Address, filterer bind.ContractFilterer) (*ProtocolVersionsFilterer, error)

+ func (_ProtocolVersions *ProtocolVersionsFilterer) FilterConfigUpdate(opts *bind.FilterOpts, version []*big.Int, updateType []uint8) (*ProtocolVersionsConfigUpdateIterator, error)

+ func (_ProtocolVersions *ProtocolVersionsFilterer) FilterInitialized(opts *bind.FilterOpts) (*ProtocolVersionsInitializedIterator, error)

+ func (_ProtocolVersions *ProtocolVersionsFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*ProtocolVersionsOwnershipTransferredIterator, error)

+ func (_ProtocolVersions *ProtocolVersionsFilterer) ParseConfigUpdate(log types.Log) (*ProtocolVersionsConfigUpdate, error)

+ func (_ProtocolVersions *ProtocolVersionsFilterer) ParseInitialized(log types.Log) (*ProtocolVersionsInitialized, error)

+ func (_ProtocolVersions *ProtocolVersionsFilterer) ParseOwnershipTransferred(log types.Log) (*ProtocolVersionsOwnershipTransferred, error)

+ func (_ProtocolVersions *ProtocolVersionsFilterer) WatchConfigUpdate(opts *bind.WatchOpts, sink chan<- *ProtocolVersionsConfigUpdate, ...) (event.Subscription, error)

+ func (_ProtocolVersions *ProtocolVersionsFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *ProtocolVersionsInitialized) (event.Subscription, error)

+ func (_ProtocolVersions *ProtocolVersionsFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ProtocolVersionsOwnershipTransferred, ...) (event.Subscription, error)

+ type ProtocolVersionsInitialized struct

+ Raw types.Log

+ Version uint8

+ type ProtocolVersionsInitializedIterator struct

+ Event *ProtocolVersionsInitialized

+ func (it *ProtocolVersionsInitializedIterator) Close() error

+ func (it *ProtocolVersionsInitializedIterator) Error() error

+ func (it *ProtocolVersionsInitializedIterator) Next() bool

+ type ProtocolVersionsOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type ProtocolVersionsOwnershipTransferredIterator struct

+ Event *ProtocolVersionsOwnershipTransferred

+ func (it *ProtocolVersionsOwnershipTransferredIterator) Close() error

+ func (it *ProtocolVersionsOwnershipTransferredIterator) Error() error

+ func (it *ProtocolVersionsOwnershipTransferredIterator) Next() bool

+ type ProtocolVersionsRaw struct

+ Contract *ProtocolVersions

+ func (_ProtocolVersions *ProtocolVersionsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_ProtocolVersions *ProtocolVersionsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ProtocolVersionsSession struct

+ CallOpts bind.CallOpts

+ Contract *ProtocolVersions

+ TransactOpts bind.TransactOpts

+ func (_ProtocolVersions *ProtocolVersionsSession) Initialize(_owner common.Address, _required *big.Int, _recommended *big.Int) (*types.Transaction, error)

+ func (_ProtocolVersions *ProtocolVersionsSession) Owner() (common.Address, error)

+ func (_ProtocolVersions *ProtocolVersionsSession) RECOMMENDEDSLOT() ([32]byte, error)

+ func (_ProtocolVersions *ProtocolVersionsSession) REQUIREDSLOT() ([32]byte, error)

+ func (_ProtocolVersions *ProtocolVersionsSession) Recommended() (*big.Int, error)

+ func (_ProtocolVersions *ProtocolVersionsSession) RenounceOwnership() (*types.Transaction, error)

+ func (_ProtocolVersions *ProtocolVersionsSession) Required() (*big.Int, error)

+ func (_ProtocolVersions *ProtocolVersionsSession) SetRecommended(_recommended *big.Int) (*types.Transaction, error)

+ func (_ProtocolVersions *ProtocolVersionsSession) SetRequired(_required *big.Int) (*types.Transaction, error)

+ func (_ProtocolVersions *ProtocolVersionsSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_ProtocolVersions *ProtocolVersionsSession) VERSION() (*big.Int, error)

+ func (_ProtocolVersions *ProtocolVersionsSession) Version() (string, error)

+ type ProtocolVersionsTransactor struct

+ func NewProtocolVersionsTransactor(address common.Address, transactor bind.ContractTransactor) (*ProtocolVersionsTransactor, error)

+ func (_ProtocolVersions *ProtocolVersionsTransactor) Initialize(opts *bind.TransactOpts, _owner common.Address, _required *big.Int, ...) (*types.Transaction, error)

+ func (_ProtocolVersions *ProtocolVersionsTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_ProtocolVersions *ProtocolVersionsTransactor) SetRecommended(opts *bind.TransactOpts, _recommended *big.Int) (*types.Transaction, error)

+ func (_ProtocolVersions *ProtocolVersionsTransactor) SetRequired(opts *bind.TransactOpts, _required *big.Int) (*types.Transaction, error)

+ func (_ProtocolVersions *ProtocolVersionsTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type ProtocolVersionsTransactorRaw struct

+ Contract *ProtocolVersionsTransactor

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

+ func (_ProtocolVersions *ProtocolVersionsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ProtocolVersionsTransactorSession struct

+ Contract *ProtocolVersionsTransactor

+ TransactOpts bind.TransactOpts

+ func (_ProtocolVersions *ProtocolVersionsTransactorSession) Initialize(_owner common.Address, _required *big.Int, _recommended *big.Int) (*types.Transaction, error)

+ func (_ProtocolVersions *ProtocolVersionsTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_ProtocolVersions *ProtocolVersionsTransactorSession) SetRecommended(_recommended *big.Int) (*types.Transaction, error)

+ func (_ProtocolVersions *ProtocolVersionsTransactorSession) SetRequired(_required *big.Int) (*types.Transaction, error)

+ func (_ProtocolVersions *ProtocolVersionsTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

type ProxyAdminCaller

+ func (_ProxyAdmin *ProxyAdminCaller) AddressManager(opts *bind.CallOpts) (common.Address, error)

+ func (_ProxyAdmin *ProxyAdminCaller) ImplementationName(opts *bind.CallOpts, arg0 common.Address) (string, error)

+ func (_ProxyAdmin *ProxyAdminCaller) IsUpgrading(opts *bind.CallOpts) (bool, error)

+ func (_ProxyAdmin *ProxyAdminCaller) ProxyType(opts *bind.CallOpts, arg0 common.Address) (uint8, error)

type ProxyAdminCallerSession

+ func (_ProxyAdmin *ProxyAdminCallerSession) AddressManager() (common.Address, error)

+ func (_ProxyAdmin *ProxyAdminCallerSession) ImplementationName(arg0 common.Address) (string, error)

+ func (_ProxyAdmin *ProxyAdminCallerSession) IsUpgrading() (bool, error)

+ func (_ProxyAdmin *ProxyAdminCallerSession) ProxyType(arg0 common.Address) (uint8, error)

type ProxyAdminSession

+ func (_ProxyAdmin *ProxyAdminSession) AddressManager() (common.Address, error)

+ func (_ProxyAdmin *ProxyAdminSession) ImplementationName(arg0 common.Address) (string, error)

+ func (_ProxyAdmin *ProxyAdminSession) IsUpgrading() (bool, error)

+ func (_ProxyAdmin *ProxyAdminSession) ProxyType(arg0 common.Address) (uint8, error)

+ func (_ProxyAdmin *ProxyAdminSession) SetAddress(_name string, _address common.Address) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminSession) SetAddressManager(_address common.Address) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminSession) SetImplementationName(_address common.Address, _name string) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminSession) SetProxyType(_address common.Address, _type uint8) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminSession) SetUpgrading(_upgrading bool) (*types.Transaction, error)

type ProxyAdminTransactor

+ func (_ProxyAdmin *ProxyAdminTransactor) SetAddress(opts *bind.TransactOpts, _name string, _address common.Address) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminTransactor) SetAddressManager(opts *bind.TransactOpts, _address common.Address) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminTransactor) SetImplementationName(opts *bind.TransactOpts, _address common.Address, _name string) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminTransactor) SetProxyType(opts *bind.TransactOpts, _address common.Address, _type uint8) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminTransactor) SetUpgrading(opts *bind.TransactOpts, _upgrading bool) (*types.Transaction, error)

type ProxyAdminTransactorSession

+ func (_ProxyAdmin *ProxyAdminTransactorSession) SetAddress(_name string, _address common.Address) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminTransactorSession) SetAddressManager(_address common.Address) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminTransactorSession) SetImplementationName(_address common.Address, _name string) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminTransactorSession) SetProxyType(_address common.Address, _type uint8) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminTransactorSession) SetUpgrading(_upgrading bool) (*types.Transaction, error)

+ type RevocationRequest struct

+ Data RevocationRequestData

+ Schema [32]byte

+ type RevocationRequestData struct

+ Uid [32]byte

+ Value *big.Int

+ type Safe struct

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

+ func NewSafe(address common.Address, backend bind.ContractBackend) (*Safe, error)

+ type SafeAddedOwner struct

+ Owner common.Address

+ Raw types.Log

+ type SafeAddedOwnerIterator struct

+ Event *SafeAddedOwner

+ func (it *SafeAddedOwnerIterator) Close() error

+ func (it *SafeAddedOwnerIterator) Error() error

+ func (it *SafeAddedOwnerIterator) Next() bool

+ type SafeApproveHash struct

+ ApprovedHash [32]byte

+ Owner common.Address

+ Raw types.Log

+ type SafeApproveHashIterator struct

+ Event *SafeApproveHash

+ func (it *SafeApproveHashIterator) Close() error

+ func (it *SafeApproveHashIterator) Error() error

+ func (it *SafeApproveHashIterator) Next() bool

+ type SafeCaller struct

+ func NewSafeCaller(address common.Address, caller bind.ContractCaller) (*SafeCaller, error)

+ func (_Safe *SafeCaller) ApprovedHashes(opts *bind.CallOpts, arg0 common.Address, arg1 [32]byte) (*big.Int, error)

+ func (_Safe *SafeCaller) CheckNSignatures(opts *bind.CallOpts, dataHash [32]byte, data []byte, signatures []byte, ...) error

+ func (_Safe *SafeCaller) CheckSignatures(opts *bind.CallOpts, dataHash [32]byte, data []byte, signatures []byte) error

+ func (_Safe *SafeCaller) DomainSeparator(opts *bind.CallOpts) ([32]byte, error)

+ func (_Safe *SafeCaller) EncodeTransactionData(opts *bind.CallOpts, to common.Address, value *big.Int, data []byte, ...) ([]byte, error)

+ func (_Safe *SafeCaller) GetChainId(opts *bind.CallOpts) (*big.Int, error)

+ func (_Safe *SafeCaller) GetModulesPaginated(opts *bind.CallOpts, start common.Address, pageSize *big.Int) (struct{ ... }, error)

+ func (_Safe *SafeCaller) GetOwners(opts *bind.CallOpts) ([]common.Address, error)

+ func (_Safe *SafeCaller) GetStorageAt(opts *bind.CallOpts, offset *big.Int, length *big.Int) ([]byte, error)

+ func (_Safe *SafeCaller) GetThreshold(opts *bind.CallOpts) (*big.Int, error)

+ func (_Safe *SafeCaller) GetTransactionHash(opts *bind.CallOpts, to common.Address, value *big.Int, data []byte, ...) ([32]byte, error)

+ func (_Safe *SafeCaller) IsModuleEnabled(opts *bind.CallOpts, module common.Address) (bool, error)

+ func (_Safe *SafeCaller) IsOwner(opts *bind.CallOpts, owner common.Address) (bool, error)

+ func (_Safe *SafeCaller) Nonce(opts *bind.CallOpts) (*big.Int, error)

+ func (_Safe *SafeCaller) SignedMessages(opts *bind.CallOpts, arg0 [32]byte) (*big.Int, error)

+ func (_Safe *SafeCaller) VERSION(opts *bind.CallOpts) (string, error)

+ type SafeCallerRaw struct

+ Contract *SafeCaller

+ func (_Safe *SafeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type SafeCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SafeCaller

+ func (_Safe *SafeCallerSession) ApprovedHashes(arg0 common.Address, arg1 [32]byte) (*big.Int, error)

+ func (_Safe *SafeCallerSession) CheckNSignatures(dataHash [32]byte, data []byte, signatures []byte, requiredSignatures *big.Int) error

+ func (_Safe *SafeCallerSession) CheckSignatures(dataHash [32]byte, data []byte, signatures []byte) error

+ func (_Safe *SafeCallerSession) DomainSeparator() ([32]byte, error)

+ func (_Safe *SafeCallerSession) EncodeTransactionData(to common.Address, value *big.Int, data []byte, operation uint8, ...) ([]byte, error)

+ func (_Safe *SafeCallerSession) GetChainId() (*big.Int, error)

+ func (_Safe *SafeCallerSession) GetModulesPaginated(start common.Address, pageSize *big.Int) (struct{ ... }, error)

+ func (_Safe *SafeCallerSession) GetOwners() ([]common.Address, error)

+ func (_Safe *SafeCallerSession) GetStorageAt(offset *big.Int, length *big.Int) ([]byte, error)

+ func (_Safe *SafeCallerSession) GetThreshold() (*big.Int, error)

+ func (_Safe *SafeCallerSession) GetTransactionHash(to common.Address, value *big.Int, data []byte, operation uint8, ...) ([32]byte, error)

+ func (_Safe *SafeCallerSession) IsModuleEnabled(module common.Address) (bool, error)

+ func (_Safe *SafeCallerSession) IsOwner(owner common.Address) (bool, error)

+ func (_Safe *SafeCallerSession) Nonce() (*big.Int, error)

+ func (_Safe *SafeCallerSession) SignedMessages(arg0 [32]byte) (*big.Int, error)

+ func (_Safe *SafeCallerSession) VERSION() (string, error)

+ type SafeChangedFallbackHandler struct

+ Handler common.Address

+ Raw types.Log

+ type SafeChangedFallbackHandlerIterator struct

+ Event *SafeChangedFallbackHandler

+ func (it *SafeChangedFallbackHandlerIterator) Close() error

+ func (it *SafeChangedFallbackHandlerIterator) Error() error

+ func (it *SafeChangedFallbackHandlerIterator) Next() bool

+ type SafeChangedGuard struct

+ Guard common.Address

+ Raw types.Log

+ type SafeChangedGuardIterator struct

+ Event *SafeChangedGuard

+ func (it *SafeChangedGuardIterator) Close() error

+ func (it *SafeChangedGuardIterator) Error() error

+ func (it *SafeChangedGuardIterator) Next() bool

+ type SafeChangedThreshold struct

+ Raw types.Log

+ Threshold *big.Int

+ type SafeChangedThresholdIterator struct

+ Event *SafeChangedThreshold

+ func (it *SafeChangedThresholdIterator) Close() error

+ func (it *SafeChangedThresholdIterator) Error() error

+ func (it *SafeChangedThresholdIterator) Next() bool

+ type SafeDisabledModule struct

+ Module common.Address

+ Raw types.Log

+ type SafeDisabledModuleIterator struct

+ Event *SafeDisabledModule

+ func (it *SafeDisabledModuleIterator) Close() error

+ func (it *SafeDisabledModuleIterator) Error() error

+ func (it *SafeDisabledModuleIterator) Next() bool

+ type SafeEnabledModule struct

+ Module common.Address

+ Raw types.Log

+ type SafeEnabledModuleIterator struct

+ Event *SafeEnabledModule

+ func (it *SafeEnabledModuleIterator) Close() error

+ func (it *SafeEnabledModuleIterator) Error() error

+ func (it *SafeEnabledModuleIterator) Next() bool

+ type SafeExecutionFailure struct

+ Payment *big.Int

+ Raw types.Log

+ TxHash [32]byte

+ type SafeExecutionFailureIterator struct

+ Event *SafeExecutionFailure

+ func (it *SafeExecutionFailureIterator) Close() error

+ func (it *SafeExecutionFailureIterator) Error() error

+ func (it *SafeExecutionFailureIterator) Next() bool

+ type SafeExecutionFromModuleFailure struct

+ Module common.Address

+ Raw types.Log

+ type SafeExecutionFromModuleFailureIterator struct

+ Event *SafeExecutionFromModuleFailure

+ func (it *SafeExecutionFromModuleFailureIterator) Close() error

+ func (it *SafeExecutionFromModuleFailureIterator) Error() error

+ func (it *SafeExecutionFromModuleFailureIterator) Next() bool

+ type SafeExecutionFromModuleSuccess struct

+ Module common.Address

+ Raw types.Log

+ type SafeExecutionFromModuleSuccessIterator struct

+ Event *SafeExecutionFromModuleSuccess

+ func (it *SafeExecutionFromModuleSuccessIterator) Close() error

+ func (it *SafeExecutionFromModuleSuccessIterator) Error() error

+ func (it *SafeExecutionFromModuleSuccessIterator) Next() bool

+ type SafeExecutionSuccess struct

+ Payment *big.Int

+ Raw types.Log

+ TxHash [32]byte

+ type SafeExecutionSuccessIterator struct

+ Event *SafeExecutionSuccess

+ func (it *SafeExecutionSuccessIterator) Close() error

+ func (it *SafeExecutionSuccessIterator) Error() error

+ func (it *SafeExecutionSuccessIterator) Next() bool

+ type SafeFilterer struct

+ func NewSafeFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeFilterer, error)

+ func (_Safe *SafeFilterer) FilterAddedOwner(opts *bind.FilterOpts, owner []common.Address) (*SafeAddedOwnerIterator, error)

+ func (_Safe *SafeFilterer) FilterApproveHash(opts *bind.FilterOpts, approvedHash [][32]byte, owner []common.Address) (*SafeApproveHashIterator, error)

+ func (_Safe *SafeFilterer) FilterChangedFallbackHandler(opts *bind.FilterOpts, handler []common.Address) (*SafeChangedFallbackHandlerIterator, error)

+ func (_Safe *SafeFilterer) FilterChangedGuard(opts *bind.FilterOpts, guard []common.Address) (*SafeChangedGuardIterator, error)

+ func (_Safe *SafeFilterer) FilterChangedThreshold(opts *bind.FilterOpts) (*SafeChangedThresholdIterator, error)

+ func (_Safe *SafeFilterer) FilterDisabledModule(opts *bind.FilterOpts, module []common.Address) (*SafeDisabledModuleIterator, error)

+ func (_Safe *SafeFilterer) FilterEnabledModule(opts *bind.FilterOpts, module []common.Address) (*SafeEnabledModuleIterator, error)

+ func (_Safe *SafeFilterer) FilterExecutionFailure(opts *bind.FilterOpts, txHash [][32]byte) (*SafeExecutionFailureIterator, error)

+ func (_Safe *SafeFilterer) FilterExecutionFromModuleFailure(opts *bind.FilterOpts, module []common.Address) (*SafeExecutionFromModuleFailureIterator, error)

+ func (_Safe *SafeFilterer) FilterExecutionFromModuleSuccess(opts *bind.FilterOpts, module []common.Address) (*SafeExecutionFromModuleSuccessIterator, error)

+ func (_Safe *SafeFilterer) FilterExecutionSuccess(opts *bind.FilterOpts, txHash [][32]byte) (*SafeExecutionSuccessIterator, error)

+ func (_Safe *SafeFilterer) FilterRemovedOwner(opts *bind.FilterOpts, owner []common.Address) (*SafeRemovedOwnerIterator, error)

+ func (_Safe *SafeFilterer) FilterSafeReceived(opts *bind.FilterOpts, sender []common.Address) (*SafeSafeReceivedIterator, error)

+ func (_Safe *SafeFilterer) FilterSafeSetup(opts *bind.FilterOpts, initiator []common.Address) (*SafeSafeSetupIterator, error)

+ func (_Safe *SafeFilterer) FilterSignMsg(opts *bind.FilterOpts, msgHash [][32]byte) (*SafeSignMsgIterator, error)

+ func (_Safe *SafeFilterer) ParseAddedOwner(log types.Log) (*SafeAddedOwner, error)

+ func (_Safe *SafeFilterer) ParseApproveHash(log types.Log) (*SafeApproveHash, error)

+ func (_Safe *SafeFilterer) ParseChangedFallbackHandler(log types.Log) (*SafeChangedFallbackHandler, error)

+ func (_Safe *SafeFilterer) ParseChangedGuard(log types.Log) (*SafeChangedGuard, error)

+ func (_Safe *SafeFilterer) ParseChangedThreshold(log types.Log) (*SafeChangedThreshold, error)

+ func (_Safe *SafeFilterer) ParseDisabledModule(log types.Log) (*SafeDisabledModule, error)

+ func (_Safe *SafeFilterer) ParseEnabledModule(log types.Log) (*SafeEnabledModule, error)

+ func (_Safe *SafeFilterer) ParseExecutionFailure(log types.Log) (*SafeExecutionFailure, error)

+ func (_Safe *SafeFilterer) ParseExecutionFromModuleFailure(log types.Log) (*SafeExecutionFromModuleFailure, error)

+ func (_Safe *SafeFilterer) ParseExecutionFromModuleSuccess(log types.Log) (*SafeExecutionFromModuleSuccess, error)

+ func (_Safe *SafeFilterer) ParseExecutionSuccess(log types.Log) (*SafeExecutionSuccess, error)

+ func (_Safe *SafeFilterer) ParseRemovedOwner(log types.Log) (*SafeRemovedOwner, error)

+ func (_Safe *SafeFilterer) ParseSafeReceived(log types.Log) (*SafeSafeReceived, error)

+ func (_Safe *SafeFilterer) ParseSafeSetup(log types.Log) (*SafeSafeSetup, error)

+ func (_Safe *SafeFilterer) ParseSignMsg(log types.Log) (*SafeSignMsg, error)

+ func (_Safe *SafeFilterer) WatchAddedOwner(opts *bind.WatchOpts, sink chan<- *SafeAddedOwner, owner []common.Address) (event.Subscription, error)

+ func (_Safe *SafeFilterer) WatchApproveHash(opts *bind.WatchOpts, sink chan<- *SafeApproveHash, approvedHash [][32]byte, ...) (event.Subscription, error)

+ func (_Safe *SafeFilterer) WatchChangedFallbackHandler(opts *bind.WatchOpts, sink chan<- *SafeChangedFallbackHandler, ...) (event.Subscription, error)

+ func (_Safe *SafeFilterer) WatchChangedGuard(opts *bind.WatchOpts, sink chan<- *SafeChangedGuard, guard []common.Address) (event.Subscription, error)

+ func (_Safe *SafeFilterer) WatchChangedThreshold(opts *bind.WatchOpts, sink chan<- *SafeChangedThreshold) (event.Subscription, error)

+ func (_Safe *SafeFilterer) WatchDisabledModule(opts *bind.WatchOpts, sink chan<- *SafeDisabledModule, module []common.Address) (event.Subscription, error)

+ func (_Safe *SafeFilterer) WatchEnabledModule(opts *bind.WatchOpts, sink chan<- *SafeEnabledModule, module []common.Address) (event.Subscription, error)

+ func (_Safe *SafeFilterer) WatchExecutionFailure(opts *bind.WatchOpts, sink chan<- *SafeExecutionFailure, txHash [][32]byte) (event.Subscription, error)

+ func (_Safe *SafeFilterer) WatchExecutionFromModuleFailure(opts *bind.WatchOpts, sink chan<- *SafeExecutionFromModuleFailure, ...) (event.Subscription, error)

+ func (_Safe *SafeFilterer) WatchExecutionFromModuleSuccess(opts *bind.WatchOpts, sink chan<- *SafeExecutionFromModuleSuccess, ...) (event.Subscription, error)

+ func (_Safe *SafeFilterer) WatchExecutionSuccess(opts *bind.WatchOpts, sink chan<- *SafeExecutionSuccess, txHash [][32]byte) (event.Subscription, error)

+ func (_Safe *SafeFilterer) WatchRemovedOwner(opts *bind.WatchOpts, sink chan<- *SafeRemovedOwner, owner []common.Address) (event.Subscription, error)

+ func (_Safe *SafeFilterer) WatchSafeReceived(opts *bind.WatchOpts, sink chan<- *SafeSafeReceived, sender []common.Address) (event.Subscription, error)

+ func (_Safe *SafeFilterer) WatchSafeSetup(opts *bind.WatchOpts, sink chan<- *SafeSafeSetup, initiator []common.Address) (event.Subscription, error)

+ func (_Safe *SafeFilterer) WatchSignMsg(opts *bind.WatchOpts, sink chan<- *SafeSignMsg, msgHash [][32]byte) (event.Subscription, error)

+ type SafeProxyFactory struct

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

+ func NewSafeProxyFactory(address common.Address, backend bind.ContractBackend) (*SafeProxyFactory, error)

+ type SafeProxyFactoryCaller struct

+ func NewSafeProxyFactoryCaller(address common.Address, caller bind.ContractCaller) (*SafeProxyFactoryCaller, error)

+ func (_SafeProxyFactory *SafeProxyFactoryCaller) GetChainId(opts *bind.CallOpts) (*big.Int, error)

+ func (_SafeProxyFactory *SafeProxyFactoryCaller) ProxyCreationCode(opts *bind.CallOpts) ([]byte, error)

+ type SafeProxyFactoryCallerRaw struct

+ Contract *SafeProxyFactoryCaller

+ func (_SafeProxyFactory *SafeProxyFactoryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type SafeProxyFactoryCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SafeProxyFactoryCaller

+ func (_SafeProxyFactory *SafeProxyFactoryCallerSession) GetChainId() (*big.Int, error)

+ func (_SafeProxyFactory *SafeProxyFactoryCallerSession) ProxyCreationCode() ([]byte, error)

+ type SafeProxyFactoryFilterer struct

+ func NewSafeProxyFactoryFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeProxyFactoryFilterer, error)

+ func (_SafeProxyFactory *SafeProxyFactoryFilterer) FilterProxyCreation(opts *bind.FilterOpts, proxy []common.Address) (*SafeProxyFactoryProxyCreationIterator, error)

+ func (_SafeProxyFactory *SafeProxyFactoryFilterer) ParseProxyCreation(log types.Log) (*SafeProxyFactoryProxyCreation, error)

+ func (_SafeProxyFactory *SafeProxyFactoryFilterer) WatchProxyCreation(opts *bind.WatchOpts, sink chan<- *SafeProxyFactoryProxyCreation, ...) (event.Subscription, error)

+ type SafeProxyFactoryProxyCreation struct

+ Proxy common.Address

+ Raw types.Log

+ Singleton common.Address

+ type SafeProxyFactoryProxyCreationIterator struct

+ Event *SafeProxyFactoryProxyCreation

+ func (it *SafeProxyFactoryProxyCreationIterator) Close() error

+ func (it *SafeProxyFactoryProxyCreationIterator) Error() error

+ func (it *SafeProxyFactoryProxyCreationIterator) Next() bool

+ type SafeProxyFactoryRaw struct

+ Contract *SafeProxyFactory

+ func (_SafeProxyFactory *SafeProxyFactoryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_SafeProxyFactory *SafeProxyFactoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeProxyFactorySession struct

+ CallOpts bind.CallOpts

+ Contract *SafeProxyFactory

+ TransactOpts bind.TransactOpts

+ func (_SafeProxyFactory *SafeProxyFactorySession) CreateChainSpecificProxyWithNonce(_singleton common.Address, initializer []byte, saltNonce *big.Int) (*types.Transaction, error)

+ func (_SafeProxyFactory *SafeProxyFactorySession) CreateProxyWithCallback(_singleton common.Address, initializer []byte, saltNonce *big.Int, ...) (*types.Transaction, error)

+ func (_SafeProxyFactory *SafeProxyFactorySession) CreateProxyWithNonce(_singleton common.Address, initializer []byte, saltNonce *big.Int) (*types.Transaction, error)

+ func (_SafeProxyFactory *SafeProxyFactorySession) GetChainId() (*big.Int, error)

+ func (_SafeProxyFactory *SafeProxyFactorySession) ProxyCreationCode() ([]byte, error)

+ type SafeProxyFactoryTransactor struct

+ func NewSafeProxyFactoryTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeProxyFactoryTransactor, error)

+ func (_SafeProxyFactory *SafeProxyFactoryTransactor) CreateChainSpecificProxyWithNonce(opts *bind.TransactOpts, _singleton common.Address, initializer []byte, ...) (*types.Transaction, error)

+ func (_SafeProxyFactory *SafeProxyFactoryTransactor) CreateProxyWithCallback(opts *bind.TransactOpts, _singleton common.Address, initializer []byte, ...) (*types.Transaction, error)

+ func (_SafeProxyFactory *SafeProxyFactoryTransactor) CreateProxyWithNonce(opts *bind.TransactOpts, _singleton common.Address, initializer []byte, ...) (*types.Transaction, error)

+ type SafeProxyFactoryTransactorRaw struct

+ Contract *SafeProxyFactoryTransactor

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

+ func (_SafeProxyFactory *SafeProxyFactoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeProxyFactoryTransactorSession struct

+ Contract *SafeProxyFactoryTransactor

+ TransactOpts bind.TransactOpts

+ func (_SafeProxyFactory *SafeProxyFactoryTransactorSession) CreateChainSpecificProxyWithNonce(_singleton common.Address, initializer []byte, saltNonce *big.Int) (*types.Transaction, error)

+ func (_SafeProxyFactory *SafeProxyFactoryTransactorSession) CreateProxyWithCallback(_singleton common.Address, initializer []byte, saltNonce *big.Int, ...) (*types.Transaction, error)

+ func (_SafeProxyFactory *SafeProxyFactoryTransactorSession) CreateProxyWithNonce(_singleton common.Address, initializer []byte, saltNonce *big.Int) (*types.Transaction, error)

+ type SafeRaw struct

+ Contract *Safe

+ func (_Safe *SafeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_Safe *SafeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeRemovedOwner struct

+ Owner common.Address

+ Raw types.Log

+ type SafeRemovedOwnerIterator struct

+ Event *SafeRemovedOwner

+ func (it *SafeRemovedOwnerIterator) Close() error

+ func (it *SafeRemovedOwnerIterator) Error() error

+ func (it *SafeRemovedOwnerIterator) Next() bool

+ type SafeSafeReceived struct

+ Raw types.Log

+ Sender common.Address

+ Value *big.Int

+ type SafeSafeReceivedIterator struct

+ Event *SafeSafeReceived

+ func (it *SafeSafeReceivedIterator) Close() error

+ func (it *SafeSafeReceivedIterator) Error() error

+ func (it *SafeSafeReceivedIterator) Next() bool

+ type SafeSafeSetup struct

+ FallbackHandler common.Address

+ Initializer common.Address

+ Initiator common.Address

+ Owners []common.Address

+ Raw types.Log

+ Threshold *big.Int

+ type SafeSafeSetupIterator struct

+ Event *SafeSafeSetup

+ func (it *SafeSafeSetupIterator) Close() error

+ func (it *SafeSafeSetupIterator) Error() error

+ func (it *SafeSafeSetupIterator) Next() bool

+ type SafeSession struct

+ CallOpts bind.CallOpts

+ Contract *Safe

+ TransactOpts bind.TransactOpts

+ func (_Safe *SafeSession) AddOwnerWithThreshold(owner common.Address, _threshold *big.Int) (*types.Transaction, error)

+ func (_Safe *SafeSession) ApproveHash(hashToApprove [32]byte) (*types.Transaction, error)

+ func (_Safe *SafeSession) ApprovedHashes(arg0 common.Address, arg1 [32]byte) (*big.Int, error)

+ func (_Safe *SafeSession) ChangeThreshold(_threshold *big.Int) (*types.Transaction, error)

+ func (_Safe *SafeSession) CheckNSignatures(dataHash [32]byte, data []byte, signatures []byte, requiredSignatures *big.Int) error

+ func (_Safe *SafeSession) CheckSignatures(dataHash [32]byte, data []byte, signatures []byte) error

+ func (_Safe *SafeSession) DisableModule(prevModule common.Address, module common.Address) (*types.Transaction, error)

+ func (_Safe *SafeSession) DomainSeparator() ([32]byte, error)

+ func (_Safe *SafeSession) EnableModule(module common.Address) (*types.Transaction, error)

+ func (_Safe *SafeSession) EncodeTransactionData(to common.Address, value *big.Int, data []byte, operation uint8, ...) ([]byte, error)

+ func (_Safe *SafeSession) ExecTransaction(to common.Address, value *big.Int, data []byte, operation uint8, ...) (*types.Transaction, error)

+ func (_Safe *SafeSession) ExecTransactionFromModule(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

+ func (_Safe *SafeSession) ExecTransactionFromModuleReturnData(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

+ func (_Safe *SafeSession) Fallback(calldata []byte) (*types.Transaction, error)

+ func (_Safe *SafeSession) GetChainId() (*big.Int, error)

+ func (_Safe *SafeSession) GetModulesPaginated(start common.Address, pageSize *big.Int) (struct{ ... }, error)

+ func (_Safe *SafeSession) GetOwners() ([]common.Address, error)

+ func (_Safe *SafeSession) GetStorageAt(offset *big.Int, length *big.Int) ([]byte, error)

+ func (_Safe *SafeSession) GetThreshold() (*big.Int, error)

+ func (_Safe *SafeSession) GetTransactionHash(to common.Address, value *big.Int, data []byte, operation uint8, ...) ([32]byte, error)

+ func (_Safe *SafeSession) IsModuleEnabled(module common.Address) (bool, error)

+ func (_Safe *SafeSession) IsOwner(owner common.Address) (bool, error)

+ func (_Safe *SafeSession) Nonce() (*big.Int, error)

+ func (_Safe *SafeSession) Receive() (*types.Transaction, error)

+ func (_Safe *SafeSession) RemoveOwner(prevOwner common.Address, owner common.Address, _threshold *big.Int) (*types.Transaction, error)

+ func (_Safe *SafeSession) SetFallbackHandler(handler common.Address) (*types.Transaction, error)

+ func (_Safe *SafeSession) SetGuard(guard common.Address) (*types.Transaction, error)

+ func (_Safe *SafeSession) Setup(_owners []common.Address, _threshold *big.Int, to common.Address, data []byte, ...) (*types.Transaction, error)

+ func (_Safe *SafeSession) SignedMessages(arg0 [32]byte) (*big.Int, error)

+ func (_Safe *SafeSession) SimulateAndRevert(targetContract common.Address, calldataPayload []byte) (*types.Transaction, error)

+ func (_Safe *SafeSession) SwapOwner(prevOwner common.Address, oldOwner common.Address, newOwner common.Address) (*types.Transaction, error)

+ func (_Safe *SafeSession) VERSION() (string, error)

+ type SafeSignMsg struct

+ MsgHash [32]byte

+ Raw types.Log

+ type SafeSignMsgIterator struct

+ Event *SafeSignMsg

+ func (it *SafeSignMsgIterator) Close() error

+ func (it *SafeSignMsgIterator) Error() error

+ func (it *SafeSignMsgIterator) Next() bool

+ type SafeTransactor struct

+ func NewSafeTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeTransactor, error)

+ func (_Safe *SafeTransactor) AddOwnerWithThreshold(opts *bind.TransactOpts, owner common.Address, _threshold *big.Int) (*types.Transaction, error)

+ func (_Safe *SafeTransactor) ApproveHash(opts *bind.TransactOpts, hashToApprove [32]byte) (*types.Transaction, error)

+ func (_Safe *SafeTransactor) ChangeThreshold(opts *bind.TransactOpts, _threshold *big.Int) (*types.Transaction, error)

+ func (_Safe *SafeTransactor) DisableModule(opts *bind.TransactOpts, prevModule common.Address, module common.Address) (*types.Transaction, error)

+ func (_Safe *SafeTransactor) EnableModule(opts *bind.TransactOpts, module common.Address) (*types.Transaction, error)

+ func (_Safe *SafeTransactor) ExecTransaction(opts *bind.TransactOpts, to common.Address, value *big.Int, data []byte, ...) (*types.Transaction, error)

+ func (_Safe *SafeTransactor) ExecTransactionFromModule(opts *bind.TransactOpts, to common.Address, value *big.Int, data []byte, ...) (*types.Transaction, error)

+ func (_Safe *SafeTransactor) ExecTransactionFromModuleReturnData(opts *bind.TransactOpts, to common.Address, value *big.Int, data []byte, ...) (*types.Transaction, error)

+ func (_Safe *SafeTransactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error)

+ func (_Safe *SafeTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Safe *SafeTransactor) RemoveOwner(opts *bind.TransactOpts, prevOwner common.Address, owner common.Address, ...) (*types.Transaction, error)

+ func (_Safe *SafeTransactor) SetFallbackHandler(opts *bind.TransactOpts, handler common.Address) (*types.Transaction, error)

+ func (_Safe *SafeTransactor) SetGuard(opts *bind.TransactOpts, guard common.Address) (*types.Transaction, error)

+ func (_Safe *SafeTransactor) Setup(opts *bind.TransactOpts, _owners []common.Address, _threshold *big.Int, ...) (*types.Transaction, error)

+ func (_Safe *SafeTransactor) SimulateAndRevert(opts *bind.TransactOpts, targetContract common.Address, calldataPayload []byte) (*types.Transaction, error)

+ func (_Safe *SafeTransactor) SwapOwner(opts *bind.TransactOpts, prevOwner common.Address, oldOwner common.Address, ...) (*types.Transaction, error)

+ type SafeTransactorRaw struct

+ Contract *SafeTransactor

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

+ func (_Safe *SafeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeTransactorSession struct

+ Contract *SafeTransactor

+ TransactOpts bind.TransactOpts

+ func (_Safe *SafeTransactorSession) AddOwnerWithThreshold(owner common.Address, _threshold *big.Int) (*types.Transaction, error)

+ func (_Safe *SafeTransactorSession) ApproveHash(hashToApprove [32]byte) (*types.Transaction, error)

+ func (_Safe *SafeTransactorSession) ChangeThreshold(_threshold *big.Int) (*types.Transaction, error)

+ func (_Safe *SafeTransactorSession) DisableModule(prevModule common.Address, module common.Address) (*types.Transaction, error)

+ func (_Safe *SafeTransactorSession) EnableModule(module common.Address) (*types.Transaction, error)

+ func (_Safe *SafeTransactorSession) ExecTransaction(to common.Address, value *big.Int, data []byte, operation uint8, ...) (*types.Transaction, error)

+ func (_Safe *SafeTransactorSession) ExecTransactionFromModule(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

+ func (_Safe *SafeTransactorSession) ExecTransactionFromModuleReturnData(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

+ func (_Safe *SafeTransactorSession) Fallback(calldata []byte) (*types.Transaction, error)

+ func (_Safe *SafeTransactorSession) Receive() (*types.Transaction, error)

+ func (_Safe *SafeTransactorSession) RemoveOwner(prevOwner common.Address, owner common.Address, _threshold *big.Int) (*types.Transaction, error)

+ func (_Safe *SafeTransactorSession) SetFallbackHandler(handler common.Address) (*types.Transaction, error)

+ func (_Safe *SafeTransactorSession) SetGuard(guard common.Address) (*types.Transaction, error)

+ func (_Safe *SafeTransactorSession) Setup(_owners []common.Address, _threshold *big.Int, to common.Address, data []byte, ...) (*types.Transaction, error)

+ func (_Safe *SafeTransactorSession) SimulateAndRevert(targetContract common.Address, calldataPayload []byte) (*types.Transaction, error)

+ func (_Safe *SafeTransactorSession) SwapOwner(prevOwner common.Address, oldOwner common.Address, newOwner common.Address) (*types.Transaction, error)

+ type SchemaRecord struct

+ Resolver common.Address

+ Revocable bool

+ Schema string

+ Uid [32]byte

+ type SchemaRegistry struct

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

+ func NewSchemaRegistry(address common.Address, backend bind.ContractBackend) (*SchemaRegistry, error)

+ type SchemaRegistryCaller struct

+ func NewSchemaRegistryCaller(address common.Address, caller bind.ContractCaller) (*SchemaRegistryCaller, error)

+ func (_SchemaRegistry *SchemaRegistryCaller) GetSchema(opts *bind.CallOpts, uid [32]byte) (SchemaRecord, error)

+ func (_SchemaRegistry *SchemaRegistryCaller) Version(opts *bind.CallOpts) (string, error)

+ type SchemaRegistryCallerRaw struct

+ Contract *SchemaRegistryCaller

+ func (_SchemaRegistry *SchemaRegistryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type SchemaRegistryCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SchemaRegistryCaller

+ func (_SchemaRegistry *SchemaRegistryCallerSession) GetSchema(uid [32]byte) (SchemaRecord, error)

+ func (_SchemaRegistry *SchemaRegistryCallerSession) Version() (string, error)

+ type SchemaRegistryFilterer struct

+ func NewSchemaRegistryFilterer(address common.Address, filterer bind.ContractFilterer) (*SchemaRegistryFilterer, error)

+ func (_SchemaRegistry *SchemaRegistryFilterer) FilterRegistered(opts *bind.FilterOpts, uid [][32]byte, registerer []common.Address) (*SchemaRegistryRegisteredIterator, error)

+ func (_SchemaRegistry *SchemaRegistryFilterer) ParseRegistered(log types.Log) (*SchemaRegistryRegistered, error)

+ func (_SchemaRegistry *SchemaRegistryFilterer) WatchRegistered(opts *bind.WatchOpts, sink chan<- *SchemaRegistryRegistered, uid [][32]byte, ...) (event.Subscription, error)

+ type SchemaRegistryRaw struct

+ Contract *SchemaRegistry

+ func (_SchemaRegistry *SchemaRegistryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_SchemaRegistry *SchemaRegistryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SchemaRegistryRegistered struct

+ Raw types.Log

+ Registerer common.Address

+ Schema SchemaRecord

+ Uid [32]byte

+ type SchemaRegistryRegisteredIterator struct

+ Event *SchemaRegistryRegistered

+ func (it *SchemaRegistryRegisteredIterator) Close() error

+ func (it *SchemaRegistryRegisteredIterator) Error() error

+ func (it *SchemaRegistryRegisteredIterator) Next() bool

+ type SchemaRegistrySession struct

+ CallOpts bind.CallOpts

+ Contract *SchemaRegistry

+ TransactOpts bind.TransactOpts

+ func (_SchemaRegistry *SchemaRegistrySession) GetSchema(uid [32]byte) (SchemaRecord, error)

+ func (_SchemaRegistry *SchemaRegistrySession) Register(schema string, resolver common.Address, revocable bool) (*types.Transaction, error)

+ func (_SchemaRegistry *SchemaRegistrySession) Version() (string, error)

+ type SchemaRegistryTransactor struct

+ func NewSchemaRegistryTransactor(address common.Address, transactor bind.ContractTransactor) (*SchemaRegistryTransactor, error)

+ func (_SchemaRegistry *SchemaRegistryTransactor) Register(opts *bind.TransactOpts, schema string, resolver common.Address, ...) (*types.Transaction, error)

+ type SchemaRegistryTransactorRaw struct

+ Contract *SchemaRegistryTransactor

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

+ func (_SchemaRegistry *SchemaRegistryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SchemaRegistryTransactorSession struct

+ Contract *SchemaRegistryTransactor

+ TransactOpts bind.TransactOpts

+ func (_SchemaRegistry *SchemaRegistryTransactorSession) Register(schema string, resolver common.Address, revocable bool) (*types.Transaction, error)

+ type SequencerFeeVault struct

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

+ func NewSequencerFeeVault(address common.Address, backend bind.ContractBackend) (*SequencerFeeVault, error)

+ type SequencerFeeVaultCaller struct

+ func NewSequencerFeeVaultCaller(address common.Address, caller bind.ContractCaller) (*SequencerFeeVaultCaller, error)

+ func (_SequencerFeeVault *SequencerFeeVaultCaller) L1FeeWallet(opts *bind.CallOpts) (common.Address, error)

+ func (_SequencerFeeVault *SequencerFeeVaultCaller) MINWITHDRAWALAMOUNT(opts *bind.CallOpts) (*big.Int, error)

+ func (_SequencerFeeVault *SequencerFeeVaultCaller) RECIPIENT(opts *bind.CallOpts) (common.Address, error)

+ func (_SequencerFeeVault *SequencerFeeVaultCaller) TotalProcessed(opts *bind.CallOpts) (*big.Int, error)

+ func (_SequencerFeeVault *SequencerFeeVaultCaller) Version(opts *bind.CallOpts) (string, error)

+ func (_SequencerFeeVault *SequencerFeeVaultCaller) WITHDRAWALNETWORK(opts *bind.CallOpts) (uint8, error)

+ type SequencerFeeVaultCallerRaw struct

+ Contract *SequencerFeeVaultCaller

+ func (_SequencerFeeVault *SequencerFeeVaultCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type SequencerFeeVaultCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SequencerFeeVaultCaller

+ func (_SequencerFeeVault *SequencerFeeVaultCallerSession) L1FeeWallet() (common.Address, error)

+ func (_SequencerFeeVault *SequencerFeeVaultCallerSession) MINWITHDRAWALAMOUNT() (*big.Int, error)

+ func (_SequencerFeeVault *SequencerFeeVaultCallerSession) RECIPIENT() (common.Address, error)

+ func (_SequencerFeeVault *SequencerFeeVaultCallerSession) TotalProcessed() (*big.Int, error)

+ func (_SequencerFeeVault *SequencerFeeVaultCallerSession) Version() (string, error)

+ func (_SequencerFeeVault *SequencerFeeVaultCallerSession) WITHDRAWALNETWORK() (uint8, error)

+ type SequencerFeeVaultFilterer struct

+ func NewSequencerFeeVaultFilterer(address common.Address, filterer bind.ContractFilterer) (*SequencerFeeVaultFilterer, error)

+ func (_SequencerFeeVault *SequencerFeeVaultFilterer) FilterWithdrawal(opts *bind.FilterOpts) (*SequencerFeeVaultWithdrawalIterator, error)

+ func (_SequencerFeeVault *SequencerFeeVaultFilterer) FilterWithdrawal0(opts *bind.FilterOpts) (*SequencerFeeVaultWithdrawal0Iterator, error)

+ func (_SequencerFeeVault *SequencerFeeVaultFilterer) ParseWithdrawal(log types.Log) (*SequencerFeeVaultWithdrawal, error)

+ func (_SequencerFeeVault *SequencerFeeVaultFilterer) ParseWithdrawal0(log types.Log) (*SequencerFeeVaultWithdrawal0, error)

+ func (_SequencerFeeVault *SequencerFeeVaultFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *SequencerFeeVaultWithdrawal) (event.Subscription, error)

+ func (_SequencerFeeVault *SequencerFeeVaultFilterer) WatchWithdrawal0(opts *bind.WatchOpts, sink chan<- *SequencerFeeVaultWithdrawal0) (event.Subscription, error)

+ type SequencerFeeVaultRaw struct

+ Contract *SequencerFeeVault

+ func (_SequencerFeeVault *SequencerFeeVaultRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_SequencerFeeVault *SequencerFeeVaultRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SequencerFeeVaultSession struct

+ CallOpts bind.CallOpts

+ Contract *SequencerFeeVault

+ TransactOpts bind.TransactOpts

+ func (_SequencerFeeVault *SequencerFeeVaultSession) L1FeeWallet() (common.Address, error)

+ func (_SequencerFeeVault *SequencerFeeVaultSession) MINWITHDRAWALAMOUNT() (*big.Int, error)

+ func (_SequencerFeeVault *SequencerFeeVaultSession) RECIPIENT() (common.Address, error)

+ func (_SequencerFeeVault *SequencerFeeVaultSession) Receive() (*types.Transaction, error)

+ func (_SequencerFeeVault *SequencerFeeVaultSession) TotalProcessed() (*big.Int, error)

+ func (_SequencerFeeVault *SequencerFeeVaultSession) Version() (string, error)

+ func (_SequencerFeeVault *SequencerFeeVaultSession) WITHDRAWALNETWORK() (uint8, error)

+ func (_SequencerFeeVault *SequencerFeeVaultSession) Withdraw() (*types.Transaction, error)

+ type SequencerFeeVaultTransactor struct

+ func NewSequencerFeeVaultTransactor(address common.Address, transactor bind.ContractTransactor) (*SequencerFeeVaultTransactor, error)

+ func (_SequencerFeeVault *SequencerFeeVaultTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_SequencerFeeVault *SequencerFeeVaultTransactor) Withdraw(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SequencerFeeVaultTransactorRaw struct

+ Contract *SequencerFeeVaultTransactor

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

+ func (_SequencerFeeVault *SequencerFeeVaultTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SequencerFeeVaultTransactorSession struct

+ Contract *SequencerFeeVaultTransactor

+ TransactOpts bind.TransactOpts

+ func (_SequencerFeeVault *SequencerFeeVaultTransactorSession) Receive() (*types.Transaction, error)

+ func (_SequencerFeeVault *SequencerFeeVaultTransactorSession) Withdraw() (*types.Transaction, error)

+ type SequencerFeeVaultWithdrawal struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type SequencerFeeVaultWithdrawal0 struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ WithdrawalNetwork uint8

+ type SequencerFeeVaultWithdrawal0Iterator struct

+ Event *SequencerFeeVaultWithdrawal0

+ func (it *SequencerFeeVaultWithdrawal0Iterator) Close() error

+ func (it *SequencerFeeVaultWithdrawal0Iterator) Error() error

+ func (it *SequencerFeeVaultWithdrawal0Iterator) Next() bool

+ type SequencerFeeVaultWithdrawalIterator struct

+ Event *SequencerFeeVaultWithdrawal

+ func (it *SequencerFeeVaultWithdrawalIterator) Close() error

+ func (it *SequencerFeeVaultWithdrawalIterator) Error() error

+ func (it *SequencerFeeVaultWithdrawalIterator) Next() bool

+ type Signature struct

+ R [32]byte

+ S [32]byte

+ V uint8

+ type StandardBridge struct

+ func NewStandardBridge(address common.Address, backend bind.ContractBackend) (*StandardBridge, error)

+ type StandardBridgeCaller struct

+ func NewStandardBridgeCaller(address common.Address, caller bind.ContractCaller) (*StandardBridgeCaller, error)

+ func (_StandardBridge *StandardBridgeCaller) Deposits(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_StandardBridge *StandardBridgeCaller) MESSENGER(opts *bind.CallOpts) (common.Address, error)

+ func (_StandardBridge *StandardBridgeCaller) Messenger(opts *bind.CallOpts) (common.Address, error)

+ func (_StandardBridge *StandardBridgeCaller) OTHERBRIDGE(opts *bind.CallOpts) (common.Address, error)

+ func (_StandardBridge *StandardBridgeCaller) OtherBridge(opts *bind.CallOpts) (common.Address, error)

+ type StandardBridgeCallerRaw struct

+ Contract *StandardBridgeCaller

+ func (_StandardBridge *StandardBridgeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type StandardBridgeCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *StandardBridgeCaller

+ func (_StandardBridge *StandardBridgeCallerSession) Deposits(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_StandardBridge *StandardBridgeCallerSession) MESSENGER() (common.Address, error)

+ func (_StandardBridge *StandardBridgeCallerSession) Messenger() (common.Address, error)

+ func (_StandardBridge *StandardBridgeCallerSession) OTHERBRIDGE() (common.Address, error)

+ func (_StandardBridge *StandardBridgeCallerSession) OtherBridge() (common.Address, error)

+ type StandardBridgeERC20BridgeFinalized struct

+ Amount *big.Int

+ ExtraData []byte

+ From common.Address

+ LocalToken common.Address

+ Raw types.Log

+ RemoteToken common.Address

+ To common.Address

+ type StandardBridgeERC20BridgeFinalizedIterator struct

+ Event *StandardBridgeERC20BridgeFinalized

+ func (it *StandardBridgeERC20BridgeFinalizedIterator) Close() error

+ func (it *StandardBridgeERC20BridgeFinalizedIterator) Error() error

+ func (it *StandardBridgeERC20BridgeFinalizedIterator) Next() bool

+ type StandardBridgeERC20BridgeInitiated struct

+ Amount *big.Int

+ ExtraData []byte

+ From common.Address

+ LocalToken common.Address

+ Raw types.Log

+ RemoteToken common.Address

+ To common.Address

+ type StandardBridgeERC20BridgeInitiatedIterator struct

+ Event *StandardBridgeERC20BridgeInitiated

+ func (it *StandardBridgeERC20BridgeInitiatedIterator) Close() error

+ func (it *StandardBridgeERC20BridgeInitiatedIterator) Error() error

+ func (it *StandardBridgeERC20BridgeInitiatedIterator) Next() bool

+ type StandardBridgeETHBridgeFinalized struct

+ Amount *big.Int

+ ExtraData []byte

+ From common.Address

+ Raw types.Log

+ To common.Address

+ type StandardBridgeETHBridgeFinalizedIterator struct

+ Event *StandardBridgeETHBridgeFinalized

+ func (it *StandardBridgeETHBridgeFinalizedIterator) Close() error

+ func (it *StandardBridgeETHBridgeFinalizedIterator) Error() error

+ func (it *StandardBridgeETHBridgeFinalizedIterator) Next() bool

+ type StandardBridgeETHBridgeInitiated struct

+ Amount *big.Int

+ ExtraData []byte

+ From common.Address

+ Raw types.Log

+ To common.Address

+ type StandardBridgeETHBridgeInitiatedIterator struct

+ Event *StandardBridgeETHBridgeInitiated

+ func (it *StandardBridgeETHBridgeInitiatedIterator) Close() error

+ func (it *StandardBridgeETHBridgeInitiatedIterator) Error() error

+ func (it *StandardBridgeETHBridgeInitiatedIterator) Next() bool

+ type StandardBridgeFilterer struct

+ func NewStandardBridgeFilterer(address common.Address, filterer bind.ContractFilterer) (*StandardBridgeFilterer, error)

+ func (_StandardBridge *StandardBridgeFilterer) FilterERC20BridgeFinalized(opts *bind.FilterOpts, localToken []common.Address, ...) (*StandardBridgeERC20BridgeFinalizedIterator, error)

+ func (_StandardBridge *StandardBridgeFilterer) FilterERC20BridgeInitiated(opts *bind.FilterOpts, localToken []common.Address, ...) (*StandardBridgeERC20BridgeInitiatedIterator, error)

+ func (_StandardBridge *StandardBridgeFilterer) FilterETHBridgeFinalized(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*StandardBridgeETHBridgeFinalizedIterator, error)

+ func (_StandardBridge *StandardBridgeFilterer) FilterETHBridgeInitiated(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*StandardBridgeETHBridgeInitiatedIterator, error)

+ func (_StandardBridge *StandardBridgeFilterer) FilterInitialized(opts *bind.FilterOpts) (*StandardBridgeInitializedIterator, error)

+ func (_StandardBridge *StandardBridgeFilterer) ParseERC20BridgeFinalized(log types.Log) (*StandardBridgeERC20BridgeFinalized, error)

+ func (_StandardBridge *StandardBridgeFilterer) ParseERC20BridgeInitiated(log types.Log) (*StandardBridgeERC20BridgeInitiated, error)

+ func (_StandardBridge *StandardBridgeFilterer) ParseETHBridgeFinalized(log types.Log) (*StandardBridgeETHBridgeFinalized, error)

+ func (_StandardBridge *StandardBridgeFilterer) ParseETHBridgeInitiated(log types.Log) (*StandardBridgeETHBridgeInitiated, error)

+ func (_StandardBridge *StandardBridgeFilterer) ParseInitialized(log types.Log) (*StandardBridgeInitialized, error)

+ func (_StandardBridge *StandardBridgeFilterer) WatchERC20BridgeFinalized(opts *bind.WatchOpts, sink chan<- *StandardBridgeERC20BridgeFinalized, ...) (event.Subscription, error)

+ func (_StandardBridge *StandardBridgeFilterer) WatchERC20BridgeInitiated(opts *bind.WatchOpts, sink chan<- *StandardBridgeERC20BridgeInitiated, ...) (event.Subscription, error)

+ func (_StandardBridge *StandardBridgeFilterer) WatchETHBridgeFinalized(opts *bind.WatchOpts, sink chan<- *StandardBridgeETHBridgeFinalized, ...) (event.Subscription, error)

+ func (_StandardBridge *StandardBridgeFilterer) WatchETHBridgeInitiated(opts *bind.WatchOpts, sink chan<- *StandardBridgeETHBridgeInitiated, ...) (event.Subscription, error)

+ func (_StandardBridge *StandardBridgeFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *StandardBridgeInitialized) (event.Subscription, error)

+ type StandardBridgeInitialized struct

+ Raw types.Log

+ Version uint8

+ type StandardBridgeInitializedIterator struct

+ Event *StandardBridgeInitialized

+ func (it *StandardBridgeInitializedIterator) Close() error

+ func (it *StandardBridgeInitializedIterator) Error() error

+ func (it *StandardBridgeInitializedIterator) Next() bool

+ type StandardBridgeRaw struct

+ Contract *StandardBridge

+ func (_StandardBridge *StandardBridgeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_StandardBridge *StandardBridgeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type StandardBridgeSession struct

+ CallOpts bind.CallOpts

+ Contract *StandardBridge

+ TransactOpts bind.TransactOpts

+ func (_StandardBridge *StandardBridgeSession) BridgeERC20(_localToken common.Address, _remoteToken common.Address, _amount *big.Int, ...) (*types.Transaction, error)

+ func (_StandardBridge *StandardBridgeSession) BridgeERC20To(_localToken common.Address, _remoteToken common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_StandardBridge *StandardBridgeSession) BridgeETH(_minGasLimit uint32, _extraData []byte) (*types.Transaction, error)

+ func (_StandardBridge *StandardBridgeSession) BridgeETHTo(_to common.Address, _minGasLimit uint32, _extraData []byte) (*types.Transaction, error)

+ func (_StandardBridge *StandardBridgeSession) Deposits(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_StandardBridge *StandardBridgeSession) FinalizeBridgeERC20(_localToken common.Address, _remoteToken common.Address, _from common.Address, ...) (*types.Transaction, error)

+ func (_StandardBridge *StandardBridgeSession) FinalizeBridgeETH(_from common.Address, _to common.Address, _amount *big.Int, _extraData []byte) (*types.Transaction, error)

+ func (_StandardBridge *StandardBridgeSession) MESSENGER() (common.Address, error)

+ func (_StandardBridge *StandardBridgeSession) Messenger() (common.Address, error)

+ func (_StandardBridge *StandardBridgeSession) OTHERBRIDGE() (common.Address, error)

+ func (_StandardBridge *StandardBridgeSession) OtherBridge() (common.Address, error)

+ func (_StandardBridge *StandardBridgeSession) Receive() (*types.Transaction, error)

+ type StandardBridgeTransactor struct

+ func NewStandardBridgeTransactor(address common.Address, transactor bind.ContractTransactor) (*StandardBridgeTransactor, error)

+ func (_StandardBridge *StandardBridgeTransactor) BridgeERC20(opts *bind.TransactOpts, _localToken common.Address, ...) (*types.Transaction, error)

+ func (_StandardBridge *StandardBridgeTransactor) BridgeERC20To(opts *bind.TransactOpts, _localToken common.Address, ...) (*types.Transaction, error)

+ func (_StandardBridge *StandardBridgeTransactor) BridgeETH(opts *bind.TransactOpts, _minGasLimit uint32, _extraData []byte) (*types.Transaction, error)

+ func (_StandardBridge *StandardBridgeTransactor) BridgeETHTo(opts *bind.TransactOpts, _to common.Address, _minGasLimit uint32, ...) (*types.Transaction, error)

+ func (_StandardBridge *StandardBridgeTransactor) FinalizeBridgeERC20(opts *bind.TransactOpts, _localToken common.Address, ...) (*types.Transaction, error)

+ func (_StandardBridge *StandardBridgeTransactor) FinalizeBridgeETH(opts *bind.TransactOpts, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_StandardBridge *StandardBridgeTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ type StandardBridgeTransactorRaw struct

+ Contract *StandardBridgeTransactor

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

+ func (_StandardBridge *StandardBridgeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type StandardBridgeTransactorSession struct

+ Contract *StandardBridgeTransactor

+ TransactOpts bind.TransactOpts

+ func (_StandardBridge *StandardBridgeTransactorSession) BridgeERC20(_localToken common.Address, _remoteToken common.Address, _amount *big.Int, ...) (*types.Transaction, error)

+ func (_StandardBridge *StandardBridgeTransactorSession) BridgeERC20To(_localToken common.Address, _remoteToken common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_StandardBridge *StandardBridgeTransactorSession) BridgeETH(_minGasLimit uint32, _extraData []byte) (*types.Transaction, error)

+ func (_StandardBridge *StandardBridgeTransactorSession) BridgeETHTo(_to common.Address, _minGasLimit uint32, _extraData []byte) (*types.Transaction, error)

+ func (_StandardBridge *StandardBridgeTransactorSession) FinalizeBridgeERC20(_localToken common.Address, _remoteToken common.Address, _from common.Address, ...) (*types.Transaction, error)

+ func (_StandardBridge *StandardBridgeTransactorSession) FinalizeBridgeETH(_from common.Address, _to common.Address, _amount *big.Int, _extraData []byte) (*types.Transaction, error)

+ func (_StandardBridge *StandardBridgeTransactorSession) Receive() (*types.Transaction, error)

+ type StorageSetter struct

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

+ func NewStorageSetter(address common.Address, backend bind.ContractBackend) (*StorageSetter, error)

+ type StorageSetterCaller struct

+ func NewStorageSetterCaller(address common.Address, caller bind.ContractCaller) (*StorageSetterCaller, error)

+ func (_StorageSetter *StorageSetterCaller) GetAddress(opts *bind.CallOpts, _slot [32]byte) (common.Address, error)

+ func (_StorageSetter *StorageSetterCaller) GetBytes32(opts *bind.CallOpts, _slot [32]byte) ([32]byte, error)

+ func (_StorageSetter *StorageSetterCaller) GetUint(opts *bind.CallOpts, _slot [32]byte) (*big.Int, error)

+ func (_StorageSetter *StorageSetterCaller) Version(opts *bind.CallOpts) (string, error)

+ type StorageSetterCallerRaw struct

+ Contract *StorageSetterCaller

+ func (_StorageSetter *StorageSetterCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type StorageSetterCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *StorageSetterCaller

+ func (_StorageSetter *StorageSetterCallerSession) GetAddress(_slot [32]byte) (common.Address, error)

+ func (_StorageSetter *StorageSetterCallerSession) GetBytes32(_slot [32]byte) ([32]byte, error)

+ func (_StorageSetter *StorageSetterCallerSession) GetUint(_slot [32]byte) (*big.Int, error)

+ func (_StorageSetter *StorageSetterCallerSession) Version() (string, error)

+ type StorageSetterFilterer struct

+ func NewStorageSetterFilterer(address common.Address, filterer bind.ContractFilterer) (*StorageSetterFilterer, error)

+ type StorageSetterRaw struct

+ Contract *StorageSetter

+ func (_StorageSetter *StorageSetterRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_StorageSetter *StorageSetterRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type StorageSetterSession struct

+ CallOpts bind.CallOpts

+ Contract *StorageSetter

+ TransactOpts bind.TransactOpts

+ func (_StorageSetter *StorageSetterSession) GetAddress(_slot [32]byte) (common.Address, error)

+ func (_StorageSetter *StorageSetterSession) GetBytes32(_slot [32]byte) ([32]byte, error)

+ func (_StorageSetter *StorageSetterSession) GetUint(_slot [32]byte) (*big.Int, error)

+ func (_StorageSetter *StorageSetterSession) SetAddress(_slot [32]byte, _address common.Address) (*types.Transaction, error)

+ func (_StorageSetter *StorageSetterSession) SetBytes32(_slot [32]byte, _value [32]byte) (*types.Transaction, error)

+ func (_StorageSetter *StorageSetterSession) SetUint(_slot [32]byte, _value *big.Int) (*types.Transaction, error)

+ func (_StorageSetter *StorageSetterSession) Version() (string, error)

+ type StorageSetterTransactor struct

+ func NewStorageSetterTransactor(address common.Address, transactor bind.ContractTransactor) (*StorageSetterTransactor, error)

+ func (_StorageSetter *StorageSetterTransactor) SetAddress(opts *bind.TransactOpts, _slot [32]byte, _address common.Address) (*types.Transaction, error)

+ func (_StorageSetter *StorageSetterTransactor) SetBytes32(opts *bind.TransactOpts, _slot [32]byte, _value [32]byte) (*types.Transaction, error)

+ func (_StorageSetter *StorageSetterTransactor) SetUint(opts *bind.TransactOpts, _slot [32]byte, _value *big.Int) (*types.Transaction, error)

+ type StorageSetterTransactorRaw struct

+ Contract *StorageSetterTransactor

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

+ func (_StorageSetter *StorageSetterTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type StorageSetterTransactorSession struct

+ Contract *StorageSetterTransactor

+ TransactOpts bind.TransactOpts

+ func (_StorageSetter *StorageSetterTransactorSession) SetAddress(_slot [32]byte, _address common.Address) (*types.Transaction, error)

+ func (_StorageSetter *StorageSetterTransactorSession) SetBytes32(_slot [32]byte, _value [32]byte) (*types.Transaction, error)

+ func (_StorageSetter *StorageSetterTransactorSession) SetUint(_slot [32]byte, _value *big.Int) (*types.Transaction, error)

+ type SystemConfigAddresses struct

+ L1CrossDomainMessenger common.Address

+ L1ERC721Bridge common.Address

+ L1StandardBridge common.Address

+ L2OutputOracle common.Address

+ OptimismMintableERC20Factory common.Address

+ OptimismPortal common.Address

type SystemConfigCaller

+ func (_SystemConfig *SystemConfigCaller) BATCHINBOXSLOT(opts *bind.CallOpts) ([32]byte, error)

+ func (_SystemConfig *SystemConfigCaller) BatchInbox(opts *bind.CallOpts) (common.Address, error)

+ func (_SystemConfig *SystemConfigCaller) L1CROSSDOMAINMESSENGERSLOT(opts *bind.CallOpts) ([32]byte, error)

+ func (_SystemConfig *SystemConfigCaller) L1CrossDomainMessenger(opts *bind.CallOpts) (common.Address, error)

+ func (_SystemConfig *SystemConfigCaller) L1ERC721BRIDGESLOT(opts *bind.CallOpts) ([32]byte, error)

+ func (_SystemConfig *SystemConfigCaller) L1ERC721Bridge(opts *bind.CallOpts) (common.Address, error)

+ func (_SystemConfig *SystemConfigCaller) L1STANDARDBRIDGESLOT(opts *bind.CallOpts) ([32]byte, error)

+ func (_SystemConfig *SystemConfigCaller) L1StandardBridge(opts *bind.CallOpts) (common.Address, error)

+ func (_SystemConfig *SystemConfigCaller) L2OUTPUTORACLESLOT(opts *bind.CallOpts) ([32]byte, error)

+ func (_SystemConfig *SystemConfigCaller) L2OutputOracle(opts *bind.CallOpts) (common.Address, error)

+ func (_SystemConfig *SystemConfigCaller) OPTIMISMMINTABLEERC20FACTORYSLOT(opts *bind.CallOpts) ([32]byte, error)

+ func (_SystemConfig *SystemConfigCaller) OPTIMISMPORTALSLOT(opts *bind.CallOpts) ([32]byte, error)

+ func (_SystemConfig *SystemConfigCaller) OptimismMintableERC20Factory(opts *bind.CallOpts) (common.Address, error)

+ func (_SystemConfig *SystemConfigCaller) OptimismPortal(opts *bind.CallOpts) (common.Address, error)

+ func (_SystemConfig *SystemConfigCaller) StartBlock(opts *bind.CallOpts) (*big.Int, error)

type SystemConfigCallerSession

+ func (_SystemConfig *SystemConfigCallerSession) BATCHINBOXSLOT() ([32]byte, error)

+ func (_SystemConfig *SystemConfigCallerSession) BatchInbox() (common.Address, error)

+ func (_SystemConfig *SystemConfigCallerSession) L1CROSSDOMAINMESSENGERSLOT() ([32]byte, error)

+ func (_SystemConfig *SystemConfigCallerSession) L1CrossDomainMessenger() (common.Address, error)

+ func (_SystemConfig *SystemConfigCallerSession) L1ERC721BRIDGESLOT() ([32]byte, error)

+ func (_SystemConfig *SystemConfigCallerSession) L1ERC721Bridge() (common.Address, error)

+ func (_SystemConfig *SystemConfigCallerSession) L1STANDARDBRIDGESLOT() ([32]byte, error)

+ func (_SystemConfig *SystemConfigCallerSession) L1StandardBridge() (common.Address, error)

+ func (_SystemConfig *SystemConfigCallerSession) L2OUTPUTORACLESLOT() ([32]byte, error)

+ func (_SystemConfig *SystemConfigCallerSession) L2OutputOracle() (common.Address, error)

+ func (_SystemConfig *SystemConfigCallerSession) OPTIMISMMINTABLEERC20FACTORYSLOT() ([32]byte, error)

+ func (_SystemConfig *SystemConfigCallerSession) OPTIMISMPORTALSLOT() ([32]byte, error)

+ func (_SystemConfig *SystemConfigCallerSession) OptimismMintableERC20Factory() (common.Address, error)

+ func (_SystemConfig *SystemConfigCallerSession) OptimismPortal() (common.Address, error)

+ func (_SystemConfig *SystemConfigCallerSession) StartBlock() (*big.Int, error)

type SystemConfigSession

+ func (_SystemConfig *SystemConfigSession) BATCHINBOXSLOT() ([32]byte, error)

+ func (_SystemConfig *SystemConfigSession) BatchInbox() (common.Address, error)

+ func (_SystemConfig *SystemConfigSession) L1CROSSDOMAINMESSENGERSLOT() ([32]byte, error)

+ func (_SystemConfig *SystemConfigSession) L1CrossDomainMessenger() (common.Address, error)

+ func (_SystemConfig *SystemConfigSession) L1ERC721BRIDGESLOT() ([32]byte, error)

+ func (_SystemConfig *SystemConfigSession) L1ERC721Bridge() (common.Address, error)

+ func (_SystemConfig *SystemConfigSession) L1STANDARDBRIDGESLOT() ([32]byte, error)

+ func (_SystemConfig *SystemConfigSession) L1StandardBridge() (common.Address, error)

+ func (_SystemConfig *SystemConfigSession) L2OUTPUTORACLESLOT() ([32]byte, error)

+ func (_SystemConfig *SystemConfigSession) L2OutputOracle() (common.Address, error)

+ func (_SystemConfig *SystemConfigSession) OPTIMISMMINTABLEERC20FACTORYSLOT() ([32]byte, error)

+ func (_SystemConfig *SystemConfigSession) OPTIMISMPORTALSLOT() ([32]byte, error)

+ func (_SystemConfig *SystemConfigSession) OptimismMintableERC20Factory() (common.Address, error)

+ func (_SystemConfig *SystemConfigSession) OptimismPortal() (common.Address, error)

+ func (_SystemConfig *SystemConfigSession) StartBlock() (*big.Int, error)

+ type TypesOutputProposal struct

+ L2BlockNumber *big.Int

+ OutputRoot [32]byte

+ Timestamp *big.Int

type TypesOutputRootProof

+ LatestBlockhash [32]byte

v1.2.0-rc.3

Feb 6, 2024

v1.2.0-rc.2

Feb 5, 2024

v1.2.0-rc.1

Jan 17, 2024

v1.1.1

Jan 31, 2024

v1.1.0

Jan 4, 2024

Changes in this version

+ const ColosseumStorageLayoutJSON

+ const KromaMintableERC20FactoryStorageLayoutJSON

+ const KromaMintableERC721FactoryStorageLayoutJSON

+ const KromaPortalStorageLayoutJSON

+ const L1BlockStorageLayoutJSON

+ const L1CrossDomainMessengerStorageLayoutJSON

+ const L1ERC721BridgeStorageLayoutJSON

+ const L1FeeVaultStorageLayoutJSON

+ const L1StandardBridgeStorageLayoutJSON

+ const L2CrossDomainMessengerStorageLayoutJSON

+ const L2ERC721BridgeStorageLayoutJSON

+ const L2OutputOracleStorageLayoutJSON

+ const L2StandardBridgeStorageLayoutJSON

+ const L2ToL1MessagePasserStorageLayoutJSON

+ const ProxyAdminStorageLayoutJSON

+ const ProxyStorageLayoutJSON

+ const SecurityCouncilStorageLayoutJSON

+ const SecurityCouncilTokenStorageLayoutJSON

+ const SystemConfigStorageLayoutJSON

+ const TimeLockStorageLayoutJSON

+ const UpgradeGovernorStorageLayoutJSON

+ const ValidatorPoolStorageLayoutJSON

+ const ValidatorRewardVaultStorageLayoutJSON

+ const WETH9StorageLayoutJSON

+ var ColosseumABI = ColosseumMetaData.ABI

+ var ColosseumBin = ColosseumMetaData.Bin

+ var ColosseumMetaData = &bind.MetaData

+ var ColosseumStorageLayout = new(solc.StorageLayout)

+ var ERC20ABI = ERC20MetaData.ABI

+ var ERC20Bin = ERC20MetaData.Bin

+ var ERC20MetaData = &bind.MetaData

+ var GasPriceOracleABI = GasPriceOracleMetaData.ABI

+ var GasPriceOracleBin = GasPriceOracleMetaData.Bin

+ var GasPriceOracleMetaData = &bind.MetaData

+ var KromaMintableERC20ABI = KromaMintableERC20MetaData.ABI

+ var KromaMintableERC20Bin = KromaMintableERC20MetaData.Bin

+ var KromaMintableERC20FactoryABI = KromaMintableERC20FactoryMetaData.ABI

+ var KromaMintableERC20FactoryBin = KromaMintableERC20FactoryMetaData.Bin

+ var KromaMintableERC20FactoryMetaData = &bind.MetaData

+ var KromaMintableERC20FactoryStorageLayout = new(solc.StorageLayout)

+ var KromaMintableERC20MetaData = &bind.MetaData

+ var KromaMintableERC721FactoryABI = KromaMintableERC721FactoryMetaData.ABI

+ var KromaMintableERC721FactoryBin = KromaMintableERC721FactoryMetaData.Bin

+ var KromaMintableERC721FactoryMetaData = &bind.MetaData

+ var KromaMintableERC721FactoryStorageLayout = new(solc.StorageLayout)

+ var KromaPortalABI = KromaPortalMetaData.ABI

+ var KromaPortalBin = KromaPortalMetaData.Bin

+ var KromaPortalMetaData = &bind.MetaData

+ var KromaPortalStorageLayout = new(solc.StorageLayout)

+ var L1BlockABI = L1BlockMetaData.ABI

+ var L1BlockBin = L1BlockMetaData.Bin

+ var L1BlockMetaData = &bind.MetaData

+ var L1BlockStorageLayout = new(solc.StorageLayout)

+ var L1CrossDomainMessengerABI = L1CrossDomainMessengerMetaData.ABI

+ var L1CrossDomainMessengerBin = L1CrossDomainMessengerMetaData.Bin

+ var L1CrossDomainMessengerMetaData = &bind.MetaData

+ var L1CrossDomainMessengerStorageLayout = new(solc.StorageLayout)

+ var L1ERC721BridgeABI = L1ERC721BridgeMetaData.ABI

+ var L1ERC721BridgeBin = L1ERC721BridgeMetaData.Bin

+ var L1ERC721BridgeMetaData = &bind.MetaData

+ var L1ERC721BridgeStorageLayout = new(solc.StorageLayout)

+ var L1FeeVaultABI = L1FeeVaultMetaData.ABI

+ var L1FeeVaultBin = L1FeeVaultMetaData.Bin

+ var L1FeeVaultMetaData = &bind.MetaData

+ var L1FeeVaultStorageLayout = new(solc.StorageLayout)

+ var L1StandardBridgeABI = L1StandardBridgeMetaData.ABI

+ var L1StandardBridgeBin = L1StandardBridgeMetaData.Bin

+ var L1StandardBridgeMetaData = &bind.MetaData

+ var L1StandardBridgeStorageLayout = new(solc.StorageLayout)

+ var L2CrossDomainMessengerABI = L2CrossDomainMessengerMetaData.ABI

+ var L2CrossDomainMessengerBin = L2CrossDomainMessengerMetaData.Bin

+ var L2CrossDomainMessengerMetaData = &bind.MetaData

+ var L2CrossDomainMessengerStorageLayout = new(solc.StorageLayout)

+ var L2ERC721BridgeABI = L2ERC721BridgeMetaData.ABI

+ var L2ERC721BridgeBin = L2ERC721BridgeMetaData.Bin

+ var L2ERC721BridgeMetaData = &bind.MetaData

+ var L2ERC721BridgeStorageLayout = new(solc.StorageLayout)

+ var L2OutputOracleABI = L2OutputOracleMetaData.ABI

+ var L2OutputOracleBin = L2OutputOracleMetaData.Bin

+ var L2OutputOracleMetaData = &bind.MetaData

+ var L2OutputOracleStorageLayout = new(solc.StorageLayout)

+ var L2StandardBridgeABI = L2StandardBridgeMetaData.ABI

+ var L2StandardBridgeBin = L2StandardBridgeMetaData.Bin

+ var L2StandardBridgeMetaData = &bind.MetaData

+ var L2StandardBridgeStorageLayout = new(solc.StorageLayout)

+ var L2ToL1MessagePasserABI = L2ToL1MessagePasserMetaData.ABI

+ var L2ToL1MessagePasserBin = L2ToL1MessagePasserMetaData.Bin

+ var L2ToL1MessagePasserMetaData = &bind.MetaData

+ var L2ToL1MessagePasserStorageLayout = new(solc.StorageLayout)

+ var ProtocolVaultABI = ProtocolVaultMetaData.ABI

+ var ProtocolVaultBin = ProtocolVaultMetaData.Bin

+ var ProtocolVaultMetaData = &bind.MetaData

+ var ProxyABI = ProxyMetaData.ABI

+ var ProxyAdminABI = ProxyAdminMetaData.ABI

+ var ProxyAdminBin = ProxyAdminMetaData.Bin

+ var ProxyAdminMetaData = &bind.MetaData

+ var ProxyAdminStorageLayout = new(solc.StorageLayout)

+ var ProxyBin = ProxyMetaData.Bin

+ var ProxyMetaData = &bind.MetaData

+ var ProxyStorageLayout = new(solc.StorageLayout)

+ var SecurityCouncilABI = SecurityCouncilMetaData.ABI

+ var SecurityCouncilBin = SecurityCouncilMetaData.Bin

+ var SecurityCouncilMetaData = &bind.MetaData

+ var SecurityCouncilStorageLayout = new(solc.StorageLayout)

+ var SecurityCouncilTokenABI = SecurityCouncilTokenMetaData.ABI

+ var SecurityCouncilTokenBin = SecurityCouncilTokenMetaData.Bin

+ var SecurityCouncilTokenMetaData = &bind.MetaData

+ var SecurityCouncilTokenStorageLayout = new(solc.StorageLayout)

+ var SystemConfigABI = SystemConfigMetaData.ABI

+ var SystemConfigBin = SystemConfigMetaData.Bin

+ var SystemConfigMetaData = &bind.MetaData

+ var SystemConfigStorageLayout = new(solc.StorageLayout)

+ var TimeLockABI = TimeLockMetaData.ABI

+ var TimeLockBin = TimeLockMetaData.Bin

+ var TimeLockMetaData = &bind.MetaData

+ var TimeLockStorageLayout = new(solc.StorageLayout)

+ var UpgradeGovernorABI = UpgradeGovernorMetaData.ABI

+ var UpgradeGovernorBin = UpgradeGovernorMetaData.Bin

+ var UpgradeGovernorMetaData = &bind.MetaData

+ var UpgradeGovernorStorageLayout = new(solc.StorageLayout)

+ var ValidatorPoolABI = ValidatorPoolMetaData.ABI

+ var ValidatorPoolBin = ValidatorPoolMetaData.Bin

+ var ValidatorPoolMetaData = &bind.MetaData

+ var ValidatorPoolStorageLayout = new(solc.StorageLayout)

+ var ValidatorRewardVaultABI = ValidatorRewardVaultMetaData.ABI

+ var ValidatorRewardVaultBin = ValidatorRewardVaultMetaData.Bin

+ var ValidatorRewardVaultMetaData = &bind.MetaData

+ var ValidatorRewardVaultStorageLayout = new(solc.StorageLayout)

+ var WETH9ABI = WETH9MetaData.ABI

+ var WETH9Bin = WETH9MetaData.Bin

+ var WETH9MetaData = &bind.MetaData

+ var WETH9StorageLayout = new(solc.StorageLayout)

+ var ZKMerkleTrieABI = ZKMerkleTrieMetaData.ABI

+ var ZKMerkleTrieBin = ZKMerkleTrieMetaData.Bin

+ var ZKMerkleTrieMetaData = &bind.MetaData

+ var ZKVerifierABI = ZKVerifierMetaData.ABI

+ var ZKVerifierBin = ZKVerifierMetaData.Bin

+ var ZKVerifierMetaData = &bind.MetaData

+ func GetDeployedBytecode(name string) ([]byte, error)

+ func GetStorageLayout(name string) (*solc.StorageLayout, error)

+ type Colosseum struct

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

+ func NewColosseum(address common.Address, backend bind.ContractBackend) (*Colosseum, error)

+ type ColosseumBisected struct

+ Challenger common.Address

+ OutputIndex *big.Int

+ Raw types.Log

+ Timestamp *big.Int

+ Turn uint8

+ type ColosseumBisectedIterator struct

+ Event *ColosseumBisected

+ func (it *ColosseumBisectedIterator) Close() error

+ func (it *ColosseumBisectedIterator) Error() error

+ func (it *ColosseumBisectedIterator) Next() bool

+ type ColosseumCaller struct

+ func NewColosseumCaller(address common.Address, caller bind.ContractCaller) (*ColosseumCaller, error)

+ func (_Colosseum *ColosseumCaller) BISECTIONTIMEOUT(opts *bind.CallOpts) (*big.Int, error)

+ func (_Colosseum *ColosseumCaller) CREATIONPERIODSECONDS(opts *bind.CallOpts) (*big.Int, error)

+ func (_Colosseum *ColosseumCaller) Challenges(opts *bind.CallOpts, arg0 *big.Int, arg1 common.Address) (struct{ ... }, error)

+ func (_Colosseum *ColosseumCaller) DUMMYHASH(opts *bind.CallOpts) ([32]byte, error)

+ func (_Colosseum *ColosseumCaller) GetChallenge(opts *bind.CallOpts, _outputIndex *big.Int, _challenger common.Address) (TypesChallenge, error)

+ func (_Colosseum *ColosseumCaller) GetSegmentsLength(opts *bind.CallOpts, _turn uint8) (*big.Int, error)

+ func (_Colosseum *ColosseumCaller) GetStatus(opts *bind.CallOpts, _outputIndex *big.Int, _challenger common.Address) (uint8, error)

+ func (_Colosseum *ColosseumCaller) IsAbleToBisect(opts *bind.CallOpts, _outputIndex *big.Int, _challenger common.Address) (bool, error)

+ func (_Colosseum *ColosseumCaller) IsInCreationPeriod(opts *bind.CallOpts, _outputIndex *big.Int) (bool, error)

+ func (_Colosseum *ColosseumCaller) L2ORACLE(opts *bind.CallOpts) (common.Address, error)

+ func (_Colosseum *ColosseumCaller) L2ORACLESUBMISSIONINTERVAL(opts *bind.CallOpts) (*big.Int, error)

+ func (_Colosseum *ColosseumCaller) MAXTXS(opts *bind.CallOpts) (*big.Int, error)

+ func (_Colosseum *ColosseumCaller) PROVINGTIMEOUT(opts *bind.CallOpts) (*big.Int, error)

+ func (_Colosseum *ColosseumCaller) SECURITYCOUNCIL(opts *bind.CallOpts) (common.Address, error)

+ func (_Colosseum *ColosseumCaller) VerifiedPublicInputs(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ func (_Colosseum *ColosseumCaller) Version(opts *bind.CallOpts) (string, error)

+ func (_Colosseum *ColosseumCaller) ZKMERKLETRIE(opts *bind.CallOpts) (common.Address, error)

+ func (_Colosseum *ColosseumCaller) ZKVERIFIER(opts *bind.CallOpts) (common.Address, error)

+ type ColosseumCallerRaw struct

+ Contract *ColosseumCaller

+ func (_Colosseum *ColosseumCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type ColosseumCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ColosseumCaller

+ func (_Colosseum *ColosseumCallerSession) BISECTIONTIMEOUT() (*big.Int, error)

+ func (_Colosseum *ColosseumCallerSession) CREATIONPERIODSECONDS() (*big.Int, error)

+ func (_Colosseum *ColosseumCallerSession) Challenges(arg0 *big.Int, arg1 common.Address) (struct{ ... }, error)

+ func (_Colosseum *ColosseumCallerSession) DUMMYHASH() ([32]byte, error)

+ func (_Colosseum *ColosseumCallerSession) GetChallenge(_outputIndex *big.Int, _challenger common.Address) (TypesChallenge, error)

+ func (_Colosseum *ColosseumCallerSession) GetSegmentsLength(_turn uint8) (*big.Int, error)

+ func (_Colosseum *ColosseumCallerSession) GetStatus(_outputIndex *big.Int, _challenger common.Address) (uint8, error)

+ func (_Colosseum *ColosseumCallerSession) IsAbleToBisect(_outputIndex *big.Int, _challenger common.Address) (bool, error)

+ func (_Colosseum *ColosseumCallerSession) IsInCreationPeriod(_outputIndex *big.Int) (bool, error)

+ func (_Colosseum *ColosseumCallerSession) L2ORACLE() (common.Address, error)

+ func (_Colosseum *ColosseumCallerSession) L2ORACLESUBMISSIONINTERVAL() (*big.Int, error)

+ func (_Colosseum *ColosseumCallerSession) MAXTXS() (*big.Int, error)

+ func (_Colosseum *ColosseumCallerSession) PROVINGTIMEOUT() (*big.Int, error)

+ func (_Colosseum *ColosseumCallerSession) SECURITYCOUNCIL() (common.Address, error)

+ func (_Colosseum *ColosseumCallerSession) VerifiedPublicInputs(arg0 [32]byte) (bool, error)

+ func (_Colosseum *ColosseumCallerSession) Version() (string, error)

+ func (_Colosseum *ColosseumCallerSession) ZKMERKLETRIE() (common.Address, error)

+ func (_Colosseum *ColosseumCallerSession) ZKVERIFIER() (common.Address, error)

+ type ColosseumChallengeCanceled struct

+ Challenger common.Address

+ OutputIndex *big.Int

+ Raw types.Log

+ Timestamp *big.Int

+ type ColosseumChallengeCanceledIterator struct

+ Event *ColosseumChallengeCanceled

+ func (it *ColosseumChallengeCanceledIterator) Close() error

+ func (it *ColosseumChallengeCanceledIterator) Error() error

+ func (it *ColosseumChallengeCanceledIterator) Next() bool

+ type ColosseumChallengeCreated struct

+ Asserter common.Address

+ Challenger common.Address

+ OutputIndex *big.Int

+ Raw types.Log

+ Timestamp *big.Int

+ type ColosseumChallengeCreatedIterator struct

+ Event *ColosseumChallengeCreated

+ func (it *ColosseumChallengeCreatedIterator) Close() error

+ func (it *ColosseumChallengeCreatedIterator) Error() error

+ func (it *ColosseumChallengeCreatedIterator) Next() bool

+ type ColosseumChallengeDismissed struct

+ Challenger common.Address

+ OutputIndex *big.Int

+ Raw types.Log

+ Timestamp *big.Int

+ type ColosseumChallengeDismissedIterator struct

+ Event *ColosseumChallengeDismissed

+ func (it *ColosseumChallengeDismissedIterator) Close() error

+ func (it *ColosseumChallengeDismissedIterator) Error() error

+ func (it *ColosseumChallengeDismissedIterator) Next() bool

+ type ColosseumChallengerTimedOut struct

+ Challenger common.Address

+ OutputIndex *big.Int

+ Raw types.Log

+ Timestamp *big.Int

+ type ColosseumChallengerTimedOutIterator struct

+ Event *ColosseumChallengerTimedOut

+ func (it *ColosseumChallengerTimedOutIterator) Close() error

+ func (it *ColosseumChallengerTimedOutIterator) Error() error

+ func (it *ColosseumChallengerTimedOutIterator) Next() bool

+ type ColosseumFilterer struct

+ func NewColosseumFilterer(address common.Address, filterer bind.ContractFilterer) (*ColosseumFilterer, error)

+ func (_Colosseum *ColosseumFilterer) FilterBisected(opts *bind.FilterOpts, outputIndex []*big.Int, challenger []common.Address) (*ColosseumBisectedIterator, error)

+ func (_Colosseum *ColosseumFilterer) FilterChallengeCanceled(opts *bind.FilterOpts, outputIndex []*big.Int, challenger []common.Address) (*ColosseumChallengeCanceledIterator, error)

+ func (_Colosseum *ColosseumFilterer) FilterChallengeCreated(opts *bind.FilterOpts, outputIndex []*big.Int, asserter []common.Address, ...) (*ColosseumChallengeCreatedIterator, error)

+ func (_Colosseum *ColosseumFilterer) FilterChallengeDismissed(opts *bind.FilterOpts, outputIndex []*big.Int, challenger []common.Address) (*ColosseumChallengeDismissedIterator, error)

+ func (_Colosseum *ColosseumFilterer) FilterChallengerTimedOut(opts *bind.FilterOpts, outputIndex []*big.Int, challenger []common.Address) (*ColosseumChallengerTimedOutIterator, error)

+ func (_Colosseum *ColosseumFilterer) FilterInitialized(opts *bind.FilterOpts) (*ColosseumInitializedIterator, error)

+ func (_Colosseum *ColosseumFilterer) FilterProven(opts *bind.FilterOpts, outputIndex []*big.Int, challenger []common.Address) (*ColosseumProvenIterator, error)

+ func (_Colosseum *ColosseumFilterer) FilterReadyToProve(opts *bind.FilterOpts, outputIndex []*big.Int, challenger []common.Address) (*ColosseumReadyToProveIterator, error)

+ func (_Colosseum *ColosseumFilterer) ParseBisected(log types.Log) (*ColosseumBisected, error)

+ func (_Colosseum *ColosseumFilterer) ParseChallengeCanceled(log types.Log) (*ColosseumChallengeCanceled, error)

+ func (_Colosseum *ColosseumFilterer) ParseChallengeCreated(log types.Log) (*ColosseumChallengeCreated, error)

+ func (_Colosseum *ColosseumFilterer) ParseChallengeDismissed(log types.Log) (*ColosseumChallengeDismissed, error)

+ func (_Colosseum *ColosseumFilterer) ParseChallengerTimedOut(log types.Log) (*ColosseumChallengerTimedOut, error)

+ func (_Colosseum *ColosseumFilterer) ParseInitialized(log types.Log) (*ColosseumInitialized, error)

+ func (_Colosseum *ColosseumFilterer) ParseProven(log types.Log) (*ColosseumProven, error)

+ func (_Colosseum *ColosseumFilterer) ParseReadyToProve(log types.Log) (*ColosseumReadyToProve, error)

+ func (_Colosseum *ColosseumFilterer) WatchBisected(opts *bind.WatchOpts, sink chan<- *ColosseumBisected, outputIndex []*big.Int, ...) (event.Subscription, error)

+ func (_Colosseum *ColosseumFilterer) WatchChallengeCanceled(opts *bind.WatchOpts, sink chan<- *ColosseumChallengeCanceled, ...) (event.Subscription, error)

+ func (_Colosseum *ColosseumFilterer) WatchChallengeCreated(opts *bind.WatchOpts, sink chan<- *ColosseumChallengeCreated, ...) (event.Subscription, error)

+ func (_Colosseum *ColosseumFilterer) WatchChallengeDismissed(opts *bind.WatchOpts, sink chan<- *ColosseumChallengeDismissed, ...) (event.Subscription, error)

+ func (_Colosseum *ColosseumFilterer) WatchChallengerTimedOut(opts *bind.WatchOpts, sink chan<- *ColosseumChallengerTimedOut, ...) (event.Subscription, error)

+ func (_Colosseum *ColosseumFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *ColosseumInitialized) (event.Subscription, error)

+ func (_Colosseum *ColosseumFilterer) WatchProven(opts *bind.WatchOpts, sink chan<- *ColosseumProven, outputIndex []*big.Int, ...) (event.Subscription, error)

+ func (_Colosseum *ColosseumFilterer) WatchReadyToProve(opts *bind.WatchOpts, sink chan<- *ColosseumReadyToProve, ...) (event.Subscription, error)

+ type ColosseumInitialized struct

+ Raw types.Log

+ Version uint8

+ type ColosseumInitializedIterator struct

+ Event *ColosseumInitialized

+ func (it *ColosseumInitializedIterator) Close() error

+ func (it *ColosseumInitializedIterator) Error() error

+ func (it *ColosseumInitializedIterator) Next() bool

+ type ColosseumProven struct

+ Challenger common.Address

+ OutputIndex *big.Int

+ Raw types.Log

+ Timestamp *big.Int

+ type ColosseumProvenIterator struct

+ Event *ColosseumProven

+ func (it *ColosseumProvenIterator) Close() error

+ func (it *ColosseumProvenIterator) Error() error

+ func (it *ColosseumProvenIterator) Next() bool

+ type ColosseumRaw struct

+ Contract *Colosseum

+ func (_Colosseum *ColosseumRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_Colosseum *ColosseumRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ColosseumReadyToProve struct

+ Challenger common.Address

+ OutputIndex *big.Int

+ Raw types.Log

+ type ColosseumReadyToProveIterator struct

+ Event *ColosseumReadyToProve

+ func (it *ColosseumReadyToProveIterator) Close() error

+ func (it *ColosseumReadyToProveIterator) Error() error

+ func (it *ColosseumReadyToProveIterator) Next() bool

+ type ColosseumSession struct

+ CallOpts bind.CallOpts

+ Contract *Colosseum

+ TransactOpts bind.TransactOpts

+ func (_Colosseum *ColosseumSession) BISECTIONTIMEOUT() (*big.Int, error)

+ func (_Colosseum *ColosseumSession) Bisect(_outputIndex *big.Int, _challenger common.Address, _pos *big.Int, ...) (*types.Transaction, error)

+ func (_Colosseum *ColosseumSession) CREATIONPERIODSECONDS() (*big.Int, error)

+ func (_Colosseum *ColosseumSession) CancelChallenge(_outputIndex *big.Int) (*types.Transaction, error)

+ func (_Colosseum *ColosseumSession) ChallengerTimeout(_outputIndex *big.Int, _challenger common.Address) (*types.Transaction, error)

+ func (_Colosseum *ColosseumSession) Challenges(arg0 *big.Int, arg1 common.Address) (struct{ ... }, error)

+ func (_Colosseum *ColosseumSession) CreateChallenge(_outputIndex *big.Int, _l1BlockHash [32]byte, _l1BlockNumber *big.Int, ...) (*types.Transaction, error)

+ func (_Colosseum *ColosseumSession) DUMMYHASH() ([32]byte, error)

+ func (_Colosseum *ColosseumSession) DismissChallenge(_outputIndex *big.Int, _challenger common.Address, _asserter common.Address, ...) (*types.Transaction, error)

+ func (_Colosseum *ColosseumSession) ForceDeleteOutput(_outputIndex *big.Int) (*types.Transaction, error)

+ func (_Colosseum *ColosseumSession) GetChallenge(_outputIndex *big.Int, _challenger common.Address) (TypesChallenge, error)

+ func (_Colosseum *ColosseumSession) GetSegmentsLength(_turn uint8) (*big.Int, error)

+ func (_Colosseum *ColosseumSession) GetStatus(_outputIndex *big.Int, _challenger common.Address) (uint8, error)

+ func (_Colosseum *ColosseumSession) Initialize(_segmentsLengths []*big.Int) (*types.Transaction, error)

+ func (_Colosseum *ColosseumSession) IsAbleToBisect(_outputIndex *big.Int, _challenger common.Address) (bool, error)

+ func (_Colosseum *ColosseumSession) IsInCreationPeriod(_outputIndex *big.Int) (bool, error)

+ func (_Colosseum *ColosseumSession) L2ORACLE() (common.Address, error)

+ func (_Colosseum *ColosseumSession) L2ORACLESUBMISSIONINTERVAL() (*big.Int, error)

+ func (_Colosseum *ColosseumSession) MAXTXS() (*big.Int, error)

+ func (_Colosseum *ColosseumSession) PROVINGTIMEOUT() (*big.Int, error)

+ func (_Colosseum *ColosseumSession) ProveFault(_outputIndex *big.Int, _pos *big.Int, _proof TypesPublicInputProof, ...) (*types.Transaction, error)

+ func (_Colosseum *ColosseumSession) SECURITYCOUNCIL() (common.Address, error)

+ func (_Colosseum *ColosseumSession) VerifiedPublicInputs(arg0 [32]byte) (bool, error)

+ func (_Colosseum *ColosseumSession) Version() (string, error)

+ func (_Colosseum *ColosseumSession) ZKMERKLETRIE() (common.Address, error)

+ func (_Colosseum *ColosseumSession) ZKVERIFIER() (common.Address, error)

+ type ColosseumTransactor struct

+ func NewColosseumTransactor(address common.Address, transactor bind.ContractTransactor) (*ColosseumTransactor, error)

+ func (_Colosseum *ColosseumTransactor) Bisect(opts *bind.TransactOpts, _outputIndex *big.Int, _challenger common.Address, ...) (*types.Transaction, error)

+ func (_Colosseum *ColosseumTransactor) CancelChallenge(opts *bind.TransactOpts, _outputIndex *big.Int) (*types.Transaction, error)

+ func (_Colosseum *ColosseumTransactor) ChallengerTimeout(opts *bind.TransactOpts, _outputIndex *big.Int, _challenger common.Address) (*types.Transaction, error)

+ func (_Colosseum *ColosseumTransactor) CreateChallenge(opts *bind.TransactOpts, _outputIndex *big.Int, _l1BlockHash [32]byte, ...) (*types.Transaction, error)

+ func (_Colosseum *ColosseumTransactor) DismissChallenge(opts *bind.TransactOpts, _outputIndex *big.Int, _challenger common.Address, ...) (*types.Transaction, error)

+ func (_Colosseum *ColosseumTransactor) ForceDeleteOutput(opts *bind.TransactOpts, _outputIndex *big.Int) (*types.Transaction, error)

+ func (_Colosseum *ColosseumTransactor) Initialize(opts *bind.TransactOpts, _segmentsLengths []*big.Int) (*types.Transaction, error)

+ func (_Colosseum *ColosseumTransactor) ProveFault(opts *bind.TransactOpts, _outputIndex *big.Int, _pos *big.Int, ...) (*types.Transaction, error)

+ type ColosseumTransactorRaw struct

+ Contract *ColosseumTransactor

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

+ func (_Colosseum *ColosseumTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ColosseumTransactorSession struct

+ Contract *ColosseumTransactor

+ TransactOpts bind.TransactOpts

+ func (_Colosseum *ColosseumTransactorSession) Bisect(_outputIndex *big.Int, _challenger common.Address, _pos *big.Int, ...) (*types.Transaction, error)

+ func (_Colosseum *ColosseumTransactorSession) CancelChallenge(_outputIndex *big.Int) (*types.Transaction, error)

+ func (_Colosseum *ColosseumTransactorSession) ChallengerTimeout(_outputIndex *big.Int, _challenger common.Address) (*types.Transaction, error)

+ func (_Colosseum *ColosseumTransactorSession) CreateChallenge(_outputIndex *big.Int, _l1BlockHash [32]byte, _l1BlockNumber *big.Int, ...) (*types.Transaction, error)

+ func (_Colosseum *ColosseumTransactorSession) DismissChallenge(_outputIndex *big.Int, _challenger common.Address, _asserter common.Address, ...) (*types.Transaction, error)

+ func (_Colosseum *ColosseumTransactorSession) ForceDeleteOutput(_outputIndex *big.Int) (*types.Transaction, error)

+ func (_Colosseum *ColosseumTransactorSession) Initialize(_segmentsLengths []*big.Int) (*types.Transaction, error)

+ func (_Colosseum *ColosseumTransactorSession) ProveFault(_outputIndex *big.Int, _pos *big.Int, _proof TypesPublicInputProof, ...) (*types.Transaction, error)

+ type ERC20 struct

+ func DeployERC20(auth *bind.TransactOpts, backend bind.ContractBackend, name_ string, ...) (common.Address, *types.Transaction, *ERC20, error)

+ func NewERC20(address common.Address, backend bind.ContractBackend) (*ERC20, error)

+ type ERC20Approval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type ERC20ApprovalIterator struct

+ Event *ERC20Approval

+ func (it *ERC20ApprovalIterator) Close() error

+ func (it *ERC20ApprovalIterator) Error() error

+ func (it *ERC20ApprovalIterator) Next() bool

+ type ERC20Caller struct

+ func NewERC20Caller(address common.Address, caller bind.ContractCaller) (*ERC20Caller, error)

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

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

+ func (_ERC20 *ERC20Caller) Decimals(opts *bind.CallOpts) (uint8, error)

+ func (_ERC20 *ERC20Caller) Name(opts *bind.CallOpts) (string, error)

+ func (_ERC20 *ERC20Caller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_ERC20 *ERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type ERC20CallerRaw struct

+ Contract *ERC20Caller

+ func (_ERC20 *ERC20CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type ERC20CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC20Caller

+ func (_ERC20 *ERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20CallerSession) Decimals() (uint8, error)

+ func (_ERC20 *ERC20CallerSession) Name() (string, error)

+ func (_ERC20 *ERC20CallerSession) Symbol() (string, error)

+ func (_ERC20 *ERC20CallerSession) TotalSupply() (*big.Int, error)

+ type ERC20Filterer struct

+ func NewERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*ERC20Filterer, error)

+ func (_ERC20 *ERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20ApprovalIterator, error)

+ func (_ERC20 *ERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20TransferIterator, error)

+ func (_ERC20 *ERC20Filterer) ParseApproval(log types.Log) (*ERC20Approval, error)

+ func (_ERC20 *ERC20Filterer) ParseTransfer(log types.Log) (*ERC20Transfer, error)

+ func (_ERC20 *ERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20Approval, owner []common.Address, ...) (event.Subscription, error)

+ func (_ERC20 *ERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20Transfer, from []common.Address, ...) (event.Subscription, error)

+ type ERC20Raw struct

+ Contract *ERC20

+ func (_ERC20 *ERC20Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_ERC20 *ERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20Session struct

+ CallOpts bind.CallOpts

+ Contract *ERC20

+ TransactOpts bind.TransactOpts

+ func (_ERC20 *ERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

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

+ func (_ERC20 *ERC20Session) BalanceOf(account common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20Session) Decimals() (uint8, error)

+ func (_ERC20 *ERC20Session) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Session) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Session) Name() (string, error)

+ func (_ERC20 *ERC20Session) Symbol() (string, error)

+ func (_ERC20 *ERC20Session) TotalSupply() (*big.Int, error)

+ func (_ERC20 *ERC20Session) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Session) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error)

+ type ERC20Transactor struct

+ func NewERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*ERC20Transactor, error)

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

+ func (_ERC20 *ERC20Transactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Transactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Transactor) Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ type ERC20TransactorRaw struct

+ Contract *ERC20Transactor

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

+ func (_ERC20 *ERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20TransactorSession struct

+ Contract *ERC20Transactor

+ TransactOpts bind.TransactOpts

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

+ func (_ERC20 *ERC20TransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20TransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20TransactorSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20TransactorSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error)

+ type ERC20Transfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type ERC20TransferIterator struct

+ Event *ERC20Transfer

+ func (it *ERC20TransferIterator) Close() error

+ func (it *ERC20TransferIterator) Error() error

+ func (it *ERC20TransferIterator) Next() bool

+ type GasPriceOracle struct

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

+ func NewGasPriceOracle(address common.Address, backend bind.ContractBackend) (*GasPriceOracle, error)

+ type GasPriceOracleCaller struct

+ func NewGasPriceOracleCaller(address common.Address, caller bind.ContractCaller) (*GasPriceOracleCaller, error)

+ func (_GasPriceOracle *GasPriceOracleCaller) BaseFee(opts *bind.CallOpts) (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleCaller) DECIMALS(opts *bind.CallOpts) (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleCaller) GasPrice(opts *bind.CallOpts) (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleCaller) GetL1Fee(opts *bind.CallOpts, _data []byte) (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleCaller) GetL1GasUsed(opts *bind.CallOpts, _data []byte) (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleCaller) L1BaseFee(opts *bind.CallOpts) (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleCaller) Overhead(opts *bind.CallOpts) (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleCaller) Scalar(opts *bind.CallOpts) (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleCaller) Version(opts *bind.CallOpts) (string, error)

+ type GasPriceOracleCallerRaw struct

+ Contract *GasPriceOracleCaller

+ func (_GasPriceOracle *GasPriceOracleCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type GasPriceOracleCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *GasPriceOracleCaller

+ func (_GasPriceOracle *GasPriceOracleCallerSession) BaseFee() (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleCallerSession) DECIMALS() (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleCallerSession) GasPrice() (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleCallerSession) GetL1Fee(_data []byte) (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleCallerSession) GetL1GasUsed(_data []byte) (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleCallerSession) L1BaseFee() (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleCallerSession) Overhead() (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleCallerSession) Scalar() (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleCallerSession) Version() (string, error)

+ type GasPriceOracleFilterer struct

+ func NewGasPriceOracleFilterer(address common.Address, filterer bind.ContractFilterer) (*GasPriceOracleFilterer, error)

+ type GasPriceOracleRaw struct

+ Contract *GasPriceOracle

+ func (_GasPriceOracle *GasPriceOracleRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_GasPriceOracle *GasPriceOracleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type GasPriceOracleSession struct

+ CallOpts bind.CallOpts

+ Contract *GasPriceOracle

+ TransactOpts bind.TransactOpts

+ func (_GasPriceOracle *GasPriceOracleSession) BaseFee() (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleSession) DECIMALS() (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleSession) GasPrice() (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleSession) GetL1Fee(_data []byte) (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleSession) GetL1GasUsed(_data []byte) (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleSession) L1BaseFee() (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleSession) Overhead() (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleSession) Scalar() (*big.Int, error)

+ func (_GasPriceOracle *GasPriceOracleSession) Version() (string, error)

+ type GasPriceOracleTransactor struct

+ func NewGasPriceOracleTransactor(address common.Address, transactor bind.ContractTransactor) (*GasPriceOracleTransactor, error)

+ type GasPriceOracleTransactorRaw struct

+ Contract *GasPriceOracleTransactor

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

+ func (_GasPriceOracle *GasPriceOracleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type GasPriceOracleTransactorSession struct

+ Contract *GasPriceOracleTransactor

+ TransactOpts bind.TransactOpts

+ type KromaMintableERC20 struct

+ func DeployKromaMintableERC20(auth *bind.TransactOpts, backend bind.ContractBackend, _bridge common.Address, ...) (common.Address, *types.Transaction, *KromaMintableERC20, error)

+ func NewKromaMintableERC20(address common.Address, backend bind.ContractBackend) (*KromaMintableERC20, error)

+ type KromaMintableERC20Approval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type KromaMintableERC20ApprovalIterator struct

+ Event *KromaMintableERC20Approval

+ func (it *KromaMintableERC20ApprovalIterator) Close() error

+ func (it *KromaMintableERC20ApprovalIterator) Error() error

+ func (it *KromaMintableERC20ApprovalIterator) Next() bool

+ type KromaMintableERC20Burn struct

+ Account common.Address

+ Amount *big.Int

+ Raw types.Log

+ type KromaMintableERC20BurnIterator struct

+ Event *KromaMintableERC20Burn

+ func (it *KromaMintableERC20BurnIterator) Close() error

+ func (it *KromaMintableERC20BurnIterator) Error() error

+ func (it *KromaMintableERC20BurnIterator) Next() bool

+ type KromaMintableERC20Caller struct

+ func NewKromaMintableERC20Caller(address common.Address, caller bind.ContractCaller) (*KromaMintableERC20Caller, error)

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

+ func (_KromaMintableERC20 *KromaMintableERC20Caller) BRIDGE(opts *bind.CallOpts) (common.Address, error)

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

+ func (_KromaMintableERC20 *KromaMintableERC20Caller) Decimals(opts *bind.CallOpts) (uint8, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Caller) Name(opts *bind.CallOpts) (string, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Caller) REMOTETOKEN(opts *bind.CallOpts) (common.Address, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Caller) SupportsInterface(opts *bind.CallOpts, _interfaceId [4]byte) (bool, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Caller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Caller) Version(opts *bind.CallOpts) (string, error)

+ type KromaMintableERC20CallerRaw struct

+ Contract *KromaMintableERC20Caller

+ func (_KromaMintableERC20 *KromaMintableERC20CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type KromaMintableERC20CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *KromaMintableERC20Caller

+ func (_KromaMintableERC20 *KromaMintableERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_KromaMintableERC20 *KromaMintableERC20CallerSession) BRIDGE() (common.Address, error)

+ func (_KromaMintableERC20 *KromaMintableERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_KromaMintableERC20 *KromaMintableERC20CallerSession) Decimals() (uint8, error)

+ func (_KromaMintableERC20 *KromaMintableERC20CallerSession) Name() (string, error)

+ func (_KromaMintableERC20 *KromaMintableERC20CallerSession) REMOTETOKEN() (common.Address, error)

+ func (_KromaMintableERC20 *KromaMintableERC20CallerSession) SupportsInterface(_interfaceId [4]byte) (bool, error)

+ func (_KromaMintableERC20 *KromaMintableERC20CallerSession) Symbol() (string, error)

+ func (_KromaMintableERC20 *KromaMintableERC20CallerSession) TotalSupply() (*big.Int, error)

+ func (_KromaMintableERC20 *KromaMintableERC20CallerSession) Version() (string, error)

+ type KromaMintableERC20Factory struct

+ func DeployKromaMintableERC20Factory(auth *bind.TransactOpts, backend bind.ContractBackend, _bridge common.Address) (common.Address, *types.Transaction, *KromaMintableERC20Factory, error)

+ func NewKromaMintableERC20Factory(address common.Address, backend bind.ContractBackend) (*KromaMintableERC20Factory, error)

+ type KromaMintableERC20FactoryCaller struct

+ func NewKromaMintableERC20FactoryCaller(address common.Address, caller bind.ContractCaller) (*KromaMintableERC20FactoryCaller, error)

+ func (_KromaMintableERC20Factory *KromaMintableERC20FactoryCaller) BRIDGE(opts *bind.CallOpts) (common.Address, error)

+ func (_KromaMintableERC20Factory *KromaMintableERC20FactoryCaller) Version(opts *bind.CallOpts) (string, error)

+ type KromaMintableERC20FactoryCallerRaw struct

+ Contract *KromaMintableERC20FactoryCaller

+ func (_KromaMintableERC20Factory *KromaMintableERC20FactoryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type KromaMintableERC20FactoryCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *KromaMintableERC20FactoryCaller

+ func (_KromaMintableERC20Factory *KromaMintableERC20FactoryCallerSession) BRIDGE() (common.Address, error)

+ func (_KromaMintableERC20Factory *KromaMintableERC20FactoryCallerSession) Version() (string, error)

+ type KromaMintableERC20FactoryFilterer struct

+ func NewKromaMintableERC20FactoryFilterer(address common.Address, filterer bind.ContractFilterer) (*KromaMintableERC20FactoryFilterer, error)

+ func (_KromaMintableERC20Factory *KromaMintableERC20FactoryFilterer) FilterKromaMintableERC20Created(opts *bind.FilterOpts, localToken []common.Address, ...) (*KromaMintableERC20FactoryKromaMintableERC20CreatedIterator, error)

+ func (_KromaMintableERC20Factory *KromaMintableERC20FactoryFilterer) ParseKromaMintableERC20Created(log types.Log) (*KromaMintableERC20FactoryKromaMintableERC20Created, error)

+ func (_KromaMintableERC20Factory *KromaMintableERC20FactoryFilterer) WatchKromaMintableERC20Created(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ type KromaMintableERC20FactoryKromaMintableERC20Created struct

+ Deployer common.Address

+ LocalToken common.Address

+ Raw types.Log

+ RemoteToken common.Address

+ type KromaMintableERC20FactoryKromaMintableERC20CreatedIterator struct

+ Event *KromaMintableERC20FactoryKromaMintableERC20Created

+ func (it *KromaMintableERC20FactoryKromaMintableERC20CreatedIterator) Close() error

+ func (it *KromaMintableERC20FactoryKromaMintableERC20CreatedIterator) Error() error

+ func (it *KromaMintableERC20FactoryKromaMintableERC20CreatedIterator) Next() bool

+ type KromaMintableERC20FactoryRaw struct

+ Contract *KromaMintableERC20Factory

+ func (_KromaMintableERC20Factory *KromaMintableERC20FactoryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_KromaMintableERC20Factory *KromaMintableERC20FactoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type KromaMintableERC20FactorySession struct

+ CallOpts bind.CallOpts

+ Contract *KromaMintableERC20Factory

+ TransactOpts bind.TransactOpts

+ func (_KromaMintableERC20Factory *KromaMintableERC20FactorySession) BRIDGE() (common.Address, error)

+ func (_KromaMintableERC20Factory *KromaMintableERC20FactorySession) CreateKromaMintableERC20(_remoteToken common.Address, _name string, _symbol string) (*types.Transaction, error)

+ func (_KromaMintableERC20Factory *KromaMintableERC20FactorySession) Version() (string, error)

+ type KromaMintableERC20FactoryTransactor struct

+ func NewKromaMintableERC20FactoryTransactor(address common.Address, transactor bind.ContractTransactor) (*KromaMintableERC20FactoryTransactor, error)

+ func (_KromaMintableERC20Factory *KromaMintableERC20FactoryTransactor) CreateKromaMintableERC20(opts *bind.TransactOpts, _remoteToken common.Address, _name string, ...) (*types.Transaction, error)

+ type KromaMintableERC20FactoryTransactorRaw struct

+ Contract *KromaMintableERC20FactoryTransactor

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

+ func (_KromaMintableERC20Factory *KromaMintableERC20FactoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type KromaMintableERC20FactoryTransactorSession struct

+ Contract *KromaMintableERC20FactoryTransactor

+ TransactOpts bind.TransactOpts

+ func (_KromaMintableERC20Factory *KromaMintableERC20FactoryTransactorSession) CreateKromaMintableERC20(_remoteToken common.Address, _name string, _symbol string) (*types.Transaction, error)

+ type KromaMintableERC20Filterer struct

+ func NewKromaMintableERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*KromaMintableERC20Filterer, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*KromaMintableERC20ApprovalIterator, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Filterer) FilterBurn(opts *bind.FilterOpts, account []common.Address) (*KromaMintableERC20BurnIterator, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Filterer) FilterMint(opts *bind.FilterOpts, account []common.Address) (*KromaMintableERC20MintIterator, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*KromaMintableERC20TransferIterator, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Filterer) ParseApproval(log types.Log) (*KromaMintableERC20Approval, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Filterer) ParseBurn(log types.Log) (*KromaMintableERC20Burn, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Filterer) ParseMint(log types.Log) (*KromaMintableERC20Mint, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Filterer) ParseTransfer(log types.Log) (*KromaMintableERC20Transfer, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *KromaMintableERC20Approval, ...) (event.Subscription, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Filterer) WatchBurn(opts *bind.WatchOpts, sink chan<- *KromaMintableERC20Burn, ...) (event.Subscription, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Filterer) WatchMint(opts *bind.WatchOpts, sink chan<- *KromaMintableERC20Mint, ...) (event.Subscription, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *KromaMintableERC20Transfer, ...) (event.Subscription, error)

+ type KromaMintableERC20Mint struct

+ Account common.Address

+ Amount *big.Int

+ Raw types.Log

+ type KromaMintableERC20MintIterator struct

+ Event *KromaMintableERC20Mint

+ func (it *KromaMintableERC20MintIterator) Close() error

+ func (it *KromaMintableERC20MintIterator) Error() error

+ func (it *KromaMintableERC20MintIterator) Next() bool

+ type KromaMintableERC20Raw struct

+ Contract *KromaMintableERC20

+ func (_KromaMintableERC20 *KromaMintableERC20Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_KromaMintableERC20 *KromaMintableERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type KromaMintableERC20Session struct

+ CallOpts bind.CallOpts

+ Contract *KromaMintableERC20

+ TransactOpts bind.TransactOpts

+ func (_KromaMintableERC20 *KromaMintableERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

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

+ func (_KromaMintableERC20 *KromaMintableERC20Session) BRIDGE() (common.Address, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Session) BalanceOf(account common.Address) (*big.Int, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Session) Burn(_from common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Session) Decimals() (uint8, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Session) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Session) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Session) Mint(_to common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Session) Name() (string, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Session) REMOTETOKEN() (common.Address, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Session) SupportsInterface(_interfaceId [4]byte) (bool, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Session) Symbol() (string, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Session) TotalSupply() (*big.Int, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Session) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Session) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Session) Version() (string, error)

+ type KromaMintableERC20Transactor struct

+ func NewKromaMintableERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*KromaMintableERC20Transactor, error)

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

+ func (_KromaMintableERC20 *KromaMintableERC20Transactor) Burn(opts *bind.TransactOpts, _from common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Transactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Transactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Transactor) Mint(opts *bind.TransactOpts, _to common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Transactor) Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_KromaMintableERC20 *KromaMintableERC20Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ type KromaMintableERC20TransactorRaw struct

+ Contract *KromaMintableERC20Transactor

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

+ func (_KromaMintableERC20 *KromaMintableERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type KromaMintableERC20TransactorSession struct

+ Contract *KromaMintableERC20Transactor

+ TransactOpts bind.TransactOpts

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

+ func (_KromaMintableERC20 *KromaMintableERC20TransactorSession) Burn(_from common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_KromaMintableERC20 *KromaMintableERC20TransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_KromaMintableERC20 *KromaMintableERC20TransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_KromaMintableERC20 *KromaMintableERC20TransactorSession) Mint(_to common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_KromaMintableERC20 *KromaMintableERC20TransactorSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_KromaMintableERC20 *KromaMintableERC20TransactorSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error)

+ type KromaMintableERC20Transfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type KromaMintableERC20TransferIterator struct

+ Event *KromaMintableERC20Transfer

+ func (it *KromaMintableERC20TransferIterator) Close() error

+ func (it *KromaMintableERC20TransferIterator) Error() error

+ func (it *KromaMintableERC20TransferIterator) Next() bool

+ type KromaMintableERC721Factory struct

+ func DeployKromaMintableERC721Factory(auth *bind.TransactOpts, backend bind.ContractBackend, _bridge common.Address, ...) (common.Address, *types.Transaction, *KromaMintableERC721Factory, error)

+ func NewKromaMintableERC721Factory(address common.Address, backend bind.ContractBackend) (*KromaMintableERC721Factory, error)

+ type KromaMintableERC721FactoryCaller struct

+ func NewKromaMintableERC721FactoryCaller(address common.Address, caller bind.ContractCaller) (*KromaMintableERC721FactoryCaller, error)

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactoryCaller) BRIDGE(opts *bind.CallOpts) (common.Address, error)

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactoryCaller) IsKromaMintableERC721(opts *bind.CallOpts, arg0 common.Address) (bool, error)

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactoryCaller) REMOTECHAINID(opts *bind.CallOpts) (*big.Int, error)

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactoryCaller) Version(opts *bind.CallOpts) (string, error)

+ type KromaMintableERC721FactoryCallerRaw struct

+ Contract *KromaMintableERC721FactoryCaller

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactoryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type KromaMintableERC721FactoryCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *KromaMintableERC721FactoryCaller

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactoryCallerSession) BRIDGE() (common.Address, error)

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactoryCallerSession) IsKromaMintableERC721(arg0 common.Address) (bool, error)

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactoryCallerSession) REMOTECHAINID() (*big.Int, error)

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactoryCallerSession) Version() (string, error)

+ type KromaMintableERC721FactoryFilterer struct

+ func NewKromaMintableERC721FactoryFilterer(address common.Address, filterer bind.ContractFilterer) (*KromaMintableERC721FactoryFilterer, error)

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactoryFilterer) FilterKromaMintableERC721Created(opts *bind.FilterOpts, localToken []common.Address, ...) (*KromaMintableERC721FactoryKromaMintableERC721CreatedIterator, error)

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactoryFilterer) ParseKromaMintableERC721Created(log types.Log) (*KromaMintableERC721FactoryKromaMintableERC721Created, error)

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactoryFilterer) WatchKromaMintableERC721Created(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ type KromaMintableERC721FactoryKromaMintableERC721Created struct

+ Deployer common.Address

+ LocalToken common.Address

+ Raw types.Log

+ RemoteToken common.Address

+ type KromaMintableERC721FactoryKromaMintableERC721CreatedIterator struct

+ Event *KromaMintableERC721FactoryKromaMintableERC721Created

+ func (it *KromaMintableERC721FactoryKromaMintableERC721CreatedIterator) Close() error

+ func (it *KromaMintableERC721FactoryKromaMintableERC721CreatedIterator) Error() error

+ func (it *KromaMintableERC721FactoryKromaMintableERC721CreatedIterator) Next() bool

+ type KromaMintableERC721FactoryRaw struct

+ Contract *KromaMintableERC721Factory

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactoryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type KromaMintableERC721FactorySession struct

+ CallOpts bind.CallOpts

+ Contract *KromaMintableERC721Factory

+ TransactOpts bind.TransactOpts

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactorySession) BRIDGE() (common.Address, error)

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactorySession) CreateKromaMintableERC721(_remoteToken common.Address, _name string, _symbol string) (*types.Transaction, error)

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactorySession) IsKromaMintableERC721(arg0 common.Address) (bool, error)

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactorySession) REMOTECHAINID() (*big.Int, error)

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactorySession) Version() (string, error)

+ type KromaMintableERC721FactoryTransactor struct

+ func NewKromaMintableERC721FactoryTransactor(address common.Address, transactor bind.ContractTransactor) (*KromaMintableERC721FactoryTransactor, error)

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactoryTransactor) CreateKromaMintableERC721(opts *bind.TransactOpts, _remoteToken common.Address, _name string, ...) (*types.Transaction, error)

+ type KromaMintableERC721FactoryTransactorRaw struct

+ Contract *KromaMintableERC721FactoryTransactor

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

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type KromaMintableERC721FactoryTransactorSession struct

+ Contract *KromaMintableERC721FactoryTransactor

+ TransactOpts bind.TransactOpts

+ func (_KromaMintableERC721Factory *KromaMintableERC721FactoryTransactorSession) CreateKromaMintableERC721(_remoteToken common.Address, _name string, _symbol string) (*types.Transaction, error)

+ type KromaPortal struct

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

+ func NewKromaPortal(address common.Address, backend bind.ContractBackend) (*KromaPortal, error)

+ type KromaPortalCaller struct

+ func NewKromaPortalCaller(address common.Address, caller bind.ContractCaller) (*KromaPortalCaller, error)

+ func (_KromaPortal *KromaPortalCaller) FinalizedWithdrawals(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ func (_KromaPortal *KromaPortalCaller) GUARDIAN(opts *bind.CallOpts) (common.Address, error)

+ func (_KromaPortal *KromaPortalCaller) IsOutputFinalized(opts *bind.CallOpts, _l2OutputIndex *big.Int) (bool, error)

+ func (_KromaPortal *KromaPortalCaller) L2ORACLE(opts *bind.CallOpts) (common.Address, error)

+ func (_KromaPortal *KromaPortalCaller) L2Sender(opts *bind.CallOpts) (common.Address, error)

+ func (_KromaPortal *KromaPortalCaller) Params(opts *bind.CallOpts) (struct{ ... }, error)

+ func (_KromaPortal *KromaPortalCaller) Paused(opts *bind.CallOpts) (bool, error)

+ func (_KromaPortal *KromaPortalCaller) ProvenWithdrawals(opts *bind.CallOpts, arg0 [32]byte) (struct{ ... }, error)

+ func (_KromaPortal *KromaPortalCaller) SYSTEMCONFIG(opts *bind.CallOpts) (common.Address, error)

+ func (_KromaPortal *KromaPortalCaller) VALIDATORPOOL(opts *bind.CallOpts) (common.Address, error)

+ func (_KromaPortal *KromaPortalCaller) Version(opts *bind.CallOpts) (string, error)

+ func (_KromaPortal *KromaPortalCaller) ZKMERKLETRIE(opts *bind.CallOpts) (common.Address, error)

+ type KromaPortalCallerRaw struct

+ Contract *KromaPortalCaller

+ func (_KromaPortal *KromaPortalCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type KromaPortalCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *KromaPortalCaller

+ func (_KromaPortal *KromaPortalCallerSession) FinalizedWithdrawals(arg0 [32]byte) (bool, error)

+ func (_KromaPortal *KromaPortalCallerSession) GUARDIAN() (common.Address, error)

+ func (_KromaPortal *KromaPortalCallerSession) IsOutputFinalized(_l2OutputIndex *big.Int) (bool, error)

+ func (_KromaPortal *KromaPortalCallerSession) L2ORACLE() (common.Address, error)

+ func (_KromaPortal *KromaPortalCallerSession) L2Sender() (common.Address, error)

+ func (_KromaPortal *KromaPortalCallerSession) Params() (struct{ ... }, error)

+ func (_KromaPortal *KromaPortalCallerSession) Paused() (bool, error)

+ func (_KromaPortal *KromaPortalCallerSession) ProvenWithdrawals(arg0 [32]byte) (struct{ ... }, error)

+ func (_KromaPortal *KromaPortalCallerSession) SYSTEMCONFIG() (common.Address, error)

+ func (_KromaPortal *KromaPortalCallerSession) VALIDATORPOOL() (common.Address, error)

+ func (_KromaPortal *KromaPortalCallerSession) Version() (string, error)

+ func (_KromaPortal *KromaPortalCallerSession) ZKMERKLETRIE() (common.Address, error)

+ type KromaPortalFilterer struct

+ func NewKromaPortalFilterer(address common.Address, filterer bind.ContractFilterer) (*KromaPortalFilterer, error)

+ func (_KromaPortal *KromaPortalFilterer) FilterInitialized(opts *bind.FilterOpts) (*KromaPortalInitializedIterator, error)

+ func (_KromaPortal *KromaPortalFilterer) FilterPaused(opts *bind.FilterOpts) (*KromaPortalPausedIterator, error)

+ func (_KromaPortal *KromaPortalFilterer) FilterTransactionDeposited(opts *bind.FilterOpts, from []common.Address, to []common.Address, ...) (*KromaPortalTransactionDepositedIterator, error)

+ func (_KromaPortal *KromaPortalFilterer) FilterUnpaused(opts *bind.FilterOpts) (*KromaPortalUnpausedIterator, error)

+ func (_KromaPortal *KromaPortalFilterer) FilterWithdrawalFinalized(opts *bind.FilterOpts, withdrawalHash [][32]byte) (*KromaPortalWithdrawalFinalizedIterator, error)

+ func (_KromaPortal *KromaPortalFilterer) FilterWithdrawalProven(opts *bind.FilterOpts, withdrawalHash [][32]byte, from []common.Address, ...) (*KromaPortalWithdrawalProvenIterator, error)

+ func (_KromaPortal *KromaPortalFilterer) ParseInitialized(log types.Log) (*KromaPortalInitialized, error)

+ func (_KromaPortal *KromaPortalFilterer) ParsePaused(log types.Log) (*KromaPortalPaused, error)

+ func (_KromaPortal *KromaPortalFilterer) ParseTransactionDeposited(log types.Log) (*KromaPortalTransactionDeposited, error)

+ func (_KromaPortal *KromaPortalFilterer) ParseUnpaused(log types.Log) (*KromaPortalUnpaused, error)

+ func (_KromaPortal *KromaPortalFilterer) ParseWithdrawalFinalized(log types.Log) (*KromaPortalWithdrawalFinalized, error)

+ func (_KromaPortal *KromaPortalFilterer) ParseWithdrawalProven(log types.Log) (*KromaPortalWithdrawalProven, error)

+ func (_KromaPortal *KromaPortalFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *KromaPortalInitialized) (event.Subscription, error)

+ func (_KromaPortal *KromaPortalFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *KromaPortalPaused) (event.Subscription, error)

+ func (_KromaPortal *KromaPortalFilterer) WatchTransactionDeposited(opts *bind.WatchOpts, sink chan<- *KromaPortalTransactionDeposited, ...) (event.Subscription, error)

+ func (_KromaPortal *KromaPortalFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *KromaPortalUnpaused) (event.Subscription, error)

+ func (_KromaPortal *KromaPortalFilterer) WatchWithdrawalFinalized(opts *bind.WatchOpts, sink chan<- *KromaPortalWithdrawalFinalized, ...) (event.Subscription, error)

+ func (_KromaPortal *KromaPortalFilterer) WatchWithdrawalProven(opts *bind.WatchOpts, sink chan<- *KromaPortalWithdrawalProven, ...) (event.Subscription, error)

+ type KromaPortalInitialized struct

+ Raw types.Log

+ Version uint8

+ type KromaPortalInitializedIterator struct

+ Event *KromaPortalInitialized

+ func (it *KromaPortalInitializedIterator) Close() error

+ func (it *KromaPortalInitializedIterator) Error() error

+ func (it *KromaPortalInitializedIterator) Next() bool

+ type KromaPortalPaused struct

+ Account common.Address

+ Raw types.Log

+ type KromaPortalPausedIterator struct

+ Event *KromaPortalPaused

+ func (it *KromaPortalPausedIterator) Close() error

+ func (it *KromaPortalPausedIterator) Error() error

+ func (it *KromaPortalPausedIterator) Next() bool

+ type KromaPortalRaw struct

+ Contract *KromaPortal

+ func (_KromaPortal *KromaPortalRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_KromaPortal *KromaPortalRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type KromaPortalSession struct

+ CallOpts bind.CallOpts

+ Contract *KromaPortal

+ TransactOpts bind.TransactOpts

+ func (_KromaPortal *KromaPortalSession) DepositTransaction(_to common.Address, _value *big.Int, _gasLimit uint64, _isCreation bool, ...) (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalSession) DepositTransactionByValidatorPool(_to common.Address, _gasLimit uint64, _data []byte) (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalSession) FinalizeWithdrawalTransaction(_tx TypesWithdrawalTransaction) (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalSession) FinalizedWithdrawals(arg0 [32]byte) (bool, error)

+ func (_KromaPortal *KromaPortalSession) GUARDIAN() (common.Address, error)

+ func (_KromaPortal *KromaPortalSession) Initialize(_paused bool) (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalSession) IsOutputFinalized(_l2OutputIndex *big.Int) (bool, error)

+ func (_KromaPortal *KromaPortalSession) L2ORACLE() (common.Address, error)

+ func (_KromaPortal *KromaPortalSession) L2Sender() (common.Address, error)

+ func (_KromaPortal *KromaPortalSession) Params() (struct{ ... }, error)

+ func (_KromaPortal *KromaPortalSession) Pause() (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalSession) Paused() (bool, error)

+ func (_KromaPortal *KromaPortalSession) ProveWithdrawalTransaction(_tx TypesWithdrawalTransaction, _l2OutputIndex *big.Int, ...) (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalSession) ProvenWithdrawals(arg0 [32]byte) (struct{ ... }, error)

+ func (_KromaPortal *KromaPortalSession) Receive() (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalSession) SYSTEMCONFIG() (common.Address, error)

+ func (_KromaPortal *KromaPortalSession) Unpause() (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalSession) VALIDATORPOOL() (common.Address, error)

+ func (_KromaPortal *KromaPortalSession) Version() (string, error)

+ func (_KromaPortal *KromaPortalSession) ZKMERKLETRIE() (common.Address, error)

+ type KromaPortalTransactionDeposited struct

+ From common.Address

+ OpaqueData []byte

+ Raw types.Log

+ To common.Address

+ Version *big.Int

+ type KromaPortalTransactionDepositedIterator struct

+ Event *KromaPortalTransactionDeposited

+ func (it *KromaPortalTransactionDepositedIterator) Close() error

+ func (it *KromaPortalTransactionDepositedIterator) Error() error

+ func (it *KromaPortalTransactionDepositedIterator) Next() bool

+ type KromaPortalTransactor struct

+ func NewKromaPortalTransactor(address common.Address, transactor bind.ContractTransactor) (*KromaPortalTransactor, error)

+ func (_KromaPortal *KromaPortalTransactor) DepositTransaction(opts *bind.TransactOpts, _to common.Address, _value *big.Int, _gasLimit uint64, ...) (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalTransactor) DepositTransactionByValidatorPool(opts *bind.TransactOpts, _to common.Address, _gasLimit uint64, _data []byte) (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalTransactor) FinalizeWithdrawalTransaction(opts *bind.TransactOpts, _tx TypesWithdrawalTransaction) (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalTransactor) Initialize(opts *bind.TransactOpts, _paused bool) (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalTransactor) ProveWithdrawalTransaction(opts *bind.TransactOpts, _tx TypesWithdrawalTransaction, ...) (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error)

+ type KromaPortalTransactorRaw struct

+ Contract *KromaPortalTransactor

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

+ func (_KromaPortal *KromaPortalTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type KromaPortalTransactorSession struct

+ Contract *KromaPortalTransactor

+ TransactOpts bind.TransactOpts

+ func (_KromaPortal *KromaPortalTransactorSession) DepositTransaction(_to common.Address, _value *big.Int, _gasLimit uint64, _isCreation bool, ...) (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalTransactorSession) DepositTransactionByValidatorPool(_to common.Address, _gasLimit uint64, _data []byte) (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalTransactorSession) FinalizeWithdrawalTransaction(_tx TypesWithdrawalTransaction) (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalTransactorSession) Initialize(_paused bool) (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalTransactorSession) Pause() (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalTransactorSession) ProveWithdrawalTransaction(_tx TypesWithdrawalTransaction, _l2OutputIndex *big.Int, ...) (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalTransactorSession) Receive() (*types.Transaction, error)

+ func (_KromaPortal *KromaPortalTransactorSession) Unpause() (*types.Transaction, error)

+ type KromaPortalUnpaused struct

+ Account common.Address

+ Raw types.Log

+ type KromaPortalUnpausedIterator struct

+ Event *KromaPortalUnpaused

+ func (it *KromaPortalUnpausedIterator) Close() error

+ func (it *KromaPortalUnpausedIterator) Error() error

+ func (it *KromaPortalUnpausedIterator) Next() bool

+ type KromaPortalWithdrawalFinalized struct

+ Raw types.Log

+ Success bool

+ WithdrawalHash [32]byte

+ type KromaPortalWithdrawalFinalizedIterator struct

+ Event *KromaPortalWithdrawalFinalized

+ func (it *KromaPortalWithdrawalFinalizedIterator) Close() error

+ func (it *KromaPortalWithdrawalFinalizedIterator) Error() error

+ func (it *KromaPortalWithdrawalFinalizedIterator) Next() bool

+ type KromaPortalWithdrawalProven struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ WithdrawalHash [32]byte

+ type KromaPortalWithdrawalProvenIterator struct

+ Event *KromaPortalWithdrawalProven

+ func (it *KromaPortalWithdrawalProvenIterator) Close() error

+ func (it *KromaPortalWithdrawalProvenIterator) Error() error

+ func (it *KromaPortalWithdrawalProvenIterator) Next() bool

+ type L1Block struct

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

+ func NewL1Block(address common.Address, backend bind.ContractBackend) (*L1Block, error)

+ type L1BlockCaller struct

+ func NewL1BlockCaller(address common.Address, caller bind.ContractCaller) (*L1BlockCaller, error)

+ func (_L1Block *L1BlockCaller) Basefee(opts *bind.CallOpts) (*big.Int, error)

+ func (_L1Block *L1BlockCaller) BatcherHash(opts *bind.CallOpts) ([32]byte, error)

+ func (_L1Block *L1BlockCaller) DEPOSITORACCOUNT(opts *bind.CallOpts) (common.Address, error)

+ func (_L1Block *L1BlockCaller) Hash(opts *bind.CallOpts) ([32]byte, error)

+ func (_L1Block *L1BlockCaller) L1FeeOverhead(opts *bind.CallOpts) (*big.Int, error)

+ func (_L1Block *L1BlockCaller) L1FeeScalar(opts *bind.CallOpts) (*big.Int, error)

+ func (_L1Block *L1BlockCaller) Number(opts *bind.CallOpts) (uint64, error)

+ func (_L1Block *L1BlockCaller) SequenceNumber(opts *bind.CallOpts) (uint64, error)

+ func (_L1Block *L1BlockCaller) Timestamp(opts *bind.CallOpts) (uint64, error)

+ func (_L1Block *L1BlockCaller) ValidatorRewardScalar(opts *bind.CallOpts) (*big.Int, error)

+ func (_L1Block *L1BlockCaller) Version(opts *bind.CallOpts) (string, error)

+ type L1BlockCallerRaw struct

+ Contract *L1BlockCaller

+ func (_L1Block *L1BlockCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type L1BlockCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *L1BlockCaller

+ func (_L1Block *L1BlockCallerSession) Basefee() (*big.Int, error)

+ func (_L1Block *L1BlockCallerSession) BatcherHash() ([32]byte, error)

+ func (_L1Block *L1BlockCallerSession) DEPOSITORACCOUNT() (common.Address, error)

+ func (_L1Block *L1BlockCallerSession) Hash() ([32]byte, error)

+ func (_L1Block *L1BlockCallerSession) L1FeeOverhead() (*big.Int, error)

+ func (_L1Block *L1BlockCallerSession) L1FeeScalar() (*big.Int, error)

+ func (_L1Block *L1BlockCallerSession) Number() (uint64, error)

+ func (_L1Block *L1BlockCallerSession) SequenceNumber() (uint64, error)

+ func (_L1Block *L1BlockCallerSession) Timestamp() (uint64, error)

+ func (_L1Block *L1BlockCallerSession) ValidatorRewardScalar() (*big.Int, error)

+ func (_L1Block *L1BlockCallerSession) Version() (string, error)

+ type L1BlockFilterer struct

+ func NewL1BlockFilterer(address common.Address, filterer bind.ContractFilterer) (*L1BlockFilterer, error)

+ type L1BlockRaw struct

+ Contract *L1Block

+ func (_L1Block *L1BlockRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_L1Block *L1BlockRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L1BlockSession struct

+ CallOpts bind.CallOpts

+ Contract *L1Block

+ TransactOpts bind.TransactOpts

+ func (_L1Block *L1BlockSession) Basefee() (*big.Int, error)

+ func (_L1Block *L1BlockSession) BatcherHash() ([32]byte, error)

+ func (_L1Block *L1BlockSession) DEPOSITORACCOUNT() (common.Address, error)

+ func (_L1Block *L1BlockSession) Hash() ([32]byte, error)

+ func (_L1Block *L1BlockSession) L1FeeOverhead() (*big.Int, error)

+ func (_L1Block *L1BlockSession) L1FeeScalar() (*big.Int, error)

+ func (_L1Block *L1BlockSession) Number() (uint64, error)

+ func (_L1Block *L1BlockSession) SequenceNumber() (uint64, error)

+ func (_L1Block *L1BlockSession) SetL1BlockValues(_number uint64, _timestamp uint64, _basefee *big.Int, _hash [32]byte, ...) (*types.Transaction, error)

+ func (_L1Block *L1BlockSession) Timestamp() (uint64, error)

+ func (_L1Block *L1BlockSession) ValidatorRewardScalar() (*big.Int, error)

+ func (_L1Block *L1BlockSession) Version() (string, error)

+ type L1BlockTransactor struct

+ func NewL1BlockTransactor(address common.Address, transactor bind.ContractTransactor) (*L1BlockTransactor, error)

+ func (_L1Block *L1BlockTransactor) SetL1BlockValues(opts *bind.TransactOpts, _number uint64, _timestamp uint64, _basefee *big.Int, ...) (*types.Transaction, error)

+ type L1BlockTransactorRaw struct

+ Contract *L1BlockTransactor

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

+ func (_L1Block *L1BlockTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L1BlockTransactorSession struct

+ Contract *L1BlockTransactor

+ TransactOpts bind.TransactOpts

+ func (_L1Block *L1BlockTransactorSession) SetL1BlockValues(_number uint64, _timestamp uint64, _basefee *big.Int, _hash [32]byte, ...) (*types.Transaction, error)

+ type L1CrossDomainMessenger struct

+ func DeployL1CrossDomainMessenger(auth *bind.TransactOpts, backend bind.ContractBackend, _portal common.Address) (common.Address, *types.Transaction, *L1CrossDomainMessenger, error)

+ func NewL1CrossDomainMessenger(address common.Address, backend bind.ContractBackend) (*L1CrossDomainMessenger, error)

+ type L1CrossDomainMessengerCaller struct

+ func NewL1CrossDomainMessengerCaller(address common.Address, caller bind.ContractCaller) (*L1CrossDomainMessengerCaller, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCaller) BaseGas(opts *bind.CallOpts, _message []byte, _minGasLimit uint32) (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCaller) FailedMessages(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCaller) MESSAGEVERSION(opts *bind.CallOpts) (uint16, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCaller) MINGASCALLDATAOVERHEAD(opts *bind.CallOpts) (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCaller) MINGASDYNAMICOVERHEADDENOMINATOR(opts *bind.CallOpts) (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCaller) MINGASDYNAMICOVERHEADNUMERATOR(opts *bind.CallOpts) (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCaller) MessageNonce(opts *bind.CallOpts) (*big.Int, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCaller) OTHERMESSENGER(opts *bind.CallOpts) (common.Address, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCaller) PORTAL(opts *bind.CallOpts) (common.Address, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCaller) Paused(opts *bind.CallOpts) (bool, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCaller) RELAYCALLOVERHEAD(opts *bind.CallOpts) (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCaller) RELAYCONSTANTOVERHEAD(opts *bind.CallOpts) (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCaller) RELAYGASCHECKBUFFER(opts *bind.CallOpts) (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCaller) RELAYRESERVEDGAS(opts *bind.CallOpts) (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCaller) SuccessfulMessages(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCaller) Version(opts *bind.CallOpts) (string, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCaller) XDomainMessageSender(opts *bind.CallOpts) (common.Address, error)

+ type L1CrossDomainMessengerCallerRaw struct

+ Contract *L1CrossDomainMessengerCaller

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type L1CrossDomainMessengerCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *L1CrossDomainMessengerCaller

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) BaseGas(_message []byte, _minGasLimit uint32) (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) FailedMessages(arg0 [32]byte) (bool, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) MESSAGEVERSION() (uint16, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) MINGASCALLDATAOVERHEAD() (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) MINGASDYNAMICOVERHEADDENOMINATOR() (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) MINGASDYNAMICOVERHEADNUMERATOR() (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) MessageNonce() (*big.Int, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) OTHERMESSENGER() (common.Address, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) PORTAL() (common.Address, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) Paused() (bool, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) RELAYCALLOVERHEAD() (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) RELAYCONSTANTOVERHEAD() (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) RELAYGASCHECKBUFFER() (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) RELAYRESERVEDGAS() (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) SuccessfulMessages(arg0 [32]byte) (bool, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) Version() (string, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) XDomainMessageSender() (common.Address, error)

+ type L1CrossDomainMessengerFailedRelayedMessage struct

+ MsgHash [32]byte

+ Raw types.Log

+ type L1CrossDomainMessengerFailedRelayedMessageIterator struct

+ Event *L1CrossDomainMessengerFailedRelayedMessage

+ func (it *L1CrossDomainMessengerFailedRelayedMessageIterator) Close() error

+ func (it *L1CrossDomainMessengerFailedRelayedMessageIterator) Error() error

+ func (it *L1CrossDomainMessengerFailedRelayedMessageIterator) Next() bool

+ type L1CrossDomainMessengerFilterer struct

+ func NewL1CrossDomainMessengerFilterer(address common.Address, filterer bind.ContractFilterer) (*L1CrossDomainMessengerFilterer, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) FilterFailedRelayedMessage(opts *bind.FilterOpts, msgHash [][32]byte) (*L1CrossDomainMessengerFailedRelayedMessageIterator, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) FilterInitialized(opts *bind.FilterOpts) (*L1CrossDomainMessengerInitializedIterator, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) FilterPaused(opts *bind.FilterOpts) (*L1CrossDomainMessengerPausedIterator, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) FilterRelayedMessage(opts *bind.FilterOpts, msgHash [][32]byte) (*L1CrossDomainMessengerRelayedMessageIterator, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) FilterSentMessage(opts *bind.FilterOpts, target []common.Address, sender []common.Address) (*L1CrossDomainMessengerSentMessageIterator, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) FilterUnpaused(opts *bind.FilterOpts) (*L1CrossDomainMessengerUnpausedIterator, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) ParseFailedRelayedMessage(log types.Log) (*L1CrossDomainMessengerFailedRelayedMessage, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) ParseInitialized(log types.Log) (*L1CrossDomainMessengerInitialized, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) ParsePaused(log types.Log) (*L1CrossDomainMessengerPaused, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) ParseRelayedMessage(log types.Log) (*L1CrossDomainMessengerRelayedMessage, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) ParseSentMessage(log types.Log) (*L1CrossDomainMessengerSentMessage, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) ParseUnpaused(log types.Log) (*L1CrossDomainMessengerUnpaused, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) WatchFailedRelayedMessage(opts *bind.WatchOpts, sink chan<- *L1CrossDomainMessengerFailedRelayedMessage, ...) (event.Subscription, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *L1CrossDomainMessengerInitialized) (event.Subscription, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *L1CrossDomainMessengerPaused) (event.Subscription, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) WatchRelayedMessage(opts *bind.WatchOpts, sink chan<- *L1CrossDomainMessengerRelayedMessage, ...) (event.Subscription, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) WatchSentMessage(opts *bind.WatchOpts, sink chan<- *L1CrossDomainMessengerSentMessage, ...) (event.Subscription, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *L1CrossDomainMessengerUnpaused) (event.Subscription, error)

+ type L1CrossDomainMessengerInitialized struct

+ Raw types.Log

+ Version uint8

+ type L1CrossDomainMessengerInitializedIterator struct

+ Event *L1CrossDomainMessengerInitialized

+ func (it *L1CrossDomainMessengerInitializedIterator) Close() error

+ func (it *L1CrossDomainMessengerInitializedIterator) Error() error

+ func (it *L1CrossDomainMessengerInitializedIterator) Next() bool

+ type L1CrossDomainMessengerPaused struct

+ Account common.Address

+ Raw types.Log

+ type L1CrossDomainMessengerPausedIterator struct

+ Event *L1CrossDomainMessengerPaused

+ func (it *L1CrossDomainMessengerPausedIterator) Close() error

+ func (it *L1CrossDomainMessengerPausedIterator) Error() error

+ func (it *L1CrossDomainMessengerPausedIterator) Next() bool

+ type L1CrossDomainMessengerRaw struct

+ Contract *L1CrossDomainMessenger

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L1CrossDomainMessengerRelayedMessage struct

+ MsgHash [32]byte

+ Raw types.Log

+ type L1CrossDomainMessengerRelayedMessageIterator struct

+ Event *L1CrossDomainMessengerRelayedMessage

+ func (it *L1CrossDomainMessengerRelayedMessageIterator) Close() error

+ func (it *L1CrossDomainMessengerRelayedMessageIterator) Error() error

+ func (it *L1CrossDomainMessengerRelayedMessageIterator) Next() bool

+ type L1CrossDomainMessengerSentMessage struct

+ GasLimit *big.Int

+ Message []byte

+ MessageNonce *big.Int

+ Raw types.Log

+ Sender common.Address

+ Target common.Address

+ Value *big.Int

+ type L1CrossDomainMessengerSentMessageIterator struct

+ Event *L1CrossDomainMessengerSentMessage

+ func (it *L1CrossDomainMessengerSentMessageIterator) Close() error

+ func (it *L1CrossDomainMessengerSentMessageIterator) Error() error

+ func (it *L1CrossDomainMessengerSentMessageIterator) Next() bool

+ type L1CrossDomainMessengerSession struct

+ CallOpts bind.CallOpts

+ Contract *L1CrossDomainMessenger

+ TransactOpts bind.TransactOpts

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) BaseGas(_message []byte, _minGasLimit uint32) (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) FailedMessages(arg0 [32]byte) (bool, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) Initialize() (*types.Transaction, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) MESSAGEVERSION() (uint16, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) MINGASCALLDATAOVERHEAD() (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) MINGASDYNAMICOVERHEADDENOMINATOR() (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) MINGASDYNAMICOVERHEADNUMERATOR() (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) MessageNonce() (*big.Int, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) OTHERMESSENGER() (common.Address, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) PORTAL() (common.Address, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) Paused() (bool, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) RELAYCALLOVERHEAD() (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) RELAYCONSTANTOVERHEAD() (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) RELAYGASCHECKBUFFER() (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) RELAYRESERVEDGAS() (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) RelayMessage(_nonce *big.Int, _sender common.Address, _target common.Address, ...) (*types.Transaction, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) SendMessage(_target common.Address, _message []byte, _minGasLimit uint32) (*types.Transaction, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) SuccessfulMessages(arg0 [32]byte) (bool, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) Version() (string, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) XDomainMessageSender() (common.Address, error)

+ type L1CrossDomainMessengerTransactor struct

+ func NewL1CrossDomainMessengerTransactor(address common.Address, transactor bind.ContractTransactor) (*L1CrossDomainMessengerTransactor, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerTransactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerTransactor) RelayMessage(opts *bind.TransactOpts, _nonce *big.Int, _sender common.Address, ...) (*types.Transaction, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerTransactor) SendMessage(opts *bind.TransactOpts, _target common.Address, _message []byte, ...) (*types.Transaction, error)

+ type L1CrossDomainMessengerTransactorRaw struct

+ Contract *L1CrossDomainMessengerTransactor

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

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L1CrossDomainMessengerTransactorSession struct

+ Contract *L1CrossDomainMessengerTransactor

+ TransactOpts bind.TransactOpts

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerTransactorSession) Initialize() (*types.Transaction, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerTransactorSession) RelayMessage(_nonce *big.Int, _sender common.Address, _target common.Address, ...) (*types.Transaction, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerTransactorSession) SendMessage(_target common.Address, _message []byte, _minGasLimit uint32) (*types.Transaction, error)

+ type L1CrossDomainMessengerUnpaused struct

+ Account common.Address

+ Raw types.Log

+ type L1CrossDomainMessengerUnpausedIterator struct

+ Event *L1CrossDomainMessengerUnpaused

+ func (it *L1CrossDomainMessengerUnpausedIterator) Close() error

+ func (it *L1CrossDomainMessengerUnpausedIterator) Error() error

+ func (it *L1CrossDomainMessengerUnpausedIterator) Next() bool

+ type L1ERC721Bridge struct

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

+ func NewL1ERC721Bridge(address common.Address, backend bind.ContractBackend) (*L1ERC721Bridge, error)

+ type L1ERC721BridgeCaller struct

+ func NewL1ERC721BridgeCaller(address common.Address, caller bind.ContractCaller) (*L1ERC721BridgeCaller, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeCaller) Deposits(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address, arg2 *big.Int) (bool, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeCaller) MESSENGER(opts *bind.CallOpts) (common.Address, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeCaller) OTHERBRIDGE(opts *bind.CallOpts) (common.Address, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeCaller) Version(opts *bind.CallOpts) (string, error)

+ type L1ERC721BridgeCallerRaw struct

+ Contract *L1ERC721BridgeCaller

+ func (_L1ERC721Bridge *L1ERC721BridgeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type L1ERC721BridgeCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *L1ERC721BridgeCaller

+ func (_L1ERC721Bridge *L1ERC721BridgeCallerSession) Deposits(arg0 common.Address, arg1 common.Address, arg2 *big.Int) (bool, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeCallerSession) MESSENGER() (common.Address, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeCallerSession) OTHERBRIDGE() (common.Address, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeCallerSession) Version() (string, error)

+ type L1ERC721BridgeERC721BridgeFinalized struct

+ ExtraData []byte

+ From common.Address

+ LocalToken common.Address

+ Raw types.Log

+ RemoteToken common.Address

+ To common.Address

+ TokenId *big.Int

+ type L1ERC721BridgeERC721BridgeFinalizedIterator struct

+ Event *L1ERC721BridgeERC721BridgeFinalized

+ func (it *L1ERC721BridgeERC721BridgeFinalizedIterator) Close() error

+ func (it *L1ERC721BridgeERC721BridgeFinalizedIterator) Error() error

+ func (it *L1ERC721BridgeERC721BridgeFinalizedIterator) Next() bool

+ type L1ERC721BridgeERC721BridgeInitiated struct

+ ExtraData []byte

+ From common.Address

+ LocalToken common.Address

+ Raw types.Log

+ RemoteToken common.Address

+ To common.Address

+ TokenId *big.Int

+ type L1ERC721BridgeERC721BridgeInitiatedIterator struct

+ Event *L1ERC721BridgeERC721BridgeInitiated

+ func (it *L1ERC721BridgeERC721BridgeInitiatedIterator) Close() error

+ func (it *L1ERC721BridgeERC721BridgeInitiatedIterator) Error() error

+ func (it *L1ERC721BridgeERC721BridgeInitiatedIterator) Next() bool

+ type L1ERC721BridgeFilterer struct

+ func NewL1ERC721BridgeFilterer(address common.Address, filterer bind.ContractFilterer) (*L1ERC721BridgeFilterer, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeFilterer) FilterERC721BridgeFinalized(opts *bind.FilterOpts, localToken []common.Address, ...) (*L1ERC721BridgeERC721BridgeFinalizedIterator, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeFilterer) FilterERC721BridgeInitiated(opts *bind.FilterOpts, localToken []common.Address, ...) (*L1ERC721BridgeERC721BridgeInitiatedIterator, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeFilterer) ParseERC721BridgeFinalized(log types.Log) (*L1ERC721BridgeERC721BridgeFinalized, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeFilterer) ParseERC721BridgeInitiated(log types.Log) (*L1ERC721BridgeERC721BridgeInitiated, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeFilterer) WatchERC721BridgeFinalized(opts *bind.WatchOpts, sink chan<- *L1ERC721BridgeERC721BridgeFinalized, ...) (event.Subscription, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeFilterer) WatchERC721BridgeInitiated(opts *bind.WatchOpts, sink chan<- *L1ERC721BridgeERC721BridgeInitiated, ...) (event.Subscription, error)

+ type L1ERC721BridgeRaw struct

+ Contract *L1ERC721Bridge

+ func (_L1ERC721Bridge *L1ERC721BridgeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_L1ERC721Bridge *L1ERC721BridgeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L1ERC721BridgeSession struct

+ CallOpts bind.CallOpts

+ Contract *L1ERC721Bridge

+ TransactOpts bind.TransactOpts

+ func (_L1ERC721Bridge *L1ERC721BridgeSession) BridgeERC721(_localToken common.Address, _remoteToken common.Address, _tokenId *big.Int, ...) (*types.Transaction, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeSession) BridgeERC721To(_localToken common.Address, _remoteToken common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeSession) Deposits(arg0 common.Address, arg1 common.Address, arg2 *big.Int) (bool, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeSession) FinalizeBridgeERC721(_localToken common.Address, _remoteToken common.Address, _from common.Address, ...) (*types.Transaction, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeSession) MESSENGER() (common.Address, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeSession) OTHERBRIDGE() (common.Address, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeSession) Version() (string, error)

+ type L1ERC721BridgeTransactor struct

+ func NewL1ERC721BridgeTransactor(address common.Address, transactor bind.ContractTransactor) (*L1ERC721BridgeTransactor, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeTransactor) BridgeERC721(opts *bind.TransactOpts, _localToken common.Address, ...) (*types.Transaction, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeTransactor) BridgeERC721To(opts *bind.TransactOpts, _localToken common.Address, ...) (*types.Transaction, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeTransactor) FinalizeBridgeERC721(opts *bind.TransactOpts, _localToken common.Address, ...) (*types.Transaction, error)

+ type L1ERC721BridgeTransactorRaw struct

+ Contract *L1ERC721BridgeTransactor

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

+ func (_L1ERC721Bridge *L1ERC721BridgeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L1ERC721BridgeTransactorSession struct

+ Contract *L1ERC721BridgeTransactor

+ TransactOpts bind.TransactOpts

+ func (_L1ERC721Bridge *L1ERC721BridgeTransactorSession) BridgeERC721(_localToken common.Address, _remoteToken common.Address, _tokenId *big.Int, ...) (*types.Transaction, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeTransactorSession) BridgeERC721To(_localToken common.Address, _remoteToken common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeTransactorSession) FinalizeBridgeERC721(_localToken common.Address, _remoteToken common.Address, _from common.Address, ...) (*types.Transaction, error)

+ type L1FeeVault struct

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

+ func NewL1FeeVault(address common.Address, backend bind.ContractBackend) (*L1FeeVault, error)

+ type L1FeeVaultCaller struct

+ func NewL1FeeVaultCaller(address common.Address, caller bind.ContractCaller) (*L1FeeVaultCaller, error)

+ func (_L1FeeVault *L1FeeVaultCaller) MINWITHDRAWALAMOUNT(opts *bind.CallOpts) (*big.Int, error)

+ func (_L1FeeVault *L1FeeVaultCaller) RECIPIENT(opts *bind.CallOpts) (common.Address, error)

+ func (_L1FeeVault *L1FeeVaultCaller) TotalProcessed(opts *bind.CallOpts) (*big.Int, error)

+ func (_L1FeeVault *L1FeeVaultCaller) Version(opts *bind.CallOpts) (string, error)

+ type L1FeeVaultCallerRaw struct

+ Contract *L1FeeVaultCaller

+ func (_L1FeeVault *L1FeeVaultCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type L1FeeVaultCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *L1FeeVaultCaller

+ func (_L1FeeVault *L1FeeVaultCallerSession) MINWITHDRAWALAMOUNT() (*big.Int, error)

+ func (_L1FeeVault *L1FeeVaultCallerSession) RECIPIENT() (common.Address, error)

+ func (_L1FeeVault *L1FeeVaultCallerSession) TotalProcessed() (*big.Int, error)

+ func (_L1FeeVault *L1FeeVaultCallerSession) Version() (string, error)

+ type L1FeeVaultFilterer struct

+ func NewL1FeeVaultFilterer(address common.Address, filterer bind.ContractFilterer) (*L1FeeVaultFilterer, error)

+ func (_L1FeeVault *L1FeeVaultFilterer) FilterWithdrawal(opts *bind.FilterOpts) (*L1FeeVaultWithdrawalIterator, error)

+ func (_L1FeeVault *L1FeeVaultFilterer) ParseWithdrawal(log types.Log) (*L1FeeVaultWithdrawal, error)

+ func (_L1FeeVault *L1FeeVaultFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *L1FeeVaultWithdrawal) (event.Subscription, error)

+ type L1FeeVaultRaw struct

+ Contract *L1FeeVault

+ func (_L1FeeVault *L1FeeVaultRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_L1FeeVault *L1FeeVaultRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L1FeeVaultSession struct

+ CallOpts bind.CallOpts

+ Contract *L1FeeVault

+ TransactOpts bind.TransactOpts

+ func (_L1FeeVault *L1FeeVaultSession) MINWITHDRAWALAMOUNT() (*big.Int, error)

+ func (_L1FeeVault *L1FeeVaultSession) RECIPIENT() (common.Address, error)

+ func (_L1FeeVault *L1FeeVaultSession) Receive() (*types.Transaction, error)

+ func (_L1FeeVault *L1FeeVaultSession) TotalProcessed() (*big.Int, error)

+ func (_L1FeeVault *L1FeeVaultSession) Version() (string, error)

+ func (_L1FeeVault *L1FeeVaultSession) Withdraw() (*types.Transaction, error)

+ func (_L1FeeVault *L1FeeVaultSession) WithdrawToL2() (*types.Transaction, error)

+ type L1FeeVaultTransactor struct

+ func NewL1FeeVaultTransactor(address common.Address, transactor bind.ContractTransactor) (*L1FeeVaultTransactor, error)

+ func (_L1FeeVault *L1FeeVaultTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_L1FeeVault *L1FeeVaultTransactor) Withdraw(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_L1FeeVault *L1FeeVaultTransactor) WithdrawToL2(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L1FeeVaultTransactorRaw struct

+ Contract *L1FeeVaultTransactor

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

+ func (_L1FeeVault *L1FeeVaultTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L1FeeVaultTransactorSession struct

+ Contract *L1FeeVaultTransactor

+ TransactOpts bind.TransactOpts

+ func (_L1FeeVault *L1FeeVaultTransactorSession) Receive() (*types.Transaction, error)

+ func (_L1FeeVault *L1FeeVaultTransactorSession) Withdraw() (*types.Transaction, error)

+ func (_L1FeeVault *L1FeeVaultTransactorSession) WithdrawToL2() (*types.Transaction, error)

+ type L1FeeVaultWithdrawal struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type L1FeeVaultWithdrawalIterator struct

+ Event *L1FeeVaultWithdrawal

+ func (it *L1FeeVaultWithdrawalIterator) Close() error

+ func (it *L1FeeVaultWithdrawalIterator) Error() error

+ func (it *L1FeeVaultWithdrawalIterator) Next() bool

+ type L1StandardBridge struct

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

+ func NewL1StandardBridge(address common.Address, backend bind.ContractBackend) (*L1StandardBridge, error)

+ type L1StandardBridgeCaller struct

+ func NewL1StandardBridgeCaller(address common.Address, caller bind.ContractCaller) (*L1StandardBridgeCaller, error)

+ func (_L1StandardBridge *L1StandardBridgeCaller) Deposits(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_L1StandardBridge *L1StandardBridgeCaller) MESSENGER(opts *bind.CallOpts) (common.Address, error)

+ func (_L1StandardBridge *L1StandardBridgeCaller) OTHERBRIDGE(opts *bind.CallOpts) (common.Address, error)

+ func (_L1StandardBridge *L1StandardBridgeCaller) Version(opts *bind.CallOpts) (string, error)

+ type L1StandardBridgeCallerRaw struct

+ Contract *L1StandardBridgeCaller

+ func (_L1StandardBridge *L1StandardBridgeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type L1StandardBridgeCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *L1StandardBridgeCaller

+ func (_L1StandardBridge *L1StandardBridgeCallerSession) Deposits(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_L1StandardBridge *L1StandardBridgeCallerSession) MESSENGER() (common.Address, error)

+ func (_L1StandardBridge *L1StandardBridgeCallerSession) OTHERBRIDGE() (common.Address, error)

+ func (_L1StandardBridge *L1StandardBridgeCallerSession) Version() (string, error)

+ type L1StandardBridgeERC20BridgeFinalized struct

+ Amount *big.Int

+ ExtraData []byte

+ From common.Address

+ LocalToken common.Address

+ Raw types.Log

+ RemoteToken common.Address

+ To common.Address

+ type L1StandardBridgeERC20BridgeFinalizedIterator struct

+ Event *L1StandardBridgeERC20BridgeFinalized

+ func (it *L1StandardBridgeERC20BridgeFinalizedIterator) Close() error

+ func (it *L1StandardBridgeERC20BridgeFinalizedIterator) Error() error

+ func (it *L1StandardBridgeERC20BridgeFinalizedIterator) Next() bool

+ type L1StandardBridgeERC20BridgeInitiated struct

+ Amount *big.Int

+ ExtraData []byte

+ From common.Address

+ LocalToken common.Address

+ Raw types.Log

+ RemoteToken common.Address

+ To common.Address

+ type L1StandardBridgeERC20BridgeInitiatedIterator struct

+ Event *L1StandardBridgeERC20BridgeInitiated

+ func (it *L1StandardBridgeERC20BridgeInitiatedIterator) Close() error

+ func (it *L1StandardBridgeERC20BridgeInitiatedIterator) Error() error

+ func (it *L1StandardBridgeERC20BridgeInitiatedIterator) Next() bool

+ type L1StandardBridgeETHBridgeFinalized struct

+ Amount *big.Int

+ ExtraData []byte

+ From common.Address

+ Raw types.Log

+ To common.Address

+ type L1StandardBridgeETHBridgeFinalizedIterator struct

+ Event *L1StandardBridgeETHBridgeFinalized

+ func (it *L1StandardBridgeETHBridgeFinalizedIterator) Close() error

+ func (it *L1StandardBridgeETHBridgeFinalizedIterator) Error() error

+ func (it *L1StandardBridgeETHBridgeFinalizedIterator) Next() bool

+ type L1StandardBridgeETHBridgeInitiated struct

+ Amount *big.Int

+ ExtraData []byte

+ From common.Address

+ Raw types.Log

+ To common.Address

+ type L1StandardBridgeETHBridgeInitiatedIterator struct

+ Event *L1StandardBridgeETHBridgeInitiated

+ func (it *L1StandardBridgeETHBridgeInitiatedIterator) Close() error

+ func (it *L1StandardBridgeETHBridgeInitiatedIterator) Error() error

+ func (it *L1StandardBridgeETHBridgeInitiatedIterator) Next() bool

+ type L1StandardBridgeFilterer struct

+ func NewL1StandardBridgeFilterer(address common.Address, filterer bind.ContractFilterer) (*L1StandardBridgeFilterer, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) FilterERC20BridgeFinalized(opts *bind.FilterOpts, localToken []common.Address, ...) (*L1StandardBridgeERC20BridgeFinalizedIterator, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) FilterERC20BridgeInitiated(opts *bind.FilterOpts, localToken []common.Address, ...) (*L1StandardBridgeERC20BridgeInitiatedIterator, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) FilterETHBridgeFinalized(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*L1StandardBridgeETHBridgeFinalizedIterator, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) FilterETHBridgeInitiated(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*L1StandardBridgeETHBridgeInitiatedIterator, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) ParseERC20BridgeFinalized(log types.Log) (*L1StandardBridgeERC20BridgeFinalized, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) ParseERC20BridgeInitiated(log types.Log) (*L1StandardBridgeERC20BridgeInitiated, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) ParseETHBridgeFinalized(log types.Log) (*L1StandardBridgeETHBridgeFinalized, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) ParseETHBridgeInitiated(log types.Log) (*L1StandardBridgeETHBridgeInitiated, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) WatchERC20BridgeFinalized(opts *bind.WatchOpts, sink chan<- *L1StandardBridgeERC20BridgeFinalized, ...) (event.Subscription, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) WatchERC20BridgeInitiated(opts *bind.WatchOpts, sink chan<- *L1StandardBridgeERC20BridgeInitiated, ...) (event.Subscription, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) WatchETHBridgeFinalized(opts *bind.WatchOpts, sink chan<- *L1StandardBridgeETHBridgeFinalized, ...) (event.Subscription, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) WatchETHBridgeInitiated(opts *bind.WatchOpts, sink chan<- *L1StandardBridgeETHBridgeInitiated, ...) (event.Subscription, error)

+ type L1StandardBridgeRaw struct

+ Contract *L1StandardBridge

+ func (_L1StandardBridge *L1StandardBridgeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_L1StandardBridge *L1StandardBridgeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L1StandardBridgeSession struct

+ CallOpts bind.CallOpts

+ Contract *L1StandardBridge

+ TransactOpts bind.TransactOpts

+ func (_L1StandardBridge *L1StandardBridgeSession) BridgeERC20(_localToken common.Address, _remoteToken common.Address, _amount *big.Int, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) BridgeERC20To(_localToken common.Address, _remoteToken common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) BridgeETH(_minGasLimit uint32, _extraData []byte) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) BridgeETHTo(_to common.Address, _minGasLimit uint32, _extraData []byte) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) Deposits(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) FinalizeBridgeERC20(_localToken common.Address, _remoteToken common.Address, _from common.Address, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) FinalizeBridgeETH(_from common.Address, _to common.Address, _amount *big.Int, _extraData []byte) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) MESSENGER() (common.Address, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) OTHERBRIDGE() (common.Address, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) Receive() (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) Version() (string, error)

+ type L1StandardBridgeTransactor struct

+ func NewL1StandardBridgeTransactor(address common.Address, transactor bind.ContractTransactor) (*L1StandardBridgeTransactor, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactor) BridgeERC20(opts *bind.TransactOpts, _localToken common.Address, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactor) BridgeERC20To(opts *bind.TransactOpts, _localToken common.Address, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactor) BridgeETH(opts *bind.TransactOpts, _minGasLimit uint32, _extraData []byte) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactor) BridgeETHTo(opts *bind.TransactOpts, _to common.Address, _minGasLimit uint32, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactor) FinalizeBridgeERC20(opts *bind.TransactOpts, _localToken common.Address, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactor) FinalizeBridgeETH(opts *bind.TransactOpts, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L1StandardBridgeTransactorRaw struct

+ Contract *L1StandardBridgeTransactor

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

+ func (_L1StandardBridge *L1StandardBridgeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L1StandardBridgeTransactorSession struct

+ Contract *L1StandardBridgeTransactor

+ TransactOpts bind.TransactOpts

+ func (_L1StandardBridge *L1StandardBridgeTransactorSession) BridgeERC20(_localToken common.Address, _remoteToken common.Address, _amount *big.Int, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactorSession) BridgeERC20To(_localToken common.Address, _remoteToken common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactorSession) BridgeETH(_minGasLimit uint32, _extraData []byte) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactorSession) BridgeETHTo(_to common.Address, _minGasLimit uint32, _extraData []byte) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactorSession) FinalizeBridgeERC20(_localToken common.Address, _remoteToken common.Address, _from common.Address, ...) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactorSession) FinalizeBridgeETH(_from common.Address, _to common.Address, _amount *big.Int, _extraData []byte) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeTransactorSession) Receive() (*types.Transaction, error)

+ type L2CrossDomainMessenger struct

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

+ func NewL2CrossDomainMessenger(address common.Address, backend bind.ContractBackend) (*L2CrossDomainMessenger, error)

+ type L2CrossDomainMessengerCaller struct

+ func NewL2CrossDomainMessengerCaller(address common.Address, caller bind.ContractCaller) (*L2CrossDomainMessengerCaller, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) BaseGas(opts *bind.CallOpts, _message []byte, _minGasLimit uint32) (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) FailedMessages(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) MESSAGEVERSION(opts *bind.CallOpts) (uint16, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) MINGASCALLDATAOVERHEAD(opts *bind.CallOpts) (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) MINGASDYNAMICOVERHEADDENOMINATOR(opts *bind.CallOpts) (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) MINGASDYNAMICOVERHEADNUMERATOR(opts *bind.CallOpts) (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) MessageNonce(opts *bind.CallOpts) (*big.Int, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) OTHERMESSENGER(opts *bind.CallOpts) (common.Address, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) Paused(opts *bind.CallOpts) (bool, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) RELAYCALLOVERHEAD(opts *bind.CallOpts) (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) RELAYCONSTANTOVERHEAD(opts *bind.CallOpts) (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) RELAYGASCHECKBUFFER(opts *bind.CallOpts) (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) RELAYRESERVEDGAS(opts *bind.CallOpts) (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) SuccessfulMessages(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) Version(opts *bind.CallOpts) (string, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) XDomainMessageSender(opts *bind.CallOpts) (common.Address, error)

+ type L2CrossDomainMessengerCallerRaw struct

+ Contract *L2CrossDomainMessengerCaller

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type L2CrossDomainMessengerCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *L2CrossDomainMessengerCaller

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) BaseGas(_message []byte, _minGasLimit uint32) (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) FailedMessages(arg0 [32]byte) (bool, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) MESSAGEVERSION() (uint16, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) MINGASCALLDATAOVERHEAD() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) MINGASDYNAMICOVERHEADDENOMINATOR() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) MINGASDYNAMICOVERHEADNUMERATOR() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) MessageNonce() (*big.Int, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) OTHERMESSENGER() (common.Address, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) Paused() (bool, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) RELAYCALLOVERHEAD() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) RELAYCONSTANTOVERHEAD() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) RELAYGASCHECKBUFFER() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) RELAYRESERVEDGAS() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) SuccessfulMessages(arg0 [32]byte) (bool, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) Version() (string, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) XDomainMessageSender() (common.Address, error)

+ type L2CrossDomainMessengerFailedRelayedMessage struct

+ MsgHash [32]byte

+ Raw types.Log

+ type L2CrossDomainMessengerFailedRelayedMessageIterator struct

+ Event *L2CrossDomainMessengerFailedRelayedMessage

+ func (it *L2CrossDomainMessengerFailedRelayedMessageIterator) Close() error

+ func (it *L2CrossDomainMessengerFailedRelayedMessageIterator) Error() error

+ func (it *L2CrossDomainMessengerFailedRelayedMessageIterator) Next() bool

+ type L2CrossDomainMessengerFilterer struct

+ func NewL2CrossDomainMessengerFilterer(address common.Address, filterer bind.ContractFilterer) (*L2CrossDomainMessengerFilterer, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) FilterFailedRelayedMessage(opts *bind.FilterOpts, msgHash [][32]byte) (*L2CrossDomainMessengerFailedRelayedMessageIterator, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) FilterInitialized(opts *bind.FilterOpts) (*L2CrossDomainMessengerInitializedIterator, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) FilterPaused(opts *bind.FilterOpts) (*L2CrossDomainMessengerPausedIterator, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) FilterRelayedMessage(opts *bind.FilterOpts, msgHash [][32]byte) (*L2CrossDomainMessengerRelayedMessageIterator, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) FilterSentMessage(opts *bind.FilterOpts, target []common.Address, sender []common.Address) (*L2CrossDomainMessengerSentMessageIterator, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) FilterUnpaused(opts *bind.FilterOpts) (*L2CrossDomainMessengerUnpausedIterator, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) ParseFailedRelayedMessage(log types.Log) (*L2CrossDomainMessengerFailedRelayedMessage, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) ParseInitialized(log types.Log) (*L2CrossDomainMessengerInitialized, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) ParsePaused(log types.Log) (*L2CrossDomainMessengerPaused, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) ParseRelayedMessage(log types.Log) (*L2CrossDomainMessengerRelayedMessage, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) ParseSentMessage(log types.Log) (*L2CrossDomainMessengerSentMessage, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) ParseUnpaused(log types.Log) (*L2CrossDomainMessengerUnpaused, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) WatchFailedRelayedMessage(opts *bind.WatchOpts, sink chan<- *L2CrossDomainMessengerFailedRelayedMessage, ...) (event.Subscription, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *L2CrossDomainMessengerInitialized) (event.Subscription, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *L2CrossDomainMessengerPaused) (event.Subscription, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) WatchRelayedMessage(opts *bind.WatchOpts, sink chan<- *L2CrossDomainMessengerRelayedMessage, ...) (event.Subscription, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) WatchSentMessage(opts *bind.WatchOpts, sink chan<- *L2CrossDomainMessengerSentMessage, ...) (event.Subscription, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *L2CrossDomainMessengerUnpaused) (event.Subscription, error)

+ type L2CrossDomainMessengerInitialized struct

+ Raw types.Log

+ Version uint8

+ type L2CrossDomainMessengerInitializedIterator struct

+ Event *L2CrossDomainMessengerInitialized

+ func (it *L2CrossDomainMessengerInitializedIterator) Close() error

+ func (it *L2CrossDomainMessengerInitializedIterator) Error() error

+ func (it *L2CrossDomainMessengerInitializedIterator) Next() bool

+ type L2CrossDomainMessengerPaused struct

+ Account common.Address

+ Raw types.Log

+ type L2CrossDomainMessengerPausedIterator struct

+ Event *L2CrossDomainMessengerPaused

+ func (it *L2CrossDomainMessengerPausedIterator) Close() error

+ func (it *L2CrossDomainMessengerPausedIterator) Error() error

+ func (it *L2CrossDomainMessengerPausedIterator) Next() bool

+ type L2CrossDomainMessengerRaw struct

+ Contract *L2CrossDomainMessenger

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L2CrossDomainMessengerRelayedMessage struct

+ MsgHash [32]byte

+ Raw types.Log

+ type L2CrossDomainMessengerRelayedMessageIterator struct

+ Event *L2CrossDomainMessengerRelayedMessage

+ func (it *L2CrossDomainMessengerRelayedMessageIterator) Close() error

+ func (it *L2CrossDomainMessengerRelayedMessageIterator) Error() error

+ func (it *L2CrossDomainMessengerRelayedMessageIterator) Next() bool

+ type L2CrossDomainMessengerSentMessage struct

+ GasLimit *big.Int

+ Message []byte

+ MessageNonce *big.Int

+ Raw types.Log

+ Sender common.Address

+ Target common.Address

+ Value *big.Int

+ type L2CrossDomainMessengerSentMessageIterator struct

+ Event *L2CrossDomainMessengerSentMessage

+ func (it *L2CrossDomainMessengerSentMessageIterator) Close() error

+ func (it *L2CrossDomainMessengerSentMessageIterator) Error() error

+ func (it *L2CrossDomainMessengerSentMessageIterator) Next() bool

+ type L2CrossDomainMessengerSession struct

+ CallOpts bind.CallOpts

+ Contract *L2CrossDomainMessenger

+ TransactOpts bind.TransactOpts

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) BaseGas(_message []byte, _minGasLimit uint32) (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) FailedMessages(arg0 [32]byte) (bool, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) Initialize() (*types.Transaction, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) MESSAGEVERSION() (uint16, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) MINGASCALLDATAOVERHEAD() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) MINGASDYNAMICOVERHEADDENOMINATOR() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) MINGASDYNAMICOVERHEADNUMERATOR() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) MessageNonce() (*big.Int, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) OTHERMESSENGER() (common.Address, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) Paused() (bool, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) RELAYCALLOVERHEAD() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) RELAYCONSTANTOVERHEAD() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) RELAYGASCHECKBUFFER() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) RELAYRESERVEDGAS() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) RelayMessage(_nonce *big.Int, _sender common.Address, _target common.Address, ...) (*types.Transaction, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) SendMessage(_target common.Address, _message []byte, _minGasLimit uint32) (*types.Transaction, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) SuccessfulMessages(arg0 [32]byte) (bool, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) Version() (string, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) XDomainMessageSender() (common.Address, error)

+ type L2CrossDomainMessengerTransactor struct

+ func NewL2CrossDomainMessengerTransactor(address common.Address, transactor bind.ContractTransactor) (*L2CrossDomainMessengerTransactor, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerTransactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerTransactor) RelayMessage(opts *bind.TransactOpts, _nonce *big.Int, _sender common.Address, ...) (*types.Transaction, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerTransactor) SendMessage(opts *bind.TransactOpts, _target common.Address, _message []byte, ...) (*types.Transaction, error)

+ type L2CrossDomainMessengerTransactorRaw struct

+ Contract *L2CrossDomainMessengerTransactor

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

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L2CrossDomainMessengerTransactorSession struct

+ Contract *L2CrossDomainMessengerTransactor

+ TransactOpts bind.TransactOpts

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerTransactorSession) Initialize() (*types.Transaction, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerTransactorSession) RelayMessage(_nonce *big.Int, _sender common.Address, _target common.Address, ...) (*types.Transaction, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerTransactorSession) SendMessage(_target common.Address, _message []byte, _minGasLimit uint32) (*types.Transaction, error)

+ type L2CrossDomainMessengerUnpaused struct

+ Account common.Address

+ Raw types.Log

+ type L2CrossDomainMessengerUnpausedIterator struct

+ Event *L2CrossDomainMessengerUnpaused

+ func (it *L2CrossDomainMessengerUnpausedIterator) Close() error

+ func (it *L2CrossDomainMessengerUnpausedIterator) Error() error

+ func (it *L2CrossDomainMessengerUnpausedIterator) Next() bool

+ type L2ERC721Bridge struct

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

+ func NewL2ERC721Bridge(address common.Address, backend bind.ContractBackend) (*L2ERC721Bridge, error)

+ type L2ERC721BridgeCaller struct

+ func NewL2ERC721BridgeCaller(address common.Address, caller bind.ContractCaller) (*L2ERC721BridgeCaller, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeCaller) MESSENGER(opts *bind.CallOpts) (common.Address, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeCaller) OTHERBRIDGE(opts *bind.CallOpts) (common.Address, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeCaller) Version(opts *bind.CallOpts) (string, error)

+ type L2ERC721BridgeCallerRaw struct

+ Contract *L2ERC721BridgeCaller

+ func (_L2ERC721Bridge *L2ERC721BridgeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type L2ERC721BridgeCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *L2ERC721BridgeCaller

+ func (_L2ERC721Bridge *L2ERC721BridgeCallerSession) MESSENGER() (common.Address, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeCallerSession) OTHERBRIDGE() (common.Address, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeCallerSession) Version() (string, error)

+ type L2ERC721BridgeERC721BridgeFinalized struct

+ ExtraData []byte

+ From common.Address

+ LocalToken common.Address

+ Raw types.Log

+ RemoteToken common.Address

+ To common.Address

+ TokenId *big.Int

+ type L2ERC721BridgeERC721BridgeFinalizedIterator struct

+ Event *L2ERC721BridgeERC721BridgeFinalized

+ func (it *L2ERC721BridgeERC721BridgeFinalizedIterator) Close() error

+ func (it *L2ERC721BridgeERC721BridgeFinalizedIterator) Error() error

+ func (it *L2ERC721BridgeERC721BridgeFinalizedIterator) Next() bool

+ type L2ERC721BridgeERC721BridgeInitiated struct

+ ExtraData []byte

+ From common.Address

+ LocalToken common.Address

+ Raw types.Log

+ RemoteToken common.Address

+ To common.Address

+ TokenId *big.Int

+ type L2ERC721BridgeERC721BridgeInitiatedIterator struct

+ Event *L2ERC721BridgeERC721BridgeInitiated

+ func (it *L2ERC721BridgeERC721BridgeInitiatedIterator) Close() error

+ func (it *L2ERC721BridgeERC721BridgeInitiatedIterator) Error() error

+ func (it *L2ERC721BridgeERC721BridgeInitiatedIterator) Next() bool

+ type L2ERC721BridgeFilterer struct

+ func NewL2ERC721BridgeFilterer(address common.Address, filterer bind.ContractFilterer) (*L2ERC721BridgeFilterer, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeFilterer) FilterERC721BridgeFinalized(opts *bind.FilterOpts, localToken []common.Address, ...) (*L2ERC721BridgeERC721BridgeFinalizedIterator, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeFilterer) FilterERC721BridgeInitiated(opts *bind.FilterOpts, localToken []common.Address, ...) (*L2ERC721BridgeERC721BridgeInitiatedIterator, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeFilterer) ParseERC721BridgeFinalized(log types.Log) (*L2ERC721BridgeERC721BridgeFinalized, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeFilterer) ParseERC721BridgeInitiated(log types.Log) (*L2ERC721BridgeERC721BridgeInitiated, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeFilterer) WatchERC721BridgeFinalized(opts *bind.WatchOpts, sink chan<- *L2ERC721BridgeERC721BridgeFinalized, ...) (event.Subscription, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeFilterer) WatchERC721BridgeInitiated(opts *bind.WatchOpts, sink chan<- *L2ERC721BridgeERC721BridgeInitiated, ...) (event.Subscription, error)

+ type L2ERC721BridgeRaw struct

+ Contract *L2ERC721Bridge

+ func (_L2ERC721Bridge *L2ERC721BridgeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_L2ERC721Bridge *L2ERC721BridgeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L2ERC721BridgeSession struct

+ CallOpts bind.CallOpts

+ Contract *L2ERC721Bridge

+ TransactOpts bind.TransactOpts

+ func (_L2ERC721Bridge *L2ERC721BridgeSession) BridgeERC721(_localToken common.Address, _remoteToken common.Address, _tokenId *big.Int, ...) (*types.Transaction, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeSession) BridgeERC721To(_localToken common.Address, _remoteToken common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeSession) FinalizeBridgeERC721(_localToken common.Address, _remoteToken common.Address, _from common.Address, ...) (*types.Transaction, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeSession) MESSENGER() (common.Address, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeSession) OTHERBRIDGE() (common.Address, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeSession) Version() (string, error)

+ type L2ERC721BridgeTransactor struct

+ func NewL2ERC721BridgeTransactor(address common.Address, transactor bind.ContractTransactor) (*L2ERC721BridgeTransactor, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeTransactor) BridgeERC721(opts *bind.TransactOpts, _localToken common.Address, ...) (*types.Transaction, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeTransactor) BridgeERC721To(opts *bind.TransactOpts, _localToken common.Address, ...) (*types.Transaction, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeTransactor) FinalizeBridgeERC721(opts *bind.TransactOpts, _localToken common.Address, ...) (*types.Transaction, error)

+ type L2ERC721BridgeTransactorRaw struct

+ Contract *L2ERC721BridgeTransactor

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

+ func (_L2ERC721Bridge *L2ERC721BridgeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L2ERC721BridgeTransactorSession struct

+ Contract *L2ERC721BridgeTransactor

+ TransactOpts bind.TransactOpts

+ func (_L2ERC721Bridge *L2ERC721BridgeTransactorSession) BridgeERC721(_localToken common.Address, _remoteToken common.Address, _tokenId *big.Int, ...) (*types.Transaction, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeTransactorSession) BridgeERC721To(_localToken common.Address, _remoteToken common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeTransactorSession) FinalizeBridgeERC721(_localToken common.Address, _remoteToken common.Address, _from common.Address, ...) (*types.Transaction, error)

+ type L2OutputOracle struct

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

+ func NewL2OutputOracle(address common.Address, backend bind.ContractBackend) (*L2OutputOracle, error)

+ type L2OutputOracleCaller struct

+ func NewL2OutputOracleCaller(address common.Address, caller bind.ContractCaller) (*L2OutputOracleCaller, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) COLOSSEUM(opts *bind.CallOpts) (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) ComputeL2Timestamp(opts *bind.CallOpts, _l2BlockNumber *big.Int) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) FINALIZATIONPERIODSECONDS(opts *bind.CallOpts) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) FinalizedAt(opts *bind.CallOpts, _outputIndex *big.Int) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) GetL2Output(opts *bind.CallOpts, _l2OutputIndex *big.Int) (TypesCheckpointOutput, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) GetL2OutputAfter(opts *bind.CallOpts, _l2BlockNumber *big.Int) (TypesCheckpointOutput, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) GetL2OutputIndexAfter(opts *bind.CallOpts, _l2BlockNumber *big.Int) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) GetSubmitter(opts *bind.CallOpts, _outputIndex *big.Int) (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) IsFinalized(opts *bind.CallOpts, _outputIndex *big.Int) (bool, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) L2BLOCKTIME(opts *bind.CallOpts) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) LatestBlockNumber(opts *bind.CallOpts) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) LatestOutputIndex(opts *bind.CallOpts) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) NextBlockNumber(opts *bind.CallOpts) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) NextOutputIndex(opts *bind.CallOpts) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) SUBMISSIONINTERVAL(opts *bind.CallOpts) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) StartingBlockNumber(opts *bind.CallOpts) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) StartingTimestamp(opts *bind.CallOpts) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) VALIDATORPOOL(opts *bind.CallOpts) (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) Version(opts *bind.CallOpts) (string, error)

+ type L2OutputOracleCallerRaw struct

+ Contract *L2OutputOracleCaller

+ func (_L2OutputOracle *L2OutputOracleCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type L2OutputOracleCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *L2OutputOracleCaller

+ func (_L2OutputOracle *L2OutputOracleCallerSession) COLOSSEUM() (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) ComputeL2Timestamp(_l2BlockNumber *big.Int) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) FINALIZATIONPERIODSECONDS() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) FinalizedAt(_outputIndex *big.Int) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) GetL2Output(_l2OutputIndex *big.Int) (TypesCheckpointOutput, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) GetL2OutputAfter(_l2BlockNumber *big.Int) (TypesCheckpointOutput, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) GetL2OutputIndexAfter(_l2BlockNumber *big.Int) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) GetSubmitter(_outputIndex *big.Int) (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) IsFinalized(_outputIndex *big.Int) (bool, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) L2BLOCKTIME() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) LatestBlockNumber() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) LatestOutputIndex() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) NextBlockNumber() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) NextOutputIndex() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) SUBMISSIONINTERVAL() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) StartingBlockNumber() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) StartingTimestamp() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) VALIDATORPOOL() (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) Version() (string, error)

+ type L2OutputOracleFilterer struct

+ func NewL2OutputOracleFilterer(address common.Address, filterer bind.ContractFilterer) (*L2OutputOracleFilterer, error)

+ func (_L2OutputOracle *L2OutputOracleFilterer) FilterInitialized(opts *bind.FilterOpts) (*L2OutputOracleInitializedIterator, error)

+ func (_L2OutputOracle *L2OutputOracleFilterer) FilterOutputReplaced(opts *bind.FilterOpts, outputIndex []*big.Int) (*L2OutputOracleOutputReplacedIterator, error)

+ func (_L2OutputOracle *L2OutputOracleFilterer) FilterOutputSubmitted(opts *bind.FilterOpts, outputRoot [][32]byte, l2OutputIndex []*big.Int, ...) (*L2OutputOracleOutputSubmittedIterator, error)

+ func (_L2OutputOracle *L2OutputOracleFilterer) ParseInitialized(log types.Log) (*L2OutputOracleInitialized, error)

+ func (_L2OutputOracle *L2OutputOracleFilterer) ParseOutputReplaced(log types.Log) (*L2OutputOracleOutputReplaced, error)

+ func (_L2OutputOracle *L2OutputOracleFilterer) ParseOutputSubmitted(log types.Log) (*L2OutputOracleOutputSubmitted, error)

+ func (_L2OutputOracle *L2OutputOracleFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *L2OutputOracleInitialized) (event.Subscription, error)

+ func (_L2OutputOracle *L2OutputOracleFilterer) WatchOutputReplaced(opts *bind.WatchOpts, sink chan<- *L2OutputOracleOutputReplaced, ...) (event.Subscription, error)

+ func (_L2OutputOracle *L2OutputOracleFilterer) WatchOutputSubmitted(opts *bind.WatchOpts, sink chan<- *L2OutputOracleOutputSubmitted, ...) (event.Subscription, error)

+ type L2OutputOracleInitialized struct

+ Raw types.Log

+ Version uint8

+ type L2OutputOracleInitializedIterator struct

+ Event *L2OutputOracleInitialized

+ func (it *L2OutputOracleInitializedIterator) Close() error

+ func (it *L2OutputOracleInitializedIterator) Error() error

+ func (it *L2OutputOracleInitializedIterator) Next() bool

+ type L2OutputOracleOutputReplaced struct

+ NewOutputRoot [32]byte

+ OutputIndex *big.Int

+ Raw types.Log

+ type L2OutputOracleOutputReplacedIterator struct

+ Event *L2OutputOracleOutputReplaced

+ func (it *L2OutputOracleOutputReplacedIterator) Close() error

+ func (it *L2OutputOracleOutputReplacedIterator) Error() error

+ func (it *L2OutputOracleOutputReplacedIterator) Next() bool

+ type L2OutputOracleOutputSubmitted struct

+ L1Timestamp *big.Int

+ L2BlockNumber *big.Int

+ L2OutputIndex *big.Int

+ OutputRoot [32]byte

+ Raw types.Log

+ type L2OutputOracleOutputSubmittedIterator struct

+ Event *L2OutputOracleOutputSubmitted

+ func (it *L2OutputOracleOutputSubmittedIterator) Close() error

+ func (it *L2OutputOracleOutputSubmittedIterator) Error() error

+ func (it *L2OutputOracleOutputSubmittedIterator) Next() bool

+ type L2OutputOracleRaw struct

+ Contract *L2OutputOracle

+ func (_L2OutputOracle *L2OutputOracleRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_L2OutputOracle *L2OutputOracleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L2OutputOracleSession struct

+ CallOpts bind.CallOpts

+ Contract *L2OutputOracle

+ TransactOpts bind.TransactOpts

+ func (_L2OutputOracle *L2OutputOracleSession) COLOSSEUM() (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleSession) ComputeL2Timestamp(_l2BlockNumber *big.Int) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleSession) FINALIZATIONPERIODSECONDS() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleSession) FinalizedAt(_outputIndex *big.Int) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleSession) GetL2Output(_l2OutputIndex *big.Int) (TypesCheckpointOutput, error)

+ func (_L2OutputOracle *L2OutputOracleSession) GetL2OutputAfter(_l2BlockNumber *big.Int) (TypesCheckpointOutput, error)

+ func (_L2OutputOracle *L2OutputOracleSession) GetL2OutputIndexAfter(_l2BlockNumber *big.Int) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleSession) GetSubmitter(_outputIndex *big.Int) (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleSession) Initialize(_startingBlockNumber *big.Int, _startingTimestamp *big.Int) (*types.Transaction, error)

+ func (_L2OutputOracle *L2OutputOracleSession) IsFinalized(_outputIndex *big.Int) (bool, error)

+ func (_L2OutputOracle *L2OutputOracleSession) L2BLOCKTIME() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleSession) LatestBlockNumber() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleSession) LatestOutputIndex() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleSession) NextBlockNumber() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleSession) NextOutputIndex() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleSession) ReplaceL2Output(_l2OutputIndex *big.Int, _newOutputRoot [32]byte, _submitter common.Address) (*types.Transaction, error)

+ func (_L2OutputOracle *L2OutputOracleSession) SUBMISSIONINTERVAL() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleSession) StartingBlockNumber() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleSession) StartingTimestamp() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleSession) SubmitL2Output(_outputRoot [32]byte, _l2BlockNumber *big.Int, _l1BlockHash [32]byte, ...) (*types.Transaction, error)

+ func (_L2OutputOracle *L2OutputOracleSession) VALIDATORPOOL() (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleSession) Version() (string, error)

+ type L2OutputOracleTransactor struct

+ func NewL2OutputOracleTransactor(address common.Address, transactor bind.ContractTransactor) (*L2OutputOracleTransactor, error)

+ func (_L2OutputOracle *L2OutputOracleTransactor) Initialize(opts *bind.TransactOpts, _startingBlockNumber *big.Int, ...) (*types.Transaction, error)

+ func (_L2OutputOracle *L2OutputOracleTransactor) ReplaceL2Output(opts *bind.TransactOpts, _l2OutputIndex *big.Int, _newOutputRoot [32]byte, ...) (*types.Transaction, error)

+ func (_L2OutputOracle *L2OutputOracleTransactor) SubmitL2Output(opts *bind.TransactOpts, _outputRoot [32]byte, _l2BlockNumber *big.Int, ...) (*types.Transaction, error)

+ type L2OutputOracleTransactorRaw struct

+ Contract *L2OutputOracleTransactor

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

+ func (_L2OutputOracle *L2OutputOracleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L2OutputOracleTransactorSession struct

+ Contract *L2OutputOracleTransactor

+ TransactOpts bind.TransactOpts

+ func (_L2OutputOracle *L2OutputOracleTransactorSession) Initialize(_startingBlockNumber *big.Int, _startingTimestamp *big.Int) (*types.Transaction, error)

+ func (_L2OutputOracle *L2OutputOracleTransactorSession) ReplaceL2Output(_l2OutputIndex *big.Int, _newOutputRoot [32]byte, _submitter common.Address) (*types.Transaction, error)

+ func (_L2OutputOracle *L2OutputOracleTransactorSession) SubmitL2Output(_outputRoot [32]byte, _l2BlockNumber *big.Int, _l1BlockHash [32]byte, ...) (*types.Transaction, error)

+ type L2StandardBridge struct

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

+ func NewL2StandardBridge(address common.Address, backend bind.ContractBackend) (*L2StandardBridge, error)

+ type L2StandardBridgeCaller struct

+ func NewL2StandardBridgeCaller(address common.Address, caller bind.ContractCaller) (*L2StandardBridgeCaller, error)

+ func (_L2StandardBridge *L2StandardBridgeCaller) Deposits(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_L2StandardBridge *L2StandardBridgeCaller) MESSENGER(opts *bind.CallOpts) (common.Address, error)

+ func (_L2StandardBridge *L2StandardBridgeCaller) OTHERBRIDGE(opts *bind.CallOpts) (common.Address, error)

+ func (_L2StandardBridge *L2StandardBridgeCaller) Version(opts *bind.CallOpts) (string, error)

+ type L2StandardBridgeCallerRaw struct

+ Contract *L2StandardBridgeCaller

+ func (_L2StandardBridge *L2StandardBridgeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type L2StandardBridgeCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *L2StandardBridgeCaller

+ func (_L2StandardBridge *L2StandardBridgeCallerSession) Deposits(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_L2StandardBridge *L2StandardBridgeCallerSession) MESSENGER() (common.Address, error)

+ func (_L2StandardBridge *L2StandardBridgeCallerSession) OTHERBRIDGE() (common.Address, error)

+ func (_L2StandardBridge *L2StandardBridgeCallerSession) Version() (string, error)

+ type L2StandardBridgeERC20BridgeFinalized struct

+ Amount *big.Int

+ ExtraData []byte

+ From common.Address

+ LocalToken common.Address

+ Raw types.Log

+ RemoteToken common.Address

+ To common.Address

+ type L2StandardBridgeERC20BridgeFinalizedIterator struct

+ Event *L2StandardBridgeERC20BridgeFinalized

+ func (it *L2StandardBridgeERC20BridgeFinalizedIterator) Close() error

+ func (it *L2StandardBridgeERC20BridgeFinalizedIterator) Error() error

+ func (it *L2StandardBridgeERC20BridgeFinalizedIterator) Next() bool

+ type L2StandardBridgeERC20BridgeInitiated struct

+ Amount *big.Int

+ ExtraData []byte

+ From common.Address

+ LocalToken common.Address

+ Raw types.Log

+ RemoteToken common.Address

+ To common.Address

+ type L2StandardBridgeERC20BridgeInitiatedIterator struct

+ Event *L2StandardBridgeERC20BridgeInitiated

+ func (it *L2StandardBridgeERC20BridgeInitiatedIterator) Close() error

+ func (it *L2StandardBridgeERC20BridgeInitiatedIterator) Error() error

+ func (it *L2StandardBridgeERC20BridgeInitiatedIterator) Next() bool

+ type L2StandardBridgeETHBridgeFinalized struct

+ Amount *big.Int

+ ExtraData []byte

+ From common.Address

+ Raw types.Log

+ To common.Address

+ type L2StandardBridgeETHBridgeFinalizedIterator struct

+ Event *L2StandardBridgeETHBridgeFinalized

+ func (it *L2StandardBridgeETHBridgeFinalizedIterator) Close() error

+ func (it *L2StandardBridgeETHBridgeFinalizedIterator) Error() error

+ func (it *L2StandardBridgeETHBridgeFinalizedIterator) Next() bool

+ type L2StandardBridgeETHBridgeInitiated struct

+ Amount *big.Int

+ ExtraData []byte

+ From common.Address

+ Raw types.Log

+ To common.Address

+ type L2StandardBridgeETHBridgeInitiatedIterator struct

+ Event *L2StandardBridgeETHBridgeInitiated

+ func (it *L2StandardBridgeETHBridgeInitiatedIterator) Close() error

+ func (it *L2StandardBridgeETHBridgeInitiatedIterator) Error() error

+ func (it *L2StandardBridgeETHBridgeInitiatedIterator) Next() bool

+ type L2StandardBridgeFilterer struct

+ func NewL2StandardBridgeFilterer(address common.Address, filterer bind.ContractFilterer) (*L2StandardBridgeFilterer, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) FilterERC20BridgeFinalized(opts *bind.FilterOpts, localToken []common.Address, ...) (*L2StandardBridgeERC20BridgeFinalizedIterator, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) FilterERC20BridgeInitiated(opts *bind.FilterOpts, localToken []common.Address, ...) (*L2StandardBridgeERC20BridgeInitiatedIterator, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) FilterETHBridgeFinalized(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*L2StandardBridgeETHBridgeFinalizedIterator, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) FilterETHBridgeInitiated(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*L2StandardBridgeETHBridgeInitiatedIterator, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) ParseERC20BridgeFinalized(log types.Log) (*L2StandardBridgeERC20BridgeFinalized, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) ParseERC20BridgeInitiated(log types.Log) (*L2StandardBridgeERC20BridgeInitiated, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) ParseETHBridgeFinalized(log types.Log) (*L2StandardBridgeETHBridgeFinalized, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) ParseETHBridgeInitiated(log types.Log) (*L2StandardBridgeETHBridgeInitiated, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) WatchERC20BridgeFinalized(opts *bind.WatchOpts, sink chan<- *L2StandardBridgeERC20BridgeFinalized, ...) (event.Subscription, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) WatchERC20BridgeInitiated(opts *bind.WatchOpts, sink chan<- *L2StandardBridgeERC20BridgeInitiated, ...) (event.Subscription, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) WatchETHBridgeFinalized(opts *bind.WatchOpts, sink chan<- *L2StandardBridgeETHBridgeFinalized, ...) (event.Subscription, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) WatchETHBridgeInitiated(opts *bind.WatchOpts, sink chan<- *L2StandardBridgeETHBridgeInitiated, ...) (event.Subscription, error)

+ type L2StandardBridgeRaw struct

+ Contract *L2StandardBridge

+ func (_L2StandardBridge *L2StandardBridgeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_L2StandardBridge *L2StandardBridgeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L2StandardBridgeSession struct

+ CallOpts bind.CallOpts

+ Contract *L2StandardBridge

+ TransactOpts bind.TransactOpts

+ func (_L2StandardBridge *L2StandardBridgeSession) BridgeERC20(_localToken common.Address, _remoteToken common.Address, _amount *big.Int, ...) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeSession) BridgeERC20To(_localToken common.Address, _remoteToken common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeSession) BridgeETH(_minGasLimit uint32, _extraData []byte) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeSession) BridgeETHTo(_to common.Address, _minGasLimit uint32, _extraData []byte) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeSession) Deposits(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_L2StandardBridge *L2StandardBridgeSession) FinalizeBridgeERC20(_localToken common.Address, _remoteToken common.Address, _from common.Address, ...) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeSession) FinalizeBridgeETH(_from common.Address, _to common.Address, _amount *big.Int, _extraData []byte) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeSession) MESSENGER() (common.Address, error)

+ func (_L2StandardBridge *L2StandardBridgeSession) OTHERBRIDGE() (common.Address, error)

+ func (_L2StandardBridge *L2StandardBridgeSession) Receive() (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeSession) Version() (string, error)

+ type L2StandardBridgeTransactor struct

+ func NewL2StandardBridgeTransactor(address common.Address, transactor bind.ContractTransactor) (*L2StandardBridgeTransactor, error)

+ func (_L2StandardBridge *L2StandardBridgeTransactor) BridgeERC20(opts *bind.TransactOpts, _localToken common.Address, ...) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeTransactor) BridgeERC20To(opts *bind.TransactOpts, _localToken common.Address, ...) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeTransactor) BridgeETH(opts *bind.TransactOpts, _minGasLimit uint32, _extraData []byte) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeTransactor) BridgeETHTo(opts *bind.TransactOpts, _to common.Address, _minGasLimit uint32, ...) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeTransactor) FinalizeBridgeERC20(opts *bind.TransactOpts, _localToken common.Address, ...) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeTransactor) FinalizeBridgeETH(opts *bind.TransactOpts, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L2StandardBridgeTransactorRaw struct

+ Contract *L2StandardBridgeTransactor

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

+ func (_L2StandardBridge *L2StandardBridgeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L2StandardBridgeTransactorSession struct

+ Contract *L2StandardBridgeTransactor

+ TransactOpts bind.TransactOpts

+ func (_L2StandardBridge *L2StandardBridgeTransactorSession) BridgeERC20(_localToken common.Address, _remoteToken common.Address, _amount *big.Int, ...) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeTransactorSession) BridgeERC20To(_localToken common.Address, _remoteToken common.Address, _to common.Address, ...) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeTransactorSession) BridgeETH(_minGasLimit uint32, _extraData []byte) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeTransactorSession) BridgeETHTo(_to common.Address, _minGasLimit uint32, _extraData []byte) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeTransactorSession) FinalizeBridgeERC20(_localToken common.Address, _remoteToken common.Address, _from common.Address, ...) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeTransactorSession) FinalizeBridgeETH(_from common.Address, _to common.Address, _amount *big.Int, _extraData []byte) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeTransactorSession) Receive() (*types.Transaction, error)

+ type L2ToL1MessagePasser struct

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

+ func NewL2ToL1MessagePasser(address common.Address, backend bind.ContractBackend) (*L2ToL1MessagePasser, error)

+ type L2ToL1MessagePasserCaller struct

+ func NewL2ToL1MessagePasserCaller(address common.Address, caller bind.ContractCaller) (*L2ToL1MessagePasserCaller, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserCaller) MESSAGEVERSION(opts *bind.CallOpts) (uint16, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserCaller) MessageNonce(opts *bind.CallOpts) (*big.Int, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserCaller) SentMessages(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserCaller) Version(opts *bind.CallOpts) (string, error)

+ type L2ToL1MessagePasserCallerRaw struct

+ Contract *L2ToL1MessagePasserCaller

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type L2ToL1MessagePasserCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *L2ToL1MessagePasserCaller

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserCallerSession) MESSAGEVERSION() (uint16, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserCallerSession) MessageNonce() (*big.Int, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserCallerSession) SentMessages(arg0 [32]byte) (bool, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserCallerSession) Version() (string, error)

+ type L2ToL1MessagePasserFilterer struct

+ func NewL2ToL1MessagePasserFilterer(address common.Address, filterer bind.ContractFilterer) (*L2ToL1MessagePasserFilterer, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserFilterer) FilterMessagePassed(opts *bind.FilterOpts, nonce []*big.Int, sender []common.Address, ...) (*L2ToL1MessagePasserMessagePassedIterator, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserFilterer) FilterWithdrawerBalanceBurnt(opts *bind.FilterOpts, amount []*big.Int) (*L2ToL1MessagePasserWithdrawerBalanceBurntIterator, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserFilterer) ParseMessagePassed(log types.Log) (*L2ToL1MessagePasserMessagePassed, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserFilterer) ParseWithdrawerBalanceBurnt(log types.Log) (*L2ToL1MessagePasserWithdrawerBalanceBurnt, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserFilterer) WatchMessagePassed(opts *bind.WatchOpts, sink chan<- *L2ToL1MessagePasserMessagePassed, ...) (event.Subscription, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserFilterer) WatchWithdrawerBalanceBurnt(opts *bind.WatchOpts, sink chan<- *L2ToL1MessagePasserWithdrawerBalanceBurnt, ...) (event.Subscription, error)

+ type L2ToL1MessagePasserMessagePassed struct

+ Data []byte

+ GasLimit *big.Int

+ Nonce *big.Int

+ Raw types.Log

+ Sender common.Address

+ Target common.Address

+ Value *big.Int

+ WithdrawalHash [32]byte

+ type L2ToL1MessagePasserMessagePassedIterator struct

+ Event *L2ToL1MessagePasserMessagePassed

+ func (it *L2ToL1MessagePasserMessagePassedIterator) Close() error

+ func (it *L2ToL1MessagePasserMessagePassedIterator) Error() error

+ func (it *L2ToL1MessagePasserMessagePassedIterator) Next() bool

+ type L2ToL1MessagePasserRaw struct

+ Contract *L2ToL1MessagePasser

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L2ToL1MessagePasserSession struct

+ CallOpts bind.CallOpts

+ Contract *L2ToL1MessagePasser

+ TransactOpts bind.TransactOpts

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserSession) Burn() (*types.Transaction, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserSession) InitiateWithdrawal(_target common.Address, _gasLimit *big.Int, _data []byte) (*types.Transaction, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserSession) MESSAGEVERSION() (uint16, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserSession) MessageNonce() (*big.Int, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserSession) Receive() (*types.Transaction, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserSession) SentMessages(arg0 [32]byte) (bool, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserSession) Version() (string, error)

+ type L2ToL1MessagePasserTransactor struct

+ func NewL2ToL1MessagePasserTransactor(address common.Address, transactor bind.ContractTransactor) (*L2ToL1MessagePasserTransactor, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserTransactor) Burn(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserTransactor) InitiateWithdrawal(opts *bind.TransactOpts, _target common.Address, _gasLimit *big.Int, ...) (*types.Transaction, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L2ToL1MessagePasserTransactorRaw struct

+ Contract *L2ToL1MessagePasserTransactor

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

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type L2ToL1MessagePasserTransactorSession struct

+ Contract *L2ToL1MessagePasserTransactor

+ TransactOpts bind.TransactOpts

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserTransactorSession) Burn() (*types.Transaction, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserTransactorSession) InitiateWithdrawal(_target common.Address, _gasLimit *big.Int, _data []byte) (*types.Transaction, error)

+ func (_L2ToL1MessagePasser *L2ToL1MessagePasserTransactorSession) Receive() (*types.Transaction, error)

+ type L2ToL1MessagePasserWithdrawerBalanceBurnt struct

+ Amount *big.Int

+ Raw types.Log

+ type L2ToL1MessagePasserWithdrawerBalanceBurntIterator struct

+ Event *L2ToL1MessagePasserWithdrawerBalanceBurnt

+ func (it *L2ToL1MessagePasserWithdrawerBalanceBurntIterator) Close() error

+ func (it *L2ToL1MessagePasserWithdrawerBalanceBurntIterator) Error() error

+ func (it *L2ToL1MessagePasserWithdrawerBalanceBurntIterator) Next() bool

+ type ProtocolVault struct

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

+ func NewProtocolVault(address common.Address, backend bind.ContractBackend) (*ProtocolVault, error)

+ type ProtocolVaultCaller struct

+ func NewProtocolVaultCaller(address common.Address, caller bind.ContractCaller) (*ProtocolVaultCaller, error)

+ func (_ProtocolVault *ProtocolVaultCaller) MINWITHDRAWALAMOUNT(opts *bind.CallOpts) (*big.Int, error)

+ func (_ProtocolVault *ProtocolVaultCaller) RECIPIENT(opts *bind.CallOpts) (common.Address, error)

+ func (_ProtocolVault *ProtocolVaultCaller) TotalProcessed(opts *bind.CallOpts) (*big.Int, error)

+ func (_ProtocolVault *ProtocolVaultCaller) Version(opts *bind.CallOpts) (string, error)

+ type ProtocolVaultCallerRaw struct

+ Contract *ProtocolVaultCaller

+ func (_ProtocolVault *ProtocolVaultCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type ProtocolVaultCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ProtocolVaultCaller

+ func (_ProtocolVault *ProtocolVaultCallerSession) MINWITHDRAWALAMOUNT() (*big.Int, error)

+ func (_ProtocolVault *ProtocolVaultCallerSession) RECIPIENT() (common.Address, error)

+ func (_ProtocolVault *ProtocolVaultCallerSession) TotalProcessed() (*big.Int, error)

+ func (_ProtocolVault *ProtocolVaultCallerSession) Version() (string, error)

+ type ProtocolVaultFilterer struct

+ func NewProtocolVaultFilterer(address common.Address, filterer bind.ContractFilterer) (*ProtocolVaultFilterer, error)

+ func (_ProtocolVault *ProtocolVaultFilterer) FilterWithdrawal(opts *bind.FilterOpts) (*ProtocolVaultWithdrawalIterator, error)

+ func (_ProtocolVault *ProtocolVaultFilterer) ParseWithdrawal(log types.Log) (*ProtocolVaultWithdrawal, error)

+ func (_ProtocolVault *ProtocolVaultFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *ProtocolVaultWithdrawal) (event.Subscription, error)

+ type ProtocolVaultRaw struct

+ Contract *ProtocolVault

+ func (_ProtocolVault *ProtocolVaultRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_ProtocolVault *ProtocolVaultRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ProtocolVaultSession struct

+ CallOpts bind.CallOpts

+ Contract *ProtocolVault

+ TransactOpts bind.TransactOpts

+ func (_ProtocolVault *ProtocolVaultSession) MINWITHDRAWALAMOUNT() (*big.Int, error)

+ func (_ProtocolVault *ProtocolVaultSession) RECIPIENT() (common.Address, error)

+ func (_ProtocolVault *ProtocolVaultSession) Receive() (*types.Transaction, error)

+ func (_ProtocolVault *ProtocolVaultSession) TotalProcessed() (*big.Int, error)

+ func (_ProtocolVault *ProtocolVaultSession) Version() (string, error)

+ func (_ProtocolVault *ProtocolVaultSession) Withdraw() (*types.Transaction, error)

+ func (_ProtocolVault *ProtocolVaultSession) WithdrawToL2() (*types.Transaction, error)

+ type ProtocolVaultTransactor struct

+ func NewProtocolVaultTransactor(address common.Address, transactor bind.ContractTransactor) (*ProtocolVaultTransactor, error)

+ func (_ProtocolVault *ProtocolVaultTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_ProtocolVault *ProtocolVaultTransactor) Withdraw(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_ProtocolVault *ProtocolVaultTransactor) WithdrawToL2(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ProtocolVaultTransactorRaw struct

+ Contract *ProtocolVaultTransactor

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

+ func (_ProtocolVault *ProtocolVaultTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ProtocolVaultTransactorSession struct

+ Contract *ProtocolVaultTransactor

+ TransactOpts bind.TransactOpts

+ func (_ProtocolVault *ProtocolVaultTransactorSession) Receive() (*types.Transaction, error)

+ func (_ProtocolVault *ProtocolVaultTransactorSession) Withdraw() (*types.Transaction, error)

+ func (_ProtocolVault *ProtocolVaultTransactorSession) WithdrawToL2() (*types.Transaction, error)

+ type ProtocolVaultWithdrawal struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type ProtocolVaultWithdrawalIterator struct

+ Event *ProtocolVaultWithdrawal

+ func (it *ProtocolVaultWithdrawalIterator) Close() error

+ func (it *ProtocolVaultWithdrawalIterator) Error() error

+ func (it *ProtocolVaultWithdrawalIterator) Next() bool

+ type Proxy struct

+ func DeployProxy(auth *bind.TransactOpts, backend bind.ContractBackend, _admin common.Address) (common.Address, *types.Transaction, *Proxy, error)

+ func NewProxy(address common.Address, backend bind.ContractBackend) (*Proxy, error)

+ type ProxyAdmin struct

+ func DeployProxyAdmin(auth *bind.TransactOpts, backend bind.ContractBackend, _owner common.Address) (common.Address, *types.Transaction, *ProxyAdmin, error)

+ func NewProxyAdmin(address common.Address, backend bind.ContractBackend) (*ProxyAdmin, error)

+ type ProxyAdminCaller struct

+ func NewProxyAdminCaller(address common.Address, caller bind.ContractCaller) (*ProxyAdminCaller, error)

+ func (_ProxyAdmin *ProxyAdminCaller) GetProxyAdmin(opts *bind.CallOpts, _proxy common.Address) (common.Address, error)

+ func (_ProxyAdmin *ProxyAdminCaller) GetProxyImplementation(opts *bind.CallOpts, _proxy common.Address) (common.Address, error)

+ func (_ProxyAdmin *ProxyAdminCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ type ProxyAdminCallerRaw struct

+ Contract *ProxyAdminCaller

+ func (_ProxyAdmin *ProxyAdminCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type ProxyAdminCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ProxyAdminCaller

+ func (_ProxyAdmin *ProxyAdminCallerSession) GetProxyAdmin(_proxy common.Address) (common.Address, error)

+ func (_ProxyAdmin *ProxyAdminCallerSession) GetProxyImplementation(_proxy common.Address) (common.Address, error)

+ func (_ProxyAdmin *ProxyAdminCallerSession) Owner() (common.Address, error)

+ type ProxyAdminChanged struct

+ NewAdmin common.Address

+ PreviousAdmin common.Address

+ Raw types.Log

+ type ProxyAdminChangedIterator struct

+ Event *ProxyAdminChanged

+ func (it *ProxyAdminChangedIterator) Close() error

+ func (it *ProxyAdminChangedIterator) Error() error

+ func (it *ProxyAdminChangedIterator) Next() bool

+ type ProxyAdminFilterer struct

+ func NewProxyAdminFilterer(address common.Address, filterer bind.ContractFilterer) (*ProxyAdminFilterer, error)

+ func (_ProxyAdmin *ProxyAdminFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*ProxyAdminOwnershipTransferredIterator, error)

+ func (_ProxyAdmin *ProxyAdminFilterer) ParseOwnershipTransferred(log types.Log) (*ProxyAdminOwnershipTransferred, error)

+ func (_ProxyAdmin *ProxyAdminFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ProxyAdminOwnershipTransferred, ...) (event.Subscription, error)

+ type ProxyAdminOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type ProxyAdminOwnershipTransferredIterator struct

+ Event *ProxyAdminOwnershipTransferred

+ func (it *ProxyAdminOwnershipTransferredIterator) Close() error

+ func (it *ProxyAdminOwnershipTransferredIterator) Error() error

+ func (it *ProxyAdminOwnershipTransferredIterator) Next() bool

+ type ProxyAdminRaw struct

+ Contract *ProxyAdmin

+ func (_ProxyAdmin *ProxyAdminRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_ProxyAdmin *ProxyAdminRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ProxyAdminSession struct

+ CallOpts bind.CallOpts

+ Contract *ProxyAdmin

+ TransactOpts bind.TransactOpts

+ func (_ProxyAdmin *ProxyAdminSession) ChangeProxyAdmin(_proxy common.Address, _newAdmin common.Address) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminSession) GetProxyAdmin(_proxy common.Address) (common.Address, error)

+ func (_ProxyAdmin *ProxyAdminSession) GetProxyImplementation(_proxy common.Address) (common.Address, error)

+ func (_ProxyAdmin *ProxyAdminSession) Owner() (common.Address, error)

+ func (_ProxyAdmin *ProxyAdminSession) RenounceOwnership() (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminSession) Upgrade(_proxy common.Address, _implementation common.Address) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminSession) UpgradeAndCall(_proxy common.Address, _implementation common.Address, _data []byte) (*types.Transaction, error)

+ type ProxyAdminTransactor struct

+ func NewProxyAdminTransactor(address common.Address, transactor bind.ContractTransactor) (*ProxyAdminTransactor, error)

+ func (_ProxyAdmin *ProxyAdminTransactor) ChangeProxyAdmin(opts *bind.TransactOpts, _proxy common.Address, _newAdmin common.Address) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminTransactor) Upgrade(opts *bind.TransactOpts, _proxy common.Address, _implementation common.Address) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminTransactor) UpgradeAndCall(opts *bind.TransactOpts, _proxy common.Address, _implementation common.Address, ...) (*types.Transaction, error)

+ type ProxyAdminTransactorRaw struct

+ Contract *ProxyAdminTransactor

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

+ func (_ProxyAdmin *ProxyAdminTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ProxyAdminTransactorSession struct

+ Contract *ProxyAdminTransactor

+ TransactOpts bind.TransactOpts

+ func (_ProxyAdmin *ProxyAdminTransactorSession) ChangeProxyAdmin(_proxy common.Address, _newAdmin common.Address) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminTransactorSession) Upgrade(_proxy common.Address, _implementation common.Address) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminTransactorSession) UpgradeAndCall(_proxy common.Address, _implementation common.Address, _data []byte) (*types.Transaction, error)

+ type ProxyCaller struct

+ func NewProxyCaller(address common.Address, caller bind.ContractCaller) (*ProxyCaller, error)

+ type ProxyCallerRaw struct

+ Contract *ProxyCaller

+ func (_Proxy *ProxyCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type ProxyCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ProxyCaller

+ type ProxyFilterer struct

+ func NewProxyFilterer(address common.Address, filterer bind.ContractFilterer) (*ProxyFilterer, error)

+ func (_Proxy *ProxyFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*ProxyAdminChangedIterator, error)

+ func (_Proxy *ProxyFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*ProxyUpgradedIterator, error)

+ func (_Proxy *ProxyFilterer) ParseAdminChanged(log types.Log) (*ProxyAdminChanged, error)

+ func (_Proxy *ProxyFilterer) ParseUpgraded(log types.Log) (*ProxyUpgraded, error)

+ func (_Proxy *ProxyFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *ProxyAdminChanged) (event.Subscription, error)

+ func (_Proxy *ProxyFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *ProxyUpgraded, ...) (event.Subscription, error)

+ type ProxyRaw struct

+ Contract *Proxy

+ func (_Proxy *ProxyRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_Proxy *ProxyRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ProxySession struct

+ CallOpts bind.CallOpts

+ Contract *Proxy

+ TransactOpts bind.TransactOpts

+ func (_Proxy *ProxySession) Admin() (*types.Transaction, error)

+ func (_Proxy *ProxySession) ChangeAdmin(_admin common.Address) (*types.Transaction, error)

+ func (_Proxy *ProxySession) Fallback(calldata []byte) (*types.Transaction, error)

+ func (_Proxy *ProxySession) Implementation() (*types.Transaction, error)

+ func (_Proxy *ProxySession) Receive() (*types.Transaction, error)

+ func (_Proxy *ProxySession) UpgradeTo(_implementation common.Address) (*types.Transaction, error)

+ func (_Proxy *ProxySession) UpgradeToAndCall(_implementation common.Address, _data []byte) (*types.Transaction, error)

+ type ProxyTransactor struct

+ func NewProxyTransactor(address common.Address, transactor bind.ContractTransactor) (*ProxyTransactor, error)

+ func (_Proxy *ProxyTransactor) Admin(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Proxy *ProxyTransactor) ChangeAdmin(opts *bind.TransactOpts, _admin common.Address) (*types.Transaction, error)

+ func (_Proxy *ProxyTransactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error)

+ func (_Proxy *ProxyTransactor) Implementation(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Proxy *ProxyTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Proxy *ProxyTransactor) UpgradeTo(opts *bind.TransactOpts, _implementation common.Address) (*types.Transaction, error)

+ func (_Proxy *ProxyTransactor) UpgradeToAndCall(opts *bind.TransactOpts, _implementation common.Address, _data []byte) (*types.Transaction, error)

+ type ProxyTransactorRaw struct

+ Contract *ProxyTransactor

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

+ func (_Proxy *ProxyTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ProxyTransactorSession struct

+ Contract *ProxyTransactor

+ TransactOpts bind.TransactOpts

+ func (_Proxy *ProxyTransactorSession) Admin() (*types.Transaction, error)

+ func (_Proxy *ProxyTransactorSession) ChangeAdmin(_admin common.Address) (*types.Transaction, error)

+ func (_Proxy *ProxyTransactorSession) Fallback(calldata []byte) (*types.Transaction, error)

+ func (_Proxy *ProxyTransactorSession) Implementation() (*types.Transaction, error)

+ func (_Proxy *ProxyTransactorSession) Receive() (*types.Transaction, error)

+ func (_Proxy *ProxyTransactorSession) UpgradeTo(_implementation common.Address) (*types.Transaction, error)

+ func (_Proxy *ProxyTransactorSession) UpgradeToAndCall(_implementation common.Address, _data []byte) (*types.Transaction, error)

+ type ProxyUpgraded struct

+ Implementation common.Address

+ Raw types.Log

+ type ProxyUpgradedIterator struct

+ Event *ProxyUpgraded

+ func (it *ProxyUpgradedIterator) Close() error

+ func (it *ProxyUpgradedIterator) Error() error

+ func (it *ProxyUpgradedIterator) Next() bool

+ type ResourceMeteringResourceConfig struct

+ BaseFeeMaxChangeDenominator uint8

+ ElasticityMultiplier uint8

+ MaxResourceLimit uint32

+ MaximumBaseFee *big.Int

+ MinimumBaseFee uint32

+ SystemTxMaxGas uint32

+ type SecurityCouncil struct

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

+ func NewSecurityCouncil(address common.Address, backend bind.ContractBackend) (*SecurityCouncil, error)

+ type SecurityCouncilCaller struct

+ func NewSecurityCouncilCaller(address common.Address, caller bind.ContractCaller) (*SecurityCouncilCaller, error)

+ func (_SecurityCouncil *SecurityCouncilCaller) COLOSSEUM(opts *bind.CallOpts) (common.Address, error)

+ func (_SecurityCouncil *SecurityCouncilCaller) Clock(opts *bind.CallOpts) (*big.Int, error)

+ func (_SecurityCouncil *SecurityCouncilCaller) Confirmations(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error)

+ func (_SecurityCouncil *SecurityCouncilCaller) GOVERNOR(opts *bind.CallOpts) (common.Address, error)

+ func (_SecurityCouncil *SecurityCouncilCaller) GenerateTransactionId(opts *bind.CallOpts, _target common.Address, _value *big.Int, _data []byte) (*big.Int, error)

+ func (_SecurityCouncil *SecurityCouncilCaller) GetConfirmationCount(opts *bind.CallOpts, _transactionId *big.Int) (*big.Int, error)

+ func (_SecurityCouncil *SecurityCouncilCaller) GetVotes(opts *bind.CallOpts, account common.Address) (*big.Int, error)

+ func (_SecurityCouncil *SecurityCouncilCaller) IsConfirmed(opts *bind.CallOpts, _transactionId *big.Int) (bool, error)

+ func (_SecurityCouncil *SecurityCouncilCaller) IsConfirmedBy(opts *bind.CallOpts, _transactionId *big.Int, _account common.Address) (bool, error)

+ func (_SecurityCouncil *SecurityCouncilCaller) OutputsDeleteRequested(opts *bind.CallOpts, arg0 *big.Int) (bool, error)

+ func (_SecurityCouncil *SecurityCouncilCaller) Quorum(opts *bind.CallOpts) (*big.Int, error)

+ func (_SecurityCouncil *SecurityCouncilCaller) TransactionCount(opts *bind.CallOpts) (*big.Int, error)

+ func (_SecurityCouncil *SecurityCouncilCaller) Transactions(opts *bind.CallOpts, arg0 *big.Int) (struct{ ... }, error)

+ func (_SecurityCouncil *SecurityCouncilCaller) Version(opts *bind.CallOpts) (string, error)

+ type SecurityCouncilCallerRaw struct

+ Contract *SecurityCouncilCaller

+ func (_SecurityCouncil *SecurityCouncilCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type SecurityCouncilCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SecurityCouncilCaller

+ func (_SecurityCouncil *SecurityCouncilCallerSession) COLOSSEUM() (common.Address, error)

+ func (_SecurityCouncil *SecurityCouncilCallerSession) Clock() (*big.Int, error)

+ func (_SecurityCouncil *SecurityCouncilCallerSession) Confirmations(arg0 *big.Int) (*big.Int, error)

+ func (_SecurityCouncil *SecurityCouncilCallerSession) GOVERNOR() (common.Address, error)

+ func (_SecurityCouncil *SecurityCouncilCallerSession) GenerateTransactionId(_target common.Address, _value *big.Int, _data []byte) (*big.Int, error)

+ func (_SecurityCouncil *SecurityCouncilCallerSession) GetConfirmationCount(_transactionId *big.Int) (*big.Int, error)

+ func (_SecurityCouncil *SecurityCouncilCallerSession) GetVotes(account common.Address) (*big.Int, error)

+ func (_SecurityCouncil *SecurityCouncilCallerSession) IsConfirmed(_transactionId *big.Int) (bool, error)

+ func (_SecurityCouncil *SecurityCouncilCallerSession) IsConfirmedBy(_transactionId *big.Int, _account common.Address) (bool, error)

+ func (_SecurityCouncil *SecurityCouncilCallerSession) OutputsDeleteRequested(arg0 *big.Int) (bool, error)

+ func (_SecurityCouncil *SecurityCouncilCallerSession) Quorum() (*big.Int, error)

+ func (_SecurityCouncil *SecurityCouncilCallerSession) TransactionCount() (*big.Int, error)

+ func (_SecurityCouncil *SecurityCouncilCallerSession) Transactions(arg0 *big.Int) (struct{ ... }, error)

+ func (_SecurityCouncil *SecurityCouncilCallerSession) Version() (string, error)

+ type SecurityCouncilConfirmationRevoked struct

+ Raw types.Log

+ Sender common.Address

+ TransactionId *big.Int

+ type SecurityCouncilConfirmationRevokedIterator struct

+ Event *SecurityCouncilConfirmationRevoked

+ func (it *SecurityCouncilConfirmationRevokedIterator) Close() error

+ func (it *SecurityCouncilConfirmationRevokedIterator) Error() error

+ func (it *SecurityCouncilConfirmationRevokedIterator) Next() bool

+ type SecurityCouncilDeletionRequested struct

+ OutputIndex *big.Int

+ Raw types.Log

+ TransactionId *big.Int

+ type SecurityCouncilDeletionRequestedIterator struct

+ Event *SecurityCouncilDeletionRequested

+ func (it *SecurityCouncilDeletionRequestedIterator) Close() error

+ func (it *SecurityCouncilDeletionRequestedIterator) Error() error

+ func (it *SecurityCouncilDeletionRequestedIterator) Next() bool

+ type SecurityCouncilFilterer struct

+ func NewSecurityCouncilFilterer(address common.Address, filterer bind.ContractFilterer) (*SecurityCouncilFilterer, error)

+ func (_SecurityCouncil *SecurityCouncilFilterer) FilterConfirmationRevoked(opts *bind.FilterOpts, sender []common.Address, transactionId []*big.Int) (*SecurityCouncilConfirmationRevokedIterator, error)

+ func (_SecurityCouncil *SecurityCouncilFilterer) FilterDeletionRequested(opts *bind.FilterOpts, transactionId []*big.Int, outputIndex []*big.Int) (*SecurityCouncilDeletionRequestedIterator, error)

+ func (_SecurityCouncil *SecurityCouncilFilterer) FilterInitialized(opts *bind.FilterOpts) (*SecurityCouncilInitializedIterator, error)

+ func (_SecurityCouncil *SecurityCouncilFilterer) FilterTransactionConfirmed(opts *bind.FilterOpts, sender []common.Address, transactionId []*big.Int) (*SecurityCouncilTransactionConfirmedIterator, error)

+ func (_SecurityCouncil *SecurityCouncilFilterer) FilterTransactionExecuted(opts *bind.FilterOpts, sender []common.Address, transactionId []*big.Int) (*SecurityCouncilTransactionExecutedIterator, error)

+ func (_SecurityCouncil *SecurityCouncilFilterer) FilterTransactionSubmitted(opts *bind.FilterOpts, sender []common.Address, transactionId []*big.Int) (*SecurityCouncilTransactionSubmittedIterator, error)

+ func (_SecurityCouncil *SecurityCouncilFilterer) FilterValidationRequested(opts *bind.FilterOpts, transactionId []*big.Int) (*SecurityCouncilValidationRequestedIterator, error)

+ func (_SecurityCouncil *SecurityCouncilFilterer) ParseConfirmationRevoked(log types.Log) (*SecurityCouncilConfirmationRevoked, error)

+ func (_SecurityCouncil *SecurityCouncilFilterer) ParseDeletionRequested(log types.Log) (*SecurityCouncilDeletionRequested, error)

+ func (_SecurityCouncil *SecurityCouncilFilterer) ParseInitialized(log types.Log) (*SecurityCouncilInitialized, error)

+ func (_SecurityCouncil *SecurityCouncilFilterer) ParseTransactionConfirmed(log types.Log) (*SecurityCouncilTransactionConfirmed, error)

+ func (_SecurityCouncil *SecurityCouncilFilterer) ParseTransactionExecuted(log types.Log) (*SecurityCouncilTransactionExecuted, error)

+ func (_SecurityCouncil *SecurityCouncilFilterer) ParseTransactionSubmitted(log types.Log) (*SecurityCouncilTransactionSubmitted, error)

+ func (_SecurityCouncil *SecurityCouncilFilterer) ParseValidationRequested(log types.Log) (*SecurityCouncilValidationRequested, error)

+ func (_SecurityCouncil *SecurityCouncilFilterer) WatchConfirmationRevoked(opts *bind.WatchOpts, sink chan<- *SecurityCouncilConfirmationRevoked, ...) (event.Subscription, error)

+ func (_SecurityCouncil *SecurityCouncilFilterer) WatchDeletionRequested(opts *bind.WatchOpts, sink chan<- *SecurityCouncilDeletionRequested, ...) (event.Subscription, error)

+ func (_SecurityCouncil *SecurityCouncilFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *SecurityCouncilInitialized) (event.Subscription, error)

+ func (_SecurityCouncil *SecurityCouncilFilterer) WatchTransactionConfirmed(opts *bind.WatchOpts, sink chan<- *SecurityCouncilTransactionConfirmed, ...) (event.Subscription, error)

+ func (_SecurityCouncil *SecurityCouncilFilterer) WatchTransactionExecuted(opts *bind.WatchOpts, sink chan<- *SecurityCouncilTransactionExecuted, ...) (event.Subscription, error)

+ func (_SecurityCouncil *SecurityCouncilFilterer) WatchTransactionSubmitted(opts *bind.WatchOpts, sink chan<- *SecurityCouncilTransactionSubmitted, ...) (event.Subscription, error)

+ func (_SecurityCouncil *SecurityCouncilFilterer) WatchValidationRequested(opts *bind.WatchOpts, sink chan<- *SecurityCouncilValidationRequested, ...) (event.Subscription, error)

+ type SecurityCouncilInitialized struct

+ Raw types.Log

+ Version uint8

+ type SecurityCouncilInitializedIterator struct

+ Event *SecurityCouncilInitialized

+ func (it *SecurityCouncilInitializedIterator) Close() error

+ func (it *SecurityCouncilInitializedIterator) Error() error

+ func (it *SecurityCouncilInitializedIterator) Next() bool

+ type SecurityCouncilRaw struct

+ Contract *SecurityCouncil

+ func (_SecurityCouncil *SecurityCouncilRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_SecurityCouncil *SecurityCouncilRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SecurityCouncilSession struct

+ CallOpts bind.CallOpts

+ Contract *SecurityCouncil

+ TransactOpts bind.TransactOpts

+ func (_SecurityCouncil *SecurityCouncilSession) COLOSSEUM() (common.Address, error)

+ func (_SecurityCouncil *SecurityCouncilSession) Clock() (*big.Int, error)

+ func (_SecurityCouncil *SecurityCouncilSession) ConfirmTransaction(_transactionId *big.Int) (*types.Transaction, error)

+ func (_SecurityCouncil *SecurityCouncilSession) Confirmations(arg0 *big.Int) (*big.Int, error)

+ func (_SecurityCouncil *SecurityCouncilSession) ExecuteTransaction(_transactionId *big.Int) (*types.Transaction, error)

+ func (_SecurityCouncil *SecurityCouncilSession) GOVERNOR() (common.Address, error)

+ func (_SecurityCouncil *SecurityCouncilSession) GenerateTransactionId(_target common.Address, _value *big.Int, _data []byte) (*big.Int, error)

+ func (_SecurityCouncil *SecurityCouncilSession) GetConfirmationCount(_transactionId *big.Int) (*big.Int, error)

+ func (_SecurityCouncil *SecurityCouncilSession) GetVotes(account common.Address) (*big.Int, error)

+ func (_SecurityCouncil *SecurityCouncilSession) IsConfirmed(_transactionId *big.Int) (bool, error)

+ func (_SecurityCouncil *SecurityCouncilSession) IsConfirmedBy(_transactionId *big.Int, _account common.Address) (bool, error)

+ func (_SecurityCouncil *SecurityCouncilSession) OutputsDeleteRequested(arg0 *big.Int) (bool, error)

+ func (_SecurityCouncil *SecurityCouncilSession) Quorum() (*big.Int, error)

+ func (_SecurityCouncil *SecurityCouncilSession) RequestDeletion(_outputIndex *big.Int, _force bool) (*types.Transaction, error)

+ func (_SecurityCouncil *SecurityCouncilSession) RequestValidation(_outputRoot [32]byte, _l2BlockNumber *big.Int, _data []byte) (*types.Transaction, error)

+ func (_SecurityCouncil *SecurityCouncilSession) RevokeConfirmation(_transactionId *big.Int) (*types.Transaction, error)

+ func (_SecurityCouncil *SecurityCouncilSession) SubmitTransaction(_target common.Address, _value *big.Int, _data []byte) (*types.Transaction, error)

+ func (_SecurityCouncil *SecurityCouncilSession) TransactionCount() (*big.Int, error)

+ func (_SecurityCouncil *SecurityCouncilSession) Transactions(arg0 *big.Int) (struct{ ... }, error)

+ func (_SecurityCouncil *SecurityCouncilSession) Version() (string, error)

+ type SecurityCouncilToken struct

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

+ func NewSecurityCouncilToken(address common.Address, backend bind.ContractBackend) (*SecurityCouncilToken, error)

+ type SecurityCouncilTokenApproval struct

+ Approved common.Address

+ Owner common.Address

+ Raw types.Log

+ TokenId *big.Int

+ type SecurityCouncilTokenApprovalForAll struct

+ Approved bool

+ Operator common.Address

+ Owner common.Address

+ Raw types.Log

+ type SecurityCouncilTokenApprovalForAllIterator struct

+ Event *SecurityCouncilTokenApprovalForAll

+ func (it *SecurityCouncilTokenApprovalForAllIterator) Close() error

+ func (it *SecurityCouncilTokenApprovalForAllIterator) Error() error

+ func (it *SecurityCouncilTokenApprovalForAllIterator) Next() bool

+ type SecurityCouncilTokenApprovalIterator struct

+ Event *SecurityCouncilTokenApproval

+ func (it *SecurityCouncilTokenApprovalIterator) Close() error

+ func (it *SecurityCouncilTokenApprovalIterator) Error() error

+ func (it *SecurityCouncilTokenApprovalIterator) Next() bool

+ type SecurityCouncilTokenBatchMetadataUpdate struct

+ FromTokenId *big.Int

+ Raw types.Log

+ ToTokenId *big.Int

+ type SecurityCouncilTokenBatchMetadataUpdateIterator struct

+ Event *SecurityCouncilTokenBatchMetadataUpdate

+ func (it *SecurityCouncilTokenBatchMetadataUpdateIterator) Close() error

+ func (it *SecurityCouncilTokenBatchMetadataUpdateIterator) Error() error

+ func (it *SecurityCouncilTokenBatchMetadataUpdateIterator) Next() bool

+ type SecurityCouncilTokenCaller struct

+ func NewSecurityCouncilTokenCaller(address common.Address, caller bind.ContractCaller) (*SecurityCouncilTokenCaller, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) CLOCKMODE(opts *bind.CallOpts) (string, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) Clock(opts *bind.CallOpts) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) DOMAINSEPARATOR(opts *bind.CallOpts) ([32]byte, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) Delegates(opts *bind.CallOpts, account common.Address) (common.Address, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) Eip712Domain(opts *bind.CallOpts) (struct{ ... }, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) GetPastTotalSupply(opts *bind.CallOpts, timepoint *big.Int) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) GetPastVotes(opts *bind.CallOpts, account common.Address, timepoint *big.Int) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) GetVotes(opts *bind.CallOpts, account common.Address) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) Locked(opts *bind.CallOpts, tokenId *big.Int) (bool, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) Nonces(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) Paused(opts *bind.CallOpts) (bool, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) TokenByIndex(opts *bind.CallOpts, index *big.Int) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) TokenOfOwnerByIndex(opts *bind.CallOpts, owner common.Address, index *big.Int) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) TokenURI(opts *bind.CallOpts, tokenId *big.Int) (string, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCaller) Version(opts *bind.CallOpts) (string, error)

+ type SecurityCouncilTokenCallerRaw struct

+ Contract *SecurityCouncilTokenCaller

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type SecurityCouncilTokenCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SecurityCouncilTokenCaller

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) CLOCKMODE() (string, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) Clock() (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) DOMAINSEPARATOR() ([32]byte, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) Delegates(account common.Address) (common.Address, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) Eip712Domain() (struct{ ... }, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) GetPastTotalSupply(timepoint *big.Int) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) GetPastVotes(account common.Address, timepoint *big.Int) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) GetVotes(account common.Address) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) Locked(tokenId *big.Int) (bool, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) Name() (string, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) Nonces(owner common.Address) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) Owner() (common.Address, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) Paused() (bool, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) Symbol() (string, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) TokenByIndex(index *big.Int) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) TokenURI(tokenId *big.Int) (string, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) TotalSupply() (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenCallerSession) Version() (string, error)

+ type SecurityCouncilTokenDelegateChanged struct

+ Delegator common.Address

+ FromDelegate common.Address

+ Raw types.Log

+ ToDelegate common.Address

+ type SecurityCouncilTokenDelegateChangedIterator struct

+ Event *SecurityCouncilTokenDelegateChanged

+ func (it *SecurityCouncilTokenDelegateChangedIterator) Close() error

+ func (it *SecurityCouncilTokenDelegateChangedIterator) Error() error

+ func (it *SecurityCouncilTokenDelegateChangedIterator) Next() bool

+ type SecurityCouncilTokenDelegateVotesChanged struct

+ Delegate common.Address

+ NewBalance *big.Int

+ PreviousBalance *big.Int

+ Raw types.Log

+ type SecurityCouncilTokenDelegateVotesChangedIterator struct

+ Event *SecurityCouncilTokenDelegateVotesChanged

+ func (it *SecurityCouncilTokenDelegateVotesChangedIterator) Close() error

+ func (it *SecurityCouncilTokenDelegateVotesChangedIterator) Error() error

+ func (it *SecurityCouncilTokenDelegateVotesChangedIterator) Next() bool

+ type SecurityCouncilTokenEIP712DomainChanged struct

+ Raw types.Log

+ type SecurityCouncilTokenEIP712DomainChangedIterator struct

+ Event *SecurityCouncilTokenEIP712DomainChanged

+ func (it *SecurityCouncilTokenEIP712DomainChangedIterator) Close() error

+ func (it *SecurityCouncilTokenEIP712DomainChangedIterator) Error() error

+ func (it *SecurityCouncilTokenEIP712DomainChangedIterator) Next() bool

+ type SecurityCouncilTokenFilterer struct

+ func NewSecurityCouncilTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*SecurityCouncilTokenFilterer, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, ...) (*SecurityCouncilTokenApprovalIterator, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*SecurityCouncilTokenApprovalForAllIterator, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) FilterBatchMetadataUpdate(opts *bind.FilterOpts) (*SecurityCouncilTokenBatchMetadataUpdateIterator, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) FilterDelegateChanged(opts *bind.FilterOpts, delegator []common.Address, ...) (*SecurityCouncilTokenDelegateChangedIterator, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) FilterDelegateVotesChanged(opts *bind.FilterOpts, delegate []common.Address) (*SecurityCouncilTokenDelegateVotesChangedIterator, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) FilterEIP712DomainChanged(opts *bind.FilterOpts) (*SecurityCouncilTokenEIP712DomainChangedIterator, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) FilterInitialized(opts *bind.FilterOpts) (*SecurityCouncilTokenInitializedIterator, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) FilterLocked(opts *bind.FilterOpts) (*SecurityCouncilTokenLockedIterator, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) FilterMetadataUpdate(opts *bind.FilterOpts) (*SecurityCouncilTokenMetadataUpdateIterator, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*SecurityCouncilTokenOwnershipTransferredIterator, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) FilterPaused(opts *bind.FilterOpts) (*SecurityCouncilTokenPausedIterator, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, ...) (*SecurityCouncilTokenTransferIterator, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) FilterUnlocked(opts *bind.FilterOpts) (*SecurityCouncilTokenUnlockedIterator, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) FilterUnpaused(opts *bind.FilterOpts) (*SecurityCouncilTokenUnpausedIterator, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) ParseApproval(log types.Log) (*SecurityCouncilTokenApproval, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) ParseApprovalForAll(log types.Log) (*SecurityCouncilTokenApprovalForAll, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) ParseBatchMetadataUpdate(log types.Log) (*SecurityCouncilTokenBatchMetadataUpdate, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) ParseDelegateChanged(log types.Log) (*SecurityCouncilTokenDelegateChanged, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) ParseDelegateVotesChanged(log types.Log) (*SecurityCouncilTokenDelegateVotesChanged, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) ParseEIP712DomainChanged(log types.Log) (*SecurityCouncilTokenEIP712DomainChanged, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) ParseInitialized(log types.Log) (*SecurityCouncilTokenInitialized, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) ParseLocked(log types.Log) (*SecurityCouncilTokenLocked, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) ParseMetadataUpdate(log types.Log) (*SecurityCouncilTokenMetadataUpdate, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) ParseOwnershipTransferred(log types.Log) (*SecurityCouncilTokenOwnershipTransferred, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) ParsePaused(log types.Log) (*SecurityCouncilTokenPaused, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) ParseTransfer(log types.Log) (*SecurityCouncilTokenTransfer, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) ParseUnlocked(log types.Log) (*SecurityCouncilTokenUnlocked, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) ParseUnpaused(log types.Log) (*SecurityCouncilTokenUnpaused, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *SecurityCouncilTokenApproval, ...) (event.Subscription, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *SecurityCouncilTokenApprovalForAll, ...) (event.Subscription, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) WatchBatchMetadataUpdate(opts *bind.WatchOpts, sink chan<- *SecurityCouncilTokenBatchMetadataUpdate) (event.Subscription, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) WatchDelegateChanged(opts *bind.WatchOpts, sink chan<- *SecurityCouncilTokenDelegateChanged, ...) (event.Subscription, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) WatchDelegateVotesChanged(opts *bind.WatchOpts, sink chan<- *SecurityCouncilTokenDelegateVotesChanged, ...) (event.Subscription, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) WatchEIP712DomainChanged(opts *bind.WatchOpts, sink chan<- *SecurityCouncilTokenEIP712DomainChanged) (event.Subscription, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *SecurityCouncilTokenInitialized) (event.Subscription, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) WatchLocked(opts *bind.WatchOpts, sink chan<- *SecurityCouncilTokenLocked) (event.Subscription, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) WatchMetadataUpdate(opts *bind.WatchOpts, sink chan<- *SecurityCouncilTokenMetadataUpdate) (event.Subscription, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *SecurityCouncilTokenOwnershipTransferred, ...) (event.Subscription, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *SecurityCouncilTokenPaused) (event.Subscription, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *SecurityCouncilTokenTransfer, ...) (event.Subscription, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) WatchUnlocked(opts *bind.WatchOpts, sink chan<- *SecurityCouncilTokenUnlocked) (event.Subscription, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *SecurityCouncilTokenUnpaused) (event.Subscription, error)

+ type SecurityCouncilTokenInitialized struct

+ Raw types.Log

+ Version uint8

+ type SecurityCouncilTokenInitializedIterator struct

+ Event *SecurityCouncilTokenInitialized

+ func (it *SecurityCouncilTokenInitializedIterator) Close() error

+ func (it *SecurityCouncilTokenInitializedIterator) Error() error

+ func (it *SecurityCouncilTokenInitializedIterator) Next() bool

+ type SecurityCouncilTokenLocked struct

+ Raw types.Log

+ TokenId *big.Int

+ type SecurityCouncilTokenLockedIterator struct

+ Event *SecurityCouncilTokenLocked

+ func (it *SecurityCouncilTokenLockedIterator) Close() error

+ func (it *SecurityCouncilTokenLockedIterator) Error() error

+ func (it *SecurityCouncilTokenLockedIterator) Next() bool

+ type SecurityCouncilTokenMetadataUpdate struct

+ Raw types.Log

+ TokenId *big.Int

+ type SecurityCouncilTokenMetadataUpdateIterator struct

+ Event *SecurityCouncilTokenMetadataUpdate

+ func (it *SecurityCouncilTokenMetadataUpdateIterator) Close() error

+ func (it *SecurityCouncilTokenMetadataUpdateIterator) Error() error

+ func (it *SecurityCouncilTokenMetadataUpdateIterator) Next() bool

+ type SecurityCouncilTokenOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type SecurityCouncilTokenOwnershipTransferredIterator struct

+ Event *SecurityCouncilTokenOwnershipTransferred

+ func (it *SecurityCouncilTokenOwnershipTransferredIterator) Close() error

+ func (it *SecurityCouncilTokenOwnershipTransferredIterator) Error() error

+ func (it *SecurityCouncilTokenOwnershipTransferredIterator) Next() bool

+ type SecurityCouncilTokenPaused struct

+ Account common.Address

+ Raw types.Log

+ type SecurityCouncilTokenPausedIterator struct

+ Event *SecurityCouncilTokenPaused

+ func (it *SecurityCouncilTokenPausedIterator) Close() error

+ func (it *SecurityCouncilTokenPausedIterator) Error() error

+ func (it *SecurityCouncilTokenPausedIterator) Next() bool

+ type SecurityCouncilTokenRaw struct

+ Contract *SecurityCouncilToken

+ func (_SecurityCouncilToken *SecurityCouncilTokenRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_SecurityCouncilToken *SecurityCouncilTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SecurityCouncilTokenSession struct

+ CallOpts bind.CallOpts

+ Contract *SecurityCouncilToken

+ TransactOpts bind.TransactOpts

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) Approve(approved common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) Burn(tokenId *big.Int) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) CLOCKMODE() (string, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) Clock() (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) DOMAINSEPARATOR() ([32]byte, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) Delegate(delegatee common.Address) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) DelegateBySig(delegatee common.Address, nonce *big.Int, expiry *big.Int, v uint8, r [32]byte, ...) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) Delegates(account common.Address) (common.Address, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) Eip712Domain() (struct{ ... }, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) GetPastTotalSupply(timepoint *big.Int) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) GetPastVotes(account common.Address, timepoint *big.Int) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) GetVotes(account common.Address) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) Initialize(_owner common.Address) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) Locked(tokenId *big.Int) (bool, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) Name() (string, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) Nonces(owner common.Address) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) Owner() (common.Address, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) Pause() (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) Paused() (bool, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) RenounceOwnership() (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) SafeMint(to common.Address, uri string) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) SetApprovalForAll(operator common.Address, approved bool) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) Symbol() (string, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) TokenByIndex(index *big.Int) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) TokenURI(tokenId *big.Int) (string, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) TotalSupply() (*big.Int, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) Unpause() (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenSession) Version() (string, error)

+ type SecurityCouncilTokenTransactor struct

+ func NewSecurityCouncilTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*SecurityCouncilTokenTransactor, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactor) Approve(opts *bind.TransactOpts, approved common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactor) Burn(opts *bind.TransactOpts, tokenId *big.Int) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactor) Delegate(opts *bind.TransactOpts, delegatee common.Address) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactor) DelegateBySig(opts *bind.TransactOpts, delegatee common.Address, nonce *big.Int, ...) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactor) Initialize(opts *bind.TransactOpts, _owner common.Address) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactor) SafeMint(opts *bind.TransactOpts, to common.Address, uri string) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactor) SetApprovalForAll(opts *bind.TransactOpts, operator common.Address, approved bool) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SecurityCouncilTokenTransactorRaw struct

+ Contract *SecurityCouncilTokenTransactor

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

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SecurityCouncilTokenTransactorSession struct

+ Contract *SecurityCouncilTokenTransactor

+ TransactOpts bind.TransactOpts

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactorSession) Approve(approved common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactorSession) Burn(tokenId *big.Int) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactorSession) Delegate(delegatee common.Address) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactorSession) DelegateBySig(delegatee common.Address, nonce *big.Int, expiry *big.Int, v uint8, r [32]byte, ...) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactorSession) Initialize(_owner common.Address) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactorSession) Pause() (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactorSession) SafeMint(to common.Address, uri string) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactorSession) SetApprovalForAll(operator common.Address, approved bool) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_SecurityCouncilToken *SecurityCouncilTokenTransactorSession) Unpause() (*types.Transaction, error)

+ type SecurityCouncilTokenTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ TokenId *big.Int

+ type SecurityCouncilTokenTransferIterator struct

+ Event *SecurityCouncilTokenTransfer

+ func (it *SecurityCouncilTokenTransferIterator) Close() error

+ func (it *SecurityCouncilTokenTransferIterator) Error() error

+ func (it *SecurityCouncilTokenTransferIterator) Next() bool

+ type SecurityCouncilTokenUnlocked struct

+ Raw types.Log

+ TokenId *big.Int

+ type SecurityCouncilTokenUnlockedIterator struct

+ Event *SecurityCouncilTokenUnlocked

+ func (it *SecurityCouncilTokenUnlockedIterator) Close() error

+ func (it *SecurityCouncilTokenUnlockedIterator) Error() error

+ func (it *SecurityCouncilTokenUnlockedIterator) Next() bool

+ type SecurityCouncilTokenUnpaused struct

+ Account common.Address

+ Raw types.Log

+ type SecurityCouncilTokenUnpausedIterator struct

+ Event *SecurityCouncilTokenUnpaused

+ func (it *SecurityCouncilTokenUnpausedIterator) Close() error

+ func (it *SecurityCouncilTokenUnpausedIterator) Error() error

+ func (it *SecurityCouncilTokenUnpausedIterator) Next() bool

+ type SecurityCouncilTransactionConfirmed struct

+ Raw types.Log

+ Sender common.Address

+ TransactionId *big.Int

+ type SecurityCouncilTransactionConfirmedIterator struct

+ Event *SecurityCouncilTransactionConfirmed

+ func (it *SecurityCouncilTransactionConfirmedIterator) Close() error

+ func (it *SecurityCouncilTransactionConfirmedIterator) Error() error

+ func (it *SecurityCouncilTransactionConfirmedIterator) Next() bool

+ type SecurityCouncilTransactionExecuted struct

+ Raw types.Log

+ Sender common.Address

+ TransactionId *big.Int

+ type SecurityCouncilTransactionExecutedIterator struct

+ Event *SecurityCouncilTransactionExecuted

+ func (it *SecurityCouncilTransactionExecutedIterator) Close() error

+ func (it *SecurityCouncilTransactionExecutedIterator) Error() error

+ func (it *SecurityCouncilTransactionExecutedIterator) Next() bool

+ type SecurityCouncilTransactionSubmitted struct

+ Raw types.Log

+ Sender common.Address

+ TransactionId *big.Int

+ type SecurityCouncilTransactionSubmittedIterator struct

+ Event *SecurityCouncilTransactionSubmitted

+ func (it *SecurityCouncilTransactionSubmittedIterator) Close() error

+ func (it *SecurityCouncilTransactionSubmittedIterator) Error() error

+ func (it *SecurityCouncilTransactionSubmittedIterator) Next() bool

+ type SecurityCouncilTransactor struct

+ func NewSecurityCouncilTransactor(address common.Address, transactor bind.ContractTransactor) (*SecurityCouncilTransactor, error)

+ func (_SecurityCouncil *SecurityCouncilTransactor) ConfirmTransaction(opts *bind.TransactOpts, _transactionId *big.Int) (*types.Transaction, error)

+ func (_SecurityCouncil *SecurityCouncilTransactor) ExecuteTransaction(opts *bind.TransactOpts, _transactionId *big.Int) (*types.Transaction, error)

+ func (_SecurityCouncil *SecurityCouncilTransactor) RequestDeletion(opts *bind.TransactOpts, _outputIndex *big.Int, _force bool) (*types.Transaction, error)

+ func (_SecurityCouncil *SecurityCouncilTransactor) RequestValidation(opts *bind.TransactOpts, _outputRoot [32]byte, _l2BlockNumber *big.Int, ...) (*types.Transaction, error)

+ func (_SecurityCouncil *SecurityCouncilTransactor) RevokeConfirmation(opts *bind.TransactOpts, _transactionId *big.Int) (*types.Transaction, error)

+ func (_SecurityCouncil *SecurityCouncilTransactor) SubmitTransaction(opts *bind.TransactOpts, _target common.Address, _value *big.Int, _data []byte) (*types.Transaction, error)

+ type SecurityCouncilTransactorRaw struct

+ Contract *SecurityCouncilTransactor

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

+ func (_SecurityCouncil *SecurityCouncilTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SecurityCouncilTransactorSession struct

+ Contract *SecurityCouncilTransactor

+ TransactOpts bind.TransactOpts

+ func (_SecurityCouncil *SecurityCouncilTransactorSession) ConfirmTransaction(_transactionId *big.Int) (*types.Transaction, error)

+ func (_SecurityCouncil *SecurityCouncilTransactorSession) ExecuteTransaction(_transactionId *big.Int) (*types.Transaction, error)

+ func (_SecurityCouncil *SecurityCouncilTransactorSession) RequestDeletion(_outputIndex *big.Int, _force bool) (*types.Transaction, error)

+ func (_SecurityCouncil *SecurityCouncilTransactorSession) RequestValidation(_outputRoot [32]byte, _l2BlockNumber *big.Int, _data []byte) (*types.Transaction, error)

+ func (_SecurityCouncil *SecurityCouncilTransactorSession) RevokeConfirmation(_transactionId *big.Int) (*types.Transaction, error)

+ func (_SecurityCouncil *SecurityCouncilTransactorSession) SubmitTransaction(_target common.Address, _value *big.Int, _data []byte) (*types.Transaction, error)

+ type SecurityCouncilValidationRequested struct

+ L2BlockNumber *big.Int

+ OutputRoot [32]byte

+ Raw types.Log

+ TransactionId *big.Int

+ type SecurityCouncilValidationRequestedIterator struct

+ Event *SecurityCouncilValidationRequested

+ func (it *SecurityCouncilValidationRequestedIterator) Close() error

+ func (it *SecurityCouncilValidationRequestedIterator) Error() error

+ func (it *SecurityCouncilValidationRequestedIterator) Next() bool

+ type SystemConfig struct

+ func DeploySystemConfig(auth *bind.TransactOpts, backend bind.ContractBackend, _owner common.Address, ...) (common.Address, *types.Transaction, *SystemConfig, error)

+ func NewSystemConfig(address common.Address, backend bind.ContractBackend) (*SystemConfig, error)

+ type SystemConfigCaller struct

+ func NewSystemConfigCaller(address common.Address, caller bind.ContractCaller) (*SystemConfigCaller, error)

+ func (_SystemConfig *SystemConfigCaller) BatcherHash(opts *bind.CallOpts) ([32]byte, error)

+ func (_SystemConfig *SystemConfigCaller) GasLimit(opts *bind.CallOpts) (uint64, error)

+ func (_SystemConfig *SystemConfigCaller) MinimumGasLimit(opts *bind.CallOpts) (uint64, error)

+ func (_SystemConfig *SystemConfigCaller) Overhead(opts *bind.CallOpts) (*big.Int, error)

+ func (_SystemConfig *SystemConfigCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_SystemConfig *SystemConfigCaller) ResourceConfig(opts *bind.CallOpts) (ResourceMeteringResourceConfig, error)

+ func (_SystemConfig *SystemConfigCaller) Scalar(opts *bind.CallOpts) (*big.Int, error)

+ func (_SystemConfig *SystemConfigCaller) UNSAFEBLOCKSIGNERSLOT(opts *bind.CallOpts) ([32]byte, error)

+ func (_SystemConfig *SystemConfigCaller) UnsafeBlockSigner(opts *bind.CallOpts) (common.Address, error)

+ func (_SystemConfig *SystemConfigCaller) VERSION(opts *bind.CallOpts) (*big.Int, error)

+ func (_SystemConfig *SystemConfigCaller) ValidatorRewardScalar(opts *bind.CallOpts) (*big.Int, error)

+ func (_SystemConfig *SystemConfigCaller) Version(opts *bind.CallOpts) (string, error)

+ type SystemConfigCallerRaw struct

+ Contract *SystemConfigCaller

+ func (_SystemConfig *SystemConfigCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type SystemConfigCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SystemConfigCaller

+ func (_SystemConfig *SystemConfigCallerSession) BatcherHash() ([32]byte, error)

+ func (_SystemConfig *SystemConfigCallerSession) GasLimit() (uint64, error)

+ func (_SystemConfig *SystemConfigCallerSession) MinimumGasLimit() (uint64, error)

+ func (_SystemConfig *SystemConfigCallerSession) Overhead() (*big.Int, error)

+ func (_SystemConfig *SystemConfigCallerSession) Owner() (common.Address, error)

+ func (_SystemConfig *SystemConfigCallerSession) ResourceConfig() (ResourceMeteringResourceConfig, error)

+ func (_SystemConfig *SystemConfigCallerSession) Scalar() (*big.Int, error)

+ func (_SystemConfig *SystemConfigCallerSession) UNSAFEBLOCKSIGNERSLOT() ([32]byte, error)

+ func (_SystemConfig *SystemConfigCallerSession) UnsafeBlockSigner() (common.Address, error)

+ func (_SystemConfig *SystemConfigCallerSession) VERSION() (*big.Int, error)

+ func (_SystemConfig *SystemConfigCallerSession) ValidatorRewardScalar() (*big.Int, error)

+ func (_SystemConfig *SystemConfigCallerSession) Version() (string, error)

+ type SystemConfigConfigUpdate struct

+ Data []byte

+ Raw types.Log

+ UpdateType uint8

+ Version *big.Int

+ type SystemConfigConfigUpdateIterator struct

+ Event *SystemConfigConfigUpdate

+ func (it *SystemConfigConfigUpdateIterator) Close() error

+ func (it *SystemConfigConfigUpdateIterator) Error() error

+ func (it *SystemConfigConfigUpdateIterator) Next() bool

+ type SystemConfigFilterer struct

+ func NewSystemConfigFilterer(address common.Address, filterer bind.ContractFilterer) (*SystemConfigFilterer, error)

+ func (_SystemConfig *SystemConfigFilterer) FilterConfigUpdate(opts *bind.FilterOpts, version []*big.Int, updateType []uint8) (*SystemConfigConfigUpdateIterator, error)

+ func (_SystemConfig *SystemConfigFilterer) FilterInitialized(opts *bind.FilterOpts) (*SystemConfigInitializedIterator, error)

+ func (_SystemConfig *SystemConfigFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*SystemConfigOwnershipTransferredIterator, error)

+ func (_SystemConfig *SystemConfigFilterer) ParseConfigUpdate(log types.Log) (*SystemConfigConfigUpdate, error)

+ func (_SystemConfig *SystemConfigFilterer) ParseInitialized(log types.Log) (*SystemConfigInitialized, error)

+ func (_SystemConfig *SystemConfigFilterer) ParseOwnershipTransferred(log types.Log) (*SystemConfigOwnershipTransferred, error)

+ func (_SystemConfig *SystemConfigFilterer) WatchConfigUpdate(opts *bind.WatchOpts, sink chan<- *SystemConfigConfigUpdate, ...) (event.Subscription, error)

+ func (_SystemConfig *SystemConfigFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *SystemConfigInitialized) (event.Subscription, error)

+ func (_SystemConfig *SystemConfigFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *SystemConfigOwnershipTransferred, ...) (event.Subscription, error)

+ type SystemConfigInitialized struct

+ Raw types.Log

+ Version uint8

+ type SystemConfigInitializedIterator struct

+ Event *SystemConfigInitialized

+ func (it *SystemConfigInitializedIterator) Close() error

+ func (it *SystemConfigInitializedIterator) Error() error

+ func (it *SystemConfigInitializedIterator) Next() bool

+ type SystemConfigOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type SystemConfigOwnershipTransferredIterator struct

+ Event *SystemConfigOwnershipTransferred

+ func (it *SystemConfigOwnershipTransferredIterator) Close() error

+ func (it *SystemConfigOwnershipTransferredIterator) Error() error

+ func (it *SystemConfigOwnershipTransferredIterator) Next() bool

+ type SystemConfigRaw struct

+ Contract *SystemConfig

+ func (_SystemConfig *SystemConfigRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_SystemConfig *SystemConfigRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SystemConfigSession struct

+ CallOpts bind.CallOpts

+ Contract *SystemConfig

+ TransactOpts bind.TransactOpts

+ func (_SystemConfig *SystemConfigSession) BatcherHash() ([32]byte, error)

+ func (_SystemConfig *SystemConfigSession) GasLimit() (uint64, error)

+ func (_SystemConfig *SystemConfigSession) Initialize(_owner common.Address, _overhead *big.Int, _scalar *big.Int, ...) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigSession) MinimumGasLimit() (uint64, error)

+ func (_SystemConfig *SystemConfigSession) Overhead() (*big.Int, error)

+ func (_SystemConfig *SystemConfigSession) Owner() (common.Address, error)

+ func (_SystemConfig *SystemConfigSession) RenounceOwnership() (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigSession) ResourceConfig() (ResourceMeteringResourceConfig, error)

+ func (_SystemConfig *SystemConfigSession) Scalar() (*big.Int, error)

+ func (_SystemConfig *SystemConfigSession) SetBatcherHash(_batcherHash [32]byte) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigSession) SetGasConfig(_overhead *big.Int, _scalar *big.Int) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigSession) SetGasLimit(_gasLimit uint64) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigSession) SetResourceConfig(_config ResourceMeteringResourceConfig) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigSession) SetUnsafeBlockSigner(_unsafeBlockSigner common.Address) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigSession) SetValidatorRewardScalar(_validatorRewardScalar *big.Int) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigSession) UNSAFEBLOCKSIGNERSLOT() ([32]byte, error)

+ func (_SystemConfig *SystemConfigSession) UnsafeBlockSigner() (common.Address, error)

+ func (_SystemConfig *SystemConfigSession) VERSION() (*big.Int, error)

+ func (_SystemConfig *SystemConfigSession) ValidatorRewardScalar() (*big.Int, error)

+ func (_SystemConfig *SystemConfigSession) Version() (string, error)

+ type SystemConfigTransactor struct

+ func NewSystemConfigTransactor(address common.Address, transactor bind.ContractTransactor) (*SystemConfigTransactor, error)

+ func (_SystemConfig *SystemConfigTransactor) Initialize(opts *bind.TransactOpts, _owner common.Address, _overhead *big.Int, ...) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigTransactor) SetBatcherHash(opts *bind.TransactOpts, _batcherHash [32]byte) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigTransactor) SetGasConfig(opts *bind.TransactOpts, _overhead *big.Int, _scalar *big.Int) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigTransactor) SetGasLimit(opts *bind.TransactOpts, _gasLimit uint64) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigTransactor) SetResourceConfig(opts *bind.TransactOpts, _config ResourceMeteringResourceConfig) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigTransactor) SetUnsafeBlockSigner(opts *bind.TransactOpts, _unsafeBlockSigner common.Address) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigTransactor) SetValidatorRewardScalar(opts *bind.TransactOpts, _validatorRewardScalar *big.Int) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type SystemConfigTransactorRaw struct

+ Contract *SystemConfigTransactor

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

+ func (_SystemConfig *SystemConfigTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SystemConfigTransactorSession struct

+ Contract *SystemConfigTransactor

+ TransactOpts bind.TransactOpts

+ func (_SystemConfig *SystemConfigTransactorSession) Initialize(_owner common.Address, _overhead *big.Int, _scalar *big.Int, ...) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigTransactorSession) SetBatcherHash(_batcherHash [32]byte) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigTransactorSession) SetGasConfig(_overhead *big.Int, _scalar *big.Int) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigTransactorSession) SetGasLimit(_gasLimit uint64) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigTransactorSession) SetResourceConfig(_config ResourceMeteringResourceConfig) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigTransactorSession) SetUnsafeBlockSigner(_unsafeBlockSigner common.Address) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigTransactorSession) SetValidatorRewardScalar(_validatorRewardScalar *big.Int) (*types.Transaction, error)

+ func (_SystemConfig *SystemConfigTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type TimeLock struct

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

+ func NewTimeLock(address common.Address, backend bind.ContractBackend) (*TimeLock, error)

+ type TimeLockCallExecuted struct

+ Data []byte

+ Id [32]byte

+ Index *big.Int

+ Raw types.Log

+ Target common.Address

+ Value *big.Int

+ type TimeLockCallExecutedIterator struct

+ Event *TimeLockCallExecuted

+ func (it *TimeLockCallExecutedIterator) Close() error

+ func (it *TimeLockCallExecutedIterator) Error() error

+ func (it *TimeLockCallExecutedIterator) Next() bool

+ type TimeLockCallSalt struct

+ Id [32]byte

+ Raw types.Log

+ Salt [32]byte

+ type TimeLockCallSaltIterator struct

+ Event *TimeLockCallSalt

+ func (it *TimeLockCallSaltIterator) Close() error

+ func (it *TimeLockCallSaltIterator) Error() error

+ func (it *TimeLockCallSaltIterator) Next() bool

+ type TimeLockCallScheduled struct

+ Data []byte

+ Delay *big.Int

+ Id [32]byte

+ Index *big.Int

+ Predecessor [32]byte

+ Raw types.Log

+ Target common.Address

+ Value *big.Int

+ type TimeLockCallScheduledIterator struct

+ Event *TimeLockCallScheduled

+ func (it *TimeLockCallScheduledIterator) Close() error

+ func (it *TimeLockCallScheduledIterator) Error() error

+ func (it *TimeLockCallScheduledIterator) Next() bool

+ type TimeLockCaller struct

+ func NewTimeLockCaller(address common.Address, caller bind.ContractCaller) (*TimeLockCaller, error)

+ func (_TimeLock *TimeLockCaller) CANCELLERROLE(opts *bind.CallOpts) ([32]byte, error)

+ func (_TimeLock *TimeLockCaller) DEFAULTADMINROLE(opts *bind.CallOpts) ([32]byte, error)

+ func (_TimeLock *TimeLockCaller) EXECUTORROLE(opts *bind.CallOpts) ([32]byte, error)

+ func (_TimeLock *TimeLockCaller) GetMinDelay(opts *bind.CallOpts) (*big.Int, error)

+ func (_TimeLock *TimeLockCaller) GetRoleAdmin(opts *bind.CallOpts, role [32]byte) ([32]byte, error)

+ func (_TimeLock *TimeLockCaller) GetTimestamp(opts *bind.CallOpts, id [32]byte) (*big.Int, error)

+ func (_TimeLock *TimeLockCaller) HasRole(opts *bind.CallOpts, role [32]byte, account common.Address) (bool, error)

+ func (_TimeLock *TimeLockCaller) HashOperation(opts *bind.CallOpts, target common.Address, value *big.Int, data []byte, ...) ([32]byte, error)

+ func (_TimeLock *TimeLockCaller) HashOperationBatch(opts *bind.CallOpts, targets []common.Address, values []*big.Int, ...) ([32]byte, error)

+ func (_TimeLock *TimeLockCaller) IsOperation(opts *bind.CallOpts, id [32]byte) (bool, error)

+ func (_TimeLock *TimeLockCaller) IsOperationDone(opts *bind.CallOpts, id [32]byte) (bool, error)

+ func (_TimeLock *TimeLockCaller) IsOperationPending(opts *bind.CallOpts, id [32]byte) (bool, error)

+ func (_TimeLock *TimeLockCaller) IsOperationReady(opts *bind.CallOpts, id [32]byte) (bool, error)

+ func (_TimeLock *TimeLockCaller) PROPOSERROLE(opts *bind.CallOpts) ([32]byte, error)

+ func (_TimeLock *TimeLockCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ func (_TimeLock *TimeLockCaller) TIMELOCKADMINROLE(opts *bind.CallOpts) ([32]byte, error)

+ func (_TimeLock *TimeLockCaller) Version(opts *bind.CallOpts) (string, error)

+ type TimeLockCallerRaw struct

+ Contract *TimeLockCaller

+ func (_TimeLock *TimeLockCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type TimeLockCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *TimeLockCaller

+ func (_TimeLock *TimeLockCallerSession) CANCELLERROLE() ([32]byte, error)

+ func (_TimeLock *TimeLockCallerSession) DEFAULTADMINROLE() ([32]byte, error)

+ func (_TimeLock *TimeLockCallerSession) EXECUTORROLE() ([32]byte, error)

+ func (_TimeLock *TimeLockCallerSession) GetMinDelay() (*big.Int, error)

+ func (_TimeLock *TimeLockCallerSession) GetRoleAdmin(role [32]byte) ([32]byte, error)

+ func (_TimeLock *TimeLockCallerSession) GetTimestamp(id [32]byte) (*big.Int, error)

+ func (_TimeLock *TimeLockCallerSession) HasRole(role [32]byte, account common.Address) (bool, error)

+ func (_TimeLock *TimeLockCallerSession) HashOperation(target common.Address, value *big.Int, data []byte, predecessor [32]byte, ...) ([32]byte, error)

+ func (_TimeLock *TimeLockCallerSession) HashOperationBatch(targets []common.Address, values []*big.Int, payloads [][]byte, ...) ([32]byte, error)

+ func (_TimeLock *TimeLockCallerSession) IsOperation(id [32]byte) (bool, error)

+ func (_TimeLock *TimeLockCallerSession) IsOperationDone(id [32]byte) (bool, error)

+ func (_TimeLock *TimeLockCallerSession) IsOperationPending(id [32]byte) (bool, error)

+ func (_TimeLock *TimeLockCallerSession) IsOperationReady(id [32]byte) (bool, error)

+ func (_TimeLock *TimeLockCallerSession) PROPOSERROLE() ([32]byte, error)

+ func (_TimeLock *TimeLockCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_TimeLock *TimeLockCallerSession) TIMELOCKADMINROLE() ([32]byte, error)

+ func (_TimeLock *TimeLockCallerSession) Version() (string, error)

+ type TimeLockCancelled struct

+ Id [32]byte

+ Raw types.Log

+ type TimeLockCancelledIterator struct

+ Event *TimeLockCancelled

+ func (it *TimeLockCancelledIterator) Close() error

+ func (it *TimeLockCancelledIterator) Error() error

+ func (it *TimeLockCancelledIterator) Next() bool

+ type TimeLockFilterer struct

+ func NewTimeLockFilterer(address common.Address, filterer bind.ContractFilterer) (*TimeLockFilterer, error)

+ func (_TimeLock *TimeLockFilterer) FilterCallExecuted(opts *bind.FilterOpts, id [][32]byte, index []*big.Int) (*TimeLockCallExecutedIterator, error)

+ func (_TimeLock *TimeLockFilterer) FilterCallSalt(opts *bind.FilterOpts, id [][32]byte) (*TimeLockCallSaltIterator, error)

+ func (_TimeLock *TimeLockFilterer) FilterCallScheduled(opts *bind.FilterOpts, id [][32]byte, index []*big.Int) (*TimeLockCallScheduledIterator, error)

+ func (_TimeLock *TimeLockFilterer) FilterCancelled(opts *bind.FilterOpts, id [][32]byte) (*TimeLockCancelledIterator, error)

+ func (_TimeLock *TimeLockFilterer) FilterInitialized(opts *bind.FilterOpts) (*TimeLockInitializedIterator, error)

+ func (_TimeLock *TimeLockFilterer) FilterMinDelayChange(opts *bind.FilterOpts) (*TimeLockMinDelayChangeIterator, error)

+ func (_TimeLock *TimeLockFilterer) FilterRoleAdminChanged(opts *bind.FilterOpts, role [][32]byte, previousAdminRole [][32]byte, ...) (*TimeLockRoleAdminChangedIterator, error)

+ func (_TimeLock *TimeLockFilterer) FilterRoleGranted(opts *bind.FilterOpts, role [][32]byte, account []common.Address, ...) (*TimeLockRoleGrantedIterator, error)

+ func (_TimeLock *TimeLockFilterer) FilterRoleRevoked(opts *bind.FilterOpts, role [][32]byte, account []common.Address, ...) (*TimeLockRoleRevokedIterator, error)

+ func (_TimeLock *TimeLockFilterer) ParseCallExecuted(log types.Log) (*TimeLockCallExecuted, error)

+ func (_TimeLock *TimeLockFilterer) ParseCallSalt(log types.Log) (*TimeLockCallSalt, error)

+ func (_TimeLock *TimeLockFilterer) ParseCallScheduled(log types.Log) (*TimeLockCallScheduled, error)

+ func (_TimeLock *TimeLockFilterer) ParseCancelled(log types.Log) (*TimeLockCancelled, error)

+ func (_TimeLock *TimeLockFilterer) ParseInitialized(log types.Log) (*TimeLockInitialized, error)

+ func (_TimeLock *TimeLockFilterer) ParseMinDelayChange(log types.Log) (*TimeLockMinDelayChange, error)

+ func (_TimeLock *TimeLockFilterer) ParseRoleAdminChanged(log types.Log) (*TimeLockRoleAdminChanged, error)

+ func (_TimeLock *TimeLockFilterer) ParseRoleGranted(log types.Log) (*TimeLockRoleGranted, error)

+ func (_TimeLock *TimeLockFilterer) ParseRoleRevoked(log types.Log) (*TimeLockRoleRevoked, error)

+ func (_TimeLock *TimeLockFilterer) WatchCallExecuted(opts *bind.WatchOpts, sink chan<- *TimeLockCallExecuted, id [][32]byte, ...) (event.Subscription, error)

+ func (_TimeLock *TimeLockFilterer) WatchCallSalt(opts *bind.WatchOpts, sink chan<- *TimeLockCallSalt, id [][32]byte) (event.Subscription, error)

+ func (_TimeLock *TimeLockFilterer) WatchCallScheduled(opts *bind.WatchOpts, sink chan<- *TimeLockCallScheduled, id [][32]byte, ...) (event.Subscription, error)

+ func (_TimeLock *TimeLockFilterer) WatchCancelled(opts *bind.WatchOpts, sink chan<- *TimeLockCancelled, id [][32]byte) (event.Subscription, error)

+ func (_TimeLock *TimeLockFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *TimeLockInitialized) (event.Subscription, error)

+ func (_TimeLock *TimeLockFilterer) WatchMinDelayChange(opts *bind.WatchOpts, sink chan<- *TimeLockMinDelayChange) (event.Subscription, error)

+ func (_TimeLock *TimeLockFilterer) WatchRoleAdminChanged(opts *bind.WatchOpts, sink chan<- *TimeLockRoleAdminChanged, role [][32]byte, ...) (event.Subscription, error)

+ func (_TimeLock *TimeLockFilterer) WatchRoleGranted(opts *bind.WatchOpts, sink chan<- *TimeLockRoleGranted, role [][32]byte, ...) (event.Subscription, error)

+ func (_TimeLock *TimeLockFilterer) WatchRoleRevoked(opts *bind.WatchOpts, sink chan<- *TimeLockRoleRevoked, role [][32]byte, ...) (event.Subscription, error)

+ type TimeLockInitialized struct

+ Raw types.Log

+ Version uint8

+ type TimeLockInitializedIterator struct

+ Event *TimeLockInitialized

+ func (it *TimeLockInitializedIterator) Close() error

+ func (it *TimeLockInitializedIterator) Error() error

+ func (it *TimeLockInitializedIterator) Next() bool

+ type TimeLockMinDelayChange struct

+ NewDuration *big.Int

+ OldDuration *big.Int

+ Raw types.Log

+ type TimeLockMinDelayChangeIterator struct

+ Event *TimeLockMinDelayChange

+ func (it *TimeLockMinDelayChangeIterator) Close() error

+ func (it *TimeLockMinDelayChangeIterator) Error() error

+ func (it *TimeLockMinDelayChangeIterator) Next() bool

+ type TimeLockRaw struct

+ Contract *TimeLock

+ func (_TimeLock *TimeLockRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_TimeLock *TimeLockRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type TimeLockRoleAdminChanged struct

+ NewAdminRole [32]byte

+ PreviousAdminRole [32]byte

+ Raw types.Log

+ Role [32]byte

+ type TimeLockRoleAdminChangedIterator struct

+ Event *TimeLockRoleAdminChanged

+ func (it *TimeLockRoleAdminChangedIterator) Close() error

+ func (it *TimeLockRoleAdminChangedIterator) Error() error

+ func (it *TimeLockRoleAdminChangedIterator) Next() bool

+ type TimeLockRoleGranted struct

+ Account common.Address

+ Raw types.Log

+ Role [32]byte

+ Sender common.Address

+ type TimeLockRoleGrantedIterator struct

+ Event *TimeLockRoleGranted

+ func (it *TimeLockRoleGrantedIterator) Close() error

+ func (it *TimeLockRoleGrantedIterator) Error() error

+ func (it *TimeLockRoleGrantedIterator) Next() bool

+ type TimeLockRoleRevoked struct

+ Account common.Address

+ Raw types.Log

+ Role [32]byte

+ Sender common.Address

+ type TimeLockRoleRevokedIterator struct

+ Event *TimeLockRoleRevoked

+ func (it *TimeLockRoleRevokedIterator) Close() error

+ func (it *TimeLockRoleRevokedIterator) Error() error

+ func (it *TimeLockRoleRevokedIterator) Next() bool

+ type TimeLockSession struct

+ CallOpts bind.CallOpts

+ Contract *TimeLock

+ TransactOpts bind.TransactOpts

+ func (_TimeLock *TimeLockSession) CANCELLERROLE() ([32]byte, error)

+ func (_TimeLock *TimeLockSession) Cancel(id [32]byte) (*types.Transaction, error)

+ func (_TimeLock *TimeLockSession) DEFAULTADMINROLE() ([32]byte, error)

+ func (_TimeLock *TimeLockSession) EXECUTORROLE() ([32]byte, error)

+ func (_TimeLock *TimeLockSession) Execute(target common.Address, value *big.Int, payload []byte, predecessor [32]byte, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockSession) ExecuteBatch(targets []common.Address, values []*big.Int, payloads [][]byte, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockSession) GetMinDelay() (*big.Int, error)

+ func (_TimeLock *TimeLockSession) GetRoleAdmin(role [32]byte) ([32]byte, error)

+ func (_TimeLock *TimeLockSession) GetTimestamp(id [32]byte) (*big.Int, error)

+ func (_TimeLock *TimeLockSession) GrantRole(role [32]byte, account common.Address) (*types.Transaction, error)

+ func (_TimeLock *TimeLockSession) HasRole(role [32]byte, account common.Address) (bool, error)

+ func (_TimeLock *TimeLockSession) HashOperation(target common.Address, value *big.Int, data []byte, predecessor [32]byte, ...) ([32]byte, error)

+ func (_TimeLock *TimeLockSession) HashOperationBatch(targets []common.Address, values []*big.Int, payloads [][]byte, ...) ([32]byte, error)

+ func (_TimeLock *TimeLockSession) Initialize(_minDelay *big.Int, _proposers []common.Address, _executors []common.Address, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockSession) IsOperation(id [32]byte) (bool, error)

+ func (_TimeLock *TimeLockSession) IsOperationDone(id [32]byte) (bool, error)

+ func (_TimeLock *TimeLockSession) IsOperationPending(id [32]byte) (bool, error)

+ func (_TimeLock *TimeLockSession) IsOperationReady(id [32]byte) (bool, error)

+ func (_TimeLock *TimeLockSession) OnERC1155BatchReceived(arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockSession) OnERC1155Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockSession) OnERC721Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 []byte) (*types.Transaction, error)

+ func (_TimeLock *TimeLockSession) PROPOSERROLE() ([32]byte, error)

+ func (_TimeLock *TimeLockSession) Receive() (*types.Transaction, error)

+ func (_TimeLock *TimeLockSession) RenounceRole(role [32]byte, account common.Address) (*types.Transaction, error)

+ func (_TimeLock *TimeLockSession) RevokeRole(role [32]byte, account common.Address) (*types.Transaction, error)

+ func (_TimeLock *TimeLockSession) Schedule(target common.Address, value *big.Int, data []byte, predecessor [32]byte, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockSession) ScheduleBatch(targets []common.Address, values []*big.Int, payloads [][]byte, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_TimeLock *TimeLockSession) TIMELOCKADMINROLE() ([32]byte, error)

+ func (_TimeLock *TimeLockSession) UpdateDelay(newDelay *big.Int) (*types.Transaction, error)

+ func (_TimeLock *TimeLockSession) Version() (string, error)

+ type TimeLockTransactor struct

+ func NewTimeLockTransactor(address common.Address, transactor bind.ContractTransactor) (*TimeLockTransactor, error)

+ func (_TimeLock *TimeLockTransactor) Cancel(opts *bind.TransactOpts, id [32]byte) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactor) Execute(opts *bind.TransactOpts, target common.Address, value *big.Int, payload []byte, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactor) ExecuteBatch(opts *bind.TransactOpts, targets []common.Address, values []*big.Int, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactor) GrantRole(opts *bind.TransactOpts, role [32]byte, account common.Address) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactor) Initialize(opts *bind.TransactOpts, _minDelay *big.Int, _proposers []common.Address, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactor) OnERC1155BatchReceived(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactor) OnERC1155Received(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactor) OnERC721Received(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactor) RenounceRole(opts *bind.TransactOpts, role [32]byte, account common.Address) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactor) RevokeRole(opts *bind.TransactOpts, role [32]byte, account common.Address) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactor) Schedule(opts *bind.TransactOpts, target common.Address, value *big.Int, data []byte, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactor) ScheduleBatch(opts *bind.TransactOpts, targets []common.Address, values []*big.Int, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactor) UpdateDelay(opts *bind.TransactOpts, newDelay *big.Int) (*types.Transaction, error)

+ type TimeLockTransactorRaw struct

+ Contract *TimeLockTransactor

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

+ func (_TimeLock *TimeLockTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type TimeLockTransactorSession struct

+ Contract *TimeLockTransactor

+ TransactOpts bind.TransactOpts

+ func (_TimeLock *TimeLockTransactorSession) Cancel(id [32]byte) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactorSession) Execute(target common.Address, value *big.Int, payload []byte, predecessor [32]byte, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactorSession) ExecuteBatch(targets []common.Address, values []*big.Int, payloads [][]byte, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactorSession) GrantRole(role [32]byte, account common.Address) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactorSession) Initialize(_minDelay *big.Int, _proposers []common.Address, _executors []common.Address, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactorSession) OnERC1155BatchReceived(arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactorSession) OnERC1155Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactorSession) OnERC721Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 []byte) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactorSession) Receive() (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactorSession) RenounceRole(role [32]byte, account common.Address) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactorSession) RevokeRole(role [32]byte, account common.Address) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactorSession) Schedule(target common.Address, value *big.Int, data []byte, predecessor [32]byte, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactorSession) ScheduleBatch(targets []common.Address, values []*big.Int, payloads [][]byte, ...) (*types.Transaction, error)

+ func (_TimeLock *TimeLockTransactorSession) UpdateDelay(newDelay *big.Int) (*types.Transaction, error)

+ type TypesBlockHeaderRLP struct

+ Coinbase []byte

+ Difficulty []byte

+ ExtraData []byte

+ GasUsed []byte

+ LogsBloom []byte

+ MixHash []byte

+ Nonce []byte

+ ReceiptsRoot []byte

+ UncleHash []byte

+ type TypesBond struct

+ Amount *big.Int

+ ExpiresAt *big.Int

+ type TypesChallenge struct

+ Asserter common.Address

+ Challenger common.Address

+ SegSize *big.Int

+ SegStart *big.Int

+ Segments [][32]byte

+ TimeoutAt uint64

+ Turn uint8

+ type TypesCheckpointOutput struct

+ L2BlockNumber *big.Int

+ OutputRoot [32]byte

+ Submitter common.Address

+ Timestamp *big.Int

+ type TypesOutputRootProof struct

+ BlockHash [32]byte

+ MessagePasserStorageRoot [32]byte

+ NextBlockHash [32]byte

+ StateRoot [32]byte

+ Version [32]byte

+ type TypesPublicInput struct

+ BaseFee *big.Int

+ BlockHash [32]byte

+ GasLimit uint64

+ Number uint64

+ ParentHash [32]byte

+ StateRoot [32]byte

+ Timestamp uint64

+ TransactionsRoot [32]byte

+ TxHashes [][32]byte

+ WithdrawalsRoot [32]byte

+ type TypesPublicInputProof struct

+ DstOutputRootProof TypesOutputRootProof

+ L2ToL1MessagePasserBalance [32]byte

+ L2ToL1MessagePasserCodeHash [32]byte

+ MerkleProof [][]byte

+ PublicInput TypesPublicInput

+ Rlps TypesBlockHeaderRLP

+ SrcOutputRootProof TypesOutputRootProof

+ type TypesWithdrawalTransaction struct

+ Data []byte

+ GasLimit *big.Int

+ Nonce *big.Int

+ Sender common.Address

+ Target common.Address

+ Value *big.Int

+ type UpgradeGovernor struct

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

+ func NewUpgradeGovernor(address common.Address, backend bind.ContractBackend) (*UpgradeGovernor, error)

+ type UpgradeGovernorCaller struct

+ func NewUpgradeGovernorCaller(address common.Address, caller bind.ContractCaller) (*UpgradeGovernorCaller, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) BALLOTTYPEHASH(opts *bind.CallOpts) ([32]byte, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) CLOCKMODE(opts *bind.CallOpts) (string, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) COUNTINGMODE(opts *bind.CallOpts) (string, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) Clock(opts *bind.CallOpts) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) EXTENDEDBALLOTTYPEHASH(opts *bind.CallOpts) ([32]byte, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) Eip712Domain(opts *bind.CallOpts) (struct{ ... }, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) GetVotes(opts *bind.CallOpts, account common.Address, timepoint *big.Int) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) GetVotesWithParams(opts *bind.CallOpts, account common.Address, timepoint *big.Int, params []byte) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) HasVoted(opts *bind.CallOpts, proposalId *big.Int, account common.Address) (bool, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) HashProposal(opts *bind.CallOpts, targets []common.Address, values []*big.Int, ...) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) ProposalDeadline(opts *bind.CallOpts, proposalId *big.Int) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) ProposalEta(opts *bind.CallOpts, proposalId *big.Int) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) ProposalProposer(opts *bind.CallOpts, proposalId *big.Int) (common.Address, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) ProposalSnapshot(opts *bind.CallOpts, proposalId *big.Int) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) ProposalThreshold(opts *bind.CallOpts) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) ProposalVotes(opts *bind.CallOpts, proposalId *big.Int) (struct{ ... }, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) Quorum(opts *bind.CallOpts, blockNumber *big.Int) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) QuorumDenominator(opts *bind.CallOpts) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) QuorumNumerator(opts *bind.CallOpts, timepoint *big.Int) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) QuorumNumerator0(opts *bind.CallOpts) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) State(opts *bind.CallOpts, proposalId *big.Int) (uint8, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) Timelock(opts *bind.CallOpts) (common.Address, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) Token(opts *bind.CallOpts) (common.Address, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) Version(opts *bind.CallOpts) (string, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) VotingDelay(opts *bind.CallOpts) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCaller) VotingPeriod(opts *bind.CallOpts) (*big.Int, error)

+ type UpgradeGovernorCallerRaw struct

+ Contract *UpgradeGovernorCaller

+ func (_UpgradeGovernor *UpgradeGovernorCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type UpgradeGovernorCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *UpgradeGovernorCaller

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) BALLOTTYPEHASH() ([32]byte, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) CLOCKMODE() (string, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) COUNTINGMODE() (string, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) Clock() (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) EXTENDEDBALLOTTYPEHASH() ([32]byte, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) Eip712Domain() (struct{ ... }, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) GetVotes(account common.Address, timepoint *big.Int) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) GetVotesWithParams(account common.Address, timepoint *big.Int, params []byte) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) HasVoted(proposalId *big.Int, account common.Address) (bool, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) HashProposal(targets []common.Address, values []*big.Int, calldatas [][]byte, ...) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) Name() (string, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) ProposalDeadline(proposalId *big.Int) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) ProposalEta(proposalId *big.Int) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) ProposalProposer(proposalId *big.Int) (common.Address, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) ProposalSnapshot(proposalId *big.Int) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) ProposalThreshold() (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) ProposalVotes(proposalId *big.Int) (struct{ ... }, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) Quorum(blockNumber *big.Int) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) QuorumDenominator() (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) QuorumNumerator(timepoint *big.Int) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) QuorumNumerator0() (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) State(proposalId *big.Int) (uint8, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) Timelock() (common.Address, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) Token() (common.Address, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) Version() (string, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) VotingDelay() (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorCallerSession) VotingPeriod() (*big.Int, error)

+ type UpgradeGovernorEIP712DomainChanged struct

+ Raw types.Log

+ type UpgradeGovernorEIP712DomainChangedIterator struct

+ Event *UpgradeGovernorEIP712DomainChanged

+ func (it *UpgradeGovernorEIP712DomainChangedIterator) Close() error

+ func (it *UpgradeGovernorEIP712DomainChangedIterator) Error() error

+ func (it *UpgradeGovernorEIP712DomainChangedIterator) Next() bool

+ type UpgradeGovernorFilterer struct

+ func NewUpgradeGovernorFilterer(address common.Address, filterer bind.ContractFilterer) (*UpgradeGovernorFilterer, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) FilterEIP712DomainChanged(opts *bind.FilterOpts) (*UpgradeGovernorEIP712DomainChangedIterator, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) FilterInitialized(opts *bind.FilterOpts) (*UpgradeGovernorInitializedIterator, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) FilterProposalCanceled(opts *bind.FilterOpts) (*UpgradeGovernorProposalCanceledIterator, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) FilterProposalCreated(opts *bind.FilterOpts) (*UpgradeGovernorProposalCreatedIterator, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) FilterProposalExecuted(opts *bind.FilterOpts) (*UpgradeGovernorProposalExecutedIterator, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) FilterProposalQueued(opts *bind.FilterOpts) (*UpgradeGovernorProposalQueuedIterator, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) FilterProposalThresholdSet(opts *bind.FilterOpts) (*UpgradeGovernorProposalThresholdSetIterator, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) FilterQuorumNumeratorUpdated(opts *bind.FilterOpts) (*UpgradeGovernorQuorumNumeratorUpdatedIterator, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) FilterTimelockChange(opts *bind.FilterOpts) (*UpgradeGovernorTimelockChangeIterator, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) FilterVoteCast(opts *bind.FilterOpts, voter []common.Address) (*UpgradeGovernorVoteCastIterator, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) FilterVoteCastWithParams(opts *bind.FilterOpts, voter []common.Address) (*UpgradeGovernorVoteCastWithParamsIterator, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) FilterVotingDelaySet(opts *bind.FilterOpts) (*UpgradeGovernorVotingDelaySetIterator, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) FilterVotingPeriodSet(opts *bind.FilterOpts) (*UpgradeGovernorVotingPeriodSetIterator, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) ParseEIP712DomainChanged(log types.Log) (*UpgradeGovernorEIP712DomainChanged, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) ParseInitialized(log types.Log) (*UpgradeGovernorInitialized, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) ParseProposalCanceled(log types.Log) (*UpgradeGovernorProposalCanceled, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) ParseProposalCreated(log types.Log) (*UpgradeGovernorProposalCreated, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) ParseProposalExecuted(log types.Log) (*UpgradeGovernorProposalExecuted, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) ParseProposalQueued(log types.Log) (*UpgradeGovernorProposalQueued, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) ParseProposalThresholdSet(log types.Log) (*UpgradeGovernorProposalThresholdSet, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) ParseQuorumNumeratorUpdated(log types.Log) (*UpgradeGovernorQuorumNumeratorUpdated, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) ParseTimelockChange(log types.Log) (*UpgradeGovernorTimelockChange, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) ParseVoteCast(log types.Log) (*UpgradeGovernorVoteCast, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) ParseVoteCastWithParams(log types.Log) (*UpgradeGovernorVoteCastWithParams, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) ParseVotingDelaySet(log types.Log) (*UpgradeGovernorVotingDelaySet, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) ParseVotingPeriodSet(log types.Log) (*UpgradeGovernorVotingPeriodSet, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) WatchEIP712DomainChanged(opts *bind.WatchOpts, sink chan<- *UpgradeGovernorEIP712DomainChanged) (event.Subscription, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *UpgradeGovernorInitialized) (event.Subscription, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) WatchProposalCanceled(opts *bind.WatchOpts, sink chan<- *UpgradeGovernorProposalCanceled) (event.Subscription, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) WatchProposalCreated(opts *bind.WatchOpts, sink chan<- *UpgradeGovernorProposalCreated) (event.Subscription, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) WatchProposalExecuted(opts *bind.WatchOpts, sink chan<- *UpgradeGovernorProposalExecuted) (event.Subscription, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) WatchProposalQueued(opts *bind.WatchOpts, sink chan<- *UpgradeGovernorProposalQueued) (event.Subscription, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) WatchProposalThresholdSet(opts *bind.WatchOpts, sink chan<- *UpgradeGovernorProposalThresholdSet) (event.Subscription, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) WatchQuorumNumeratorUpdated(opts *bind.WatchOpts, sink chan<- *UpgradeGovernorQuorumNumeratorUpdated) (event.Subscription, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) WatchTimelockChange(opts *bind.WatchOpts, sink chan<- *UpgradeGovernorTimelockChange) (event.Subscription, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) WatchVoteCast(opts *bind.WatchOpts, sink chan<- *UpgradeGovernorVoteCast, ...) (event.Subscription, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) WatchVoteCastWithParams(opts *bind.WatchOpts, sink chan<- *UpgradeGovernorVoteCastWithParams, ...) (event.Subscription, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) WatchVotingDelaySet(opts *bind.WatchOpts, sink chan<- *UpgradeGovernorVotingDelaySet) (event.Subscription, error)

+ func (_UpgradeGovernor *UpgradeGovernorFilterer) WatchVotingPeriodSet(opts *bind.WatchOpts, sink chan<- *UpgradeGovernorVotingPeriodSet) (event.Subscription, error)

+ type UpgradeGovernorInitialized struct

+ Raw types.Log

+ Version uint8

+ type UpgradeGovernorInitializedIterator struct

+ Event *UpgradeGovernorInitialized

+ func (it *UpgradeGovernorInitializedIterator) Close() error

+ func (it *UpgradeGovernorInitializedIterator) Error() error

+ func (it *UpgradeGovernorInitializedIterator) Next() bool

+ type UpgradeGovernorProposalCanceled struct

+ ProposalId *big.Int

+ Raw types.Log

+ type UpgradeGovernorProposalCanceledIterator struct

+ Event *UpgradeGovernorProposalCanceled

+ func (it *UpgradeGovernorProposalCanceledIterator) Close() error

+ func (it *UpgradeGovernorProposalCanceledIterator) Error() error

+ func (it *UpgradeGovernorProposalCanceledIterator) Next() bool

+ type UpgradeGovernorProposalCreated struct

+ Calldatas [][]byte

+ Description string

+ ProposalId *big.Int

+ Proposer common.Address

+ Raw types.Log

+ Signatures []string

+ Targets []common.Address

+ Values []*big.Int

+ VoteEnd *big.Int

+ VoteStart *big.Int

+ type UpgradeGovernorProposalCreatedIterator struct

+ Event *UpgradeGovernorProposalCreated

+ func (it *UpgradeGovernorProposalCreatedIterator) Close() error

+ func (it *UpgradeGovernorProposalCreatedIterator) Error() error

+ func (it *UpgradeGovernorProposalCreatedIterator) Next() bool

+ type UpgradeGovernorProposalExecuted struct

+ ProposalId *big.Int

+ Raw types.Log

+ type UpgradeGovernorProposalExecutedIterator struct

+ Event *UpgradeGovernorProposalExecuted

+ func (it *UpgradeGovernorProposalExecutedIterator) Close() error

+ func (it *UpgradeGovernorProposalExecutedIterator) Error() error

+ func (it *UpgradeGovernorProposalExecutedIterator) Next() bool

+ type UpgradeGovernorProposalQueued struct

+ Eta *big.Int

+ ProposalId *big.Int

+ Raw types.Log

+ type UpgradeGovernorProposalQueuedIterator struct

+ Event *UpgradeGovernorProposalQueued

+ func (it *UpgradeGovernorProposalQueuedIterator) Close() error

+ func (it *UpgradeGovernorProposalQueuedIterator) Error() error

+ func (it *UpgradeGovernorProposalQueuedIterator) Next() bool

+ type UpgradeGovernorProposalThresholdSet struct

+ NewProposalThreshold *big.Int

+ OldProposalThreshold *big.Int

+ Raw types.Log

+ type UpgradeGovernorProposalThresholdSetIterator struct

+ Event *UpgradeGovernorProposalThresholdSet

+ func (it *UpgradeGovernorProposalThresholdSetIterator) Close() error

+ func (it *UpgradeGovernorProposalThresholdSetIterator) Error() error

+ func (it *UpgradeGovernorProposalThresholdSetIterator) Next() bool

+ type UpgradeGovernorQuorumNumeratorUpdated struct

+ NewQuorumNumerator *big.Int

+ OldQuorumNumerator *big.Int

+ Raw types.Log

+ type UpgradeGovernorQuorumNumeratorUpdatedIterator struct

+ Event *UpgradeGovernorQuorumNumeratorUpdated

+ func (it *UpgradeGovernorQuorumNumeratorUpdatedIterator) Close() error

+ func (it *UpgradeGovernorQuorumNumeratorUpdatedIterator) Error() error

+ func (it *UpgradeGovernorQuorumNumeratorUpdatedIterator) Next() bool

+ type UpgradeGovernorRaw struct

+ Contract *UpgradeGovernor

+ func (_UpgradeGovernor *UpgradeGovernorRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_UpgradeGovernor *UpgradeGovernorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type UpgradeGovernorSession struct

+ CallOpts bind.CallOpts

+ Contract *UpgradeGovernor

+ TransactOpts bind.TransactOpts

+ func (_UpgradeGovernor *UpgradeGovernorSession) BALLOTTYPEHASH() ([32]byte, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) CLOCKMODE() (string, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) COUNTINGMODE() (string, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) Cancel(targets []common.Address, values []*big.Int, calldatas [][]byte, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) CastVote(proposalId *big.Int, support uint8) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) CastVoteBySig(proposalId *big.Int, support uint8, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) CastVoteWithReason(proposalId *big.Int, support uint8, reason string) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) CastVoteWithReasonAndParams(proposalId *big.Int, support uint8, reason string, params []byte) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) CastVoteWithReasonAndParamsBySig(proposalId *big.Int, support uint8, reason string, params []byte, v uint8, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) Clock() (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) EXTENDEDBALLOTTYPEHASH() ([32]byte, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) Eip712Domain() (struct{ ... }, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) Execute(targets []common.Address, values []*big.Int, calldatas [][]byte, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) GetVotes(account common.Address, timepoint *big.Int) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) GetVotesWithParams(account common.Address, timepoint *big.Int, params []byte) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) HasVoted(proposalId *big.Int, account common.Address) (bool, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) HashProposal(targets []common.Address, values []*big.Int, calldatas [][]byte, ...) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) Initialize(_token common.Address, _timelock common.Address, _initialVotingDelay *big.Int, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) Name() (string, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) OnERC1155BatchReceived(arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) OnERC1155Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) OnERC721Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 []byte) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) ProposalDeadline(proposalId *big.Int) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) ProposalEta(proposalId *big.Int) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) ProposalProposer(proposalId *big.Int) (common.Address, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) ProposalSnapshot(proposalId *big.Int) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) ProposalThreshold() (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) ProposalVotes(proposalId *big.Int) (struct{ ... }, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) Propose(targets []common.Address, values []*big.Int, calldatas [][]byte, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) Queue(targets []common.Address, values []*big.Int, calldatas [][]byte, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) Quorum(blockNumber *big.Int) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) QuorumDenominator() (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) QuorumNumerator(timepoint *big.Int) (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) QuorumNumerator0() (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) Receive() (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) Relay(target common.Address, value *big.Int, data []byte) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) SetProposalThreshold(newProposalThreshold *big.Int) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) SetVotingDelay(newVotingDelay *big.Int) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) SetVotingPeriod(newVotingPeriod *big.Int) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) State(proposalId *big.Int) (uint8, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) Timelock() (common.Address, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) Token() (common.Address, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) UpdateQuorumNumerator(newQuorumNumerator *big.Int) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) UpdateTimelock(newTimelock common.Address) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) Version() (string, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) VotingDelay() (*big.Int, error)

+ func (_UpgradeGovernor *UpgradeGovernorSession) VotingPeriod() (*big.Int, error)

+ type UpgradeGovernorTimelockChange struct

+ NewTimelock common.Address

+ OldTimelock common.Address

+ Raw types.Log

+ type UpgradeGovernorTimelockChangeIterator struct

+ Event *UpgradeGovernorTimelockChange

+ func (it *UpgradeGovernorTimelockChangeIterator) Close() error

+ func (it *UpgradeGovernorTimelockChangeIterator) Error() error

+ func (it *UpgradeGovernorTimelockChangeIterator) Next() bool

+ type UpgradeGovernorTransactor struct

+ func NewUpgradeGovernorTransactor(address common.Address, transactor bind.ContractTransactor) (*UpgradeGovernorTransactor, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactor) Cancel(opts *bind.TransactOpts, targets []common.Address, values []*big.Int, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactor) CastVote(opts *bind.TransactOpts, proposalId *big.Int, support uint8) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactor) CastVoteBySig(opts *bind.TransactOpts, proposalId *big.Int, support uint8, v uint8, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactor) CastVoteWithReason(opts *bind.TransactOpts, proposalId *big.Int, support uint8, reason string) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactor) CastVoteWithReasonAndParams(opts *bind.TransactOpts, proposalId *big.Int, support uint8, reason string, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactor) CastVoteWithReasonAndParamsBySig(opts *bind.TransactOpts, proposalId *big.Int, support uint8, reason string, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactor) Execute(opts *bind.TransactOpts, targets []common.Address, values []*big.Int, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactor) Initialize(opts *bind.TransactOpts, _token common.Address, _timelock common.Address, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactor) OnERC1155BatchReceived(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactor) OnERC1155Received(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactor) OnERC721Received(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactor) Propose(opts *bind.TransactOpts, targets []common.Address, values []*big.Int, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactor) Queue(opts *bind.TransactOpts, targets []common.Address, values []*big.Int, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactor) Relay(opts *bind.TransactOpts, target common.Address, value *big.Int, data []byte) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactor) SetProposalThreshold(opts *bind.TransactOpts, newProposalThreshold *big.Int) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactor) SetVotingDelay(opts *bind.TransactOpts, newVotingDelay *big.Int) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactor) SetVotingPeriod(opts *bind.TransactOpts, newVotingPeriod *big.Int) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactor) UpdateQuorumNumerator(opts *bind.TransactOpts, newQuorumNumerator *big.Int) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactor) UpdateTimelock(opts *bind.TransactOpts, newTimelock common.Address) (*types.Transaction, error)

+ type UpgradeGovernorTransactorRaw struct

+ Contract *UpgradeGovernorTransactor

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

+ func (_UpgradeGovernor *UpgradeGovernorTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type UpgradeGovernorTransactorSession struct

+ Contract *UpgradeGovernorTransactor

+ TransactOpts bind.TransactOpts

+ func (_UpgradeGovernor *UpgradeGovernorTransactorSession) Cancel(targets []common.Address, values []*big.Int, calldatas [][]byte, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactorSession) CastVote(proposalId *big.Int, support uint8) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactorSession) CastVoteBySig(proposalId *big.Int, support uint8, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactorSession) CastVoteWithReason(proposalId *big.Int, support uint8, reason string) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactorSession) CastVoteWithReasonAndParams(proposalId *big.Int, support uint8, reason string, params []byte) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactorSession) CastVoteWithReasonAndParamsBySig(proposalId *big.Int, support uint8, reason string, params []byte, v uint8, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactorSession) Execute(targets []common.Address, values []*big.Int, calldatas [][]byte, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactorSession) Initialize(_token common.Address, _timelock common.Address, _initialVotingDelay *big.Int, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactorSession) OnERC1155BatchReceived(arg0 common.Address, arg1 common.Address, arg2 []*big.Int, arg3 []*big.Int, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactorSession) OnERC1155Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactorSession) OnERC721Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 []byte) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactorSession) Propose(targets []common.Address, values []*big.Int, calldatas [][]byte, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactorSession) Queue(targets []common.Address, values []*big.Int, calldatas [][]byte, ...) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactorSession) Receive() (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactorSession) Relay(target common.Address, value *big.Int, data []byte) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactorSession) SetProposalThreshold(newProposalThreshold *big.Int) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactorSession) SetVotingDelay(newVotingDelay *big.Int) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactorSession) SetVotingPeriod(newVotingPeriod *big.Int) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactorSession) UpdateQuorumNumerator(newQuorumNumerator *big.Int) (*types.Transaction, error)

+ func (_UpgradeGovernor *UpgradeGovernorTransactorSession) UpdateTimelock(newTimelock common.Address) (*types.Transaction, error)

+ type UpgradeGovernorVoteCast struct

+ ProposalId *big.Int

+ Raw types.Log

+ Reason string

+ Support uint8

+ Voter common.Address

+ Weight *big.Int

+ type UpgradeGovernorVoteCastIterator struct

+ Event *UpgradeGovernorVoteCast

+ func (it *UpgradeGovernorVoteCastIterator) Close() error

+ func (it *UpgradeGovernorVoteCastIterator) Error() error

+ func (it *UpgradeGovernorVoteCastIterator) Next() bool

+ type UpgradeGovernorVoteCastWithParams struct

+ Params []byte

+ ProposalId *big.Int

+ Raw types.Log

+ Reason string

+ Support uint8

+ Voter common.Address

+ Weight *big.Int

+ type UpgradeGovernorVoteCastWithParamsIterator struct

+ Event *UpgradeGovernorVoteCastWithParams

+ func (it *UpgradeGovernorVoteCastWithParamsIterator) Close() error

+ func (it *UpgradeGovernorVoteCastWithParamsIterator) Error() error

+ func (it *UpgradeGovernorVoteCastWithParamsIterator) Next() bool

+ type UpgradeGovernorVotingDelaySet struct

+ NewVotingDelay *big.Int

+ OldVotingDelay *big.Int

+ Raw types.Log

+ type UpgradeGovernorVotingDelaySetIterator struct

+ Event *UpgradeGovernorVotingDelaySet

+ func (it *UpgradeGovernorVotingDelaySetIterator) Close() error

+ func (it *UpgradeGovernorVotingDelaySetIterator) Error() error

+ func (it *UpgradeGovernorVotingDelaySetIterator) Next() bool

+ type UpgradeGovernorVotingPeriodSet struct

+ NewVotingPeriod *big.Int

+ OldVotingPeriod *big.Int

+ Raw types.Log

+ type UpgradeGovernorVotingPeriodSetIterator struct

+ Event *UpgradeGovernorVotingPeriodSet

+ func (it *UpgradeGovernorVotingPeriodSetIterator) Close() error

+ func (it *UpgradeGovernorVotingPeriodSetIterator) Error() error

+ func (it *UpgradeGovernorVotingPeriodSetIterator) Next() bool

+ type ValidatorPool struct

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

+ func NewValidatorPool(address common.Address, backend bind.ContractBackend) (*ValidatorPool, error)

+ type ValidatorPoolBondIncreased struct

+ Amount *big.Int

+ Challenger common.Address

+ OutputIndex *big.Int

+ Raw types.Log

+ type ValidatorPoolBondIncreasedIterator struct

+ Event *ValidatorPoolBondIncreased

+ func (it *ValidatorPoolBondIncreasedIterator) Close() error

+ func (it *ValidatorPoolBondIncreasedIterator) Error() error

+ func (it *ValidatorPoolBondIncreasedIterator) Next() bool

+ type ValidatorPoolBonded struct

+ Amount *big.Int

+ ExpiresAt *big.Int

+ OutputIndex *big.Int

+ Raw types.Log

+ Submitter common.Address

+ type ValidatorPoolBondedIterator struct

+ Event *ValidatorPoolBonded

+ func (it *ValidatorPoolBondedIterator) Close() error

+ func (it *ValidatorPoolBondedIterator) Error() error

+ func (it *ValidatorPoolBondedIterator) Next() bool

+ type ValidatorPoolCaller struct

+ func NewValidatorPoolCaller(address common.Address, caller bind.ContractCaller) (*ValidatorPoolCaller, error)

+ func (_ValidatorPool *ValidatorPoolCaller) BalanceOf(opts *bind.CallOpts, _addr common.Address) (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolCaller) GetBond(opts *bind.CallOpts, _outputIndex *big.Int) (TypesBond, error)

+ func (_ValidatorPool *ValidatorPoolCaller) GetPendingBond(opts *bind.CallOpts, _outputIndex *big.Int, _challenger common.Address) (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolCaller) IsValidator(opts *bind.CallOpts, _addr common.Address) (bool, error)

+ func (_ValidatorPool *ValidatorPoolCaller) L2ORACLE(opts *bind.CallOpts) (common.Address, error)

+ func (_ValidatorPool *ValidatorPoolCaller) MAXUNBOND(opts *bind.CallOpts) (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolCaller) NextValidator(opts *bind.CallOpts) (common.Address, error)

+ func (_ValidatorPool *ValidatorPoolCaller) PORTAL(opts *bind.CallOpts) (common.Address, error)

+ func (_ValidatorPool *ValidatorPoolCaller) REQUIREDBONDAMOUNT(opts *bind.CallOpts) (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolCaller) ROUNDDURATION(opts *bind.CallOpts) (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolCaller) SECURITYCOUNCIL(opts *bind.CallOpts) (common.Address, error)

+ func (_ValidatorPool *ValidatorPoolCaller) TAXDENOMINATOR(opts *bind.CallOpts) (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolCaller) TAXNUMERATOR(opts *bind.CallOpts) (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolCaller) TRUSTEDVALIDATOR(opts *bind.CallOpts) (common.Address, error)

+ func (_ValidatorPool *ValidatorPoolCaller) VAULTREWARDGASLIMIT(opts *bind.CallOpts) (uint64, error)

+ func (_ValidatorPool *ValidatorPoolCaller) ValidatorCount(opts *bind.CallOpts) (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolCaller) Version(opts *bind.CallOpts) (string, error)

+ type ValidatorPoolCallerRaw struct

+ Contract *ValidatorPoolCaller

+ func (_ValidatorPool *ValidatorPoolCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type ValidatorPoolCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ValidatorPoolCaller

+ func (_ValidatorPool *ValidatorPoolCallerSession) BalanceOf(_addr common.Address) (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolCallerSession) GetBond(_outputIndex *big.Int) (TypesBond, error)

+ func (_ValidatorPool *ValidatorPoolCallerSession) GetPendingBond(_outputIndex *big.Int, _challenger common.Address) (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolCallerSession) IsValidator(_addr common.Address) (bool, error)

+ func (_ValidatorPool *ValidatorPoolCallerSession) L2ORACLE() (common.Address, error)

+ func (_ValidatorPool *ValidatorPoolCallerSession) MAXUNBOND() (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolCallerSession) NextValidator() (common.Address, error)

+ func (_ValidatorPool *ValidatorPoolCallerSession) PORTAL() (common.Address, error)

+ func (_ValidatorPool *ValidatorPoolCallerSession) REQUIREDBONDAMOUNT() (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolCallerSession) ROUNDDURATION() (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolCallerSession) SECURITYCOUNCIL() (common.Address, error)

+ func (_ValidatorPool *ValidatorPoolCallerSession) TAXDENOMINATOR() (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolCallerSession) TAXNUMERATOR() (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolCallerSession) TRUSTEDVALIDATOR() (common.Address, error)

+ func (_ValidatorPool *ValidatorPoolCallerSession) VAULTREWARDGASLIMIT() (uint64, error)

+ func (_ValidatorPool *ValidatorPoolCallerSession) ValidatorCount() (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolCallerSession) Version() (string, error)

+ type ValidatorPoolFilterer struct

+ func NewValidatorPoolFilterer(address common.Address, filterer bind.ContractFilterer) (*ValidatorPoolFilterer, error)

+ func (_ValidatorPool *ValidatorPoolFilterer) FilterBondIncreased(opts *bind.FilterOpts, outputIndex []*big.Int, challenger []common.Address) (*ValidatorPoolBondIncreasedIterator, error)

+ func (_ValidatorPool *ValidatorPoolFilterer) FilterBonded(opts *bind.FilterOpts, submitter []common.Address, outputIndex []*big.Int) (*ValidatorPoolBondedIterator, error)

+ func (_ValidatorPool *ValidatorPoolFilterer) FilterInitialized(opts *bind.FilterOpts) (*ValidatorPoolInitializedIterator, error)

+ func (_ValidatorPool *ValidatorPoolFilterer) FilterPendingBondAdded(opts *bind.FilterOpts, outputIndex []*big.Int, challenger []common.Address) (*ValidatorPoolPendingBondAddedIterator, error)

+ func (_ValidatorPool *ValidatorPoolFilterer) FilterPendingBondReleased(opts *bind.FilterOpts, outputIndex []*big.Int, challenger []common.Address, ...) (*ValidatorPoolPendingBondReleasedIterator, error)

+ func (_ValidatorPool *ValidatorPoolFilterer) FilterUnbonded(opts *bind.FilterOpts, outputIndex []*big.Int, recipient []common.Address) (*ValidatorPoolUnbondedIterator, error)

+ func (_ValidatorPool *ValidatorPoolFilterer) ParseBondIncreased(log types.Log) (*ValidatorPoolBondIncreased, error)

+ func (_ValidatorPool *ValidatorPoolFilterer) ParseBonded(log types.Log) (*ValidatorPoolBonded, error)

+ func (_ValidatorPool *ValidatorPoolFilterer) ParseInitialized(log types.Log) (*ValidatorPoolInitialized, error)

+ func (_ValidatorPool *ValidatorPoolFilterer) ParsePendingBondAdded(log types.Log) (*ValidatorPoolPendingBondAdded, error)

+ func (_ValidatorPool *ValidatorPoolFilterer) ParsePendingBondReleased(log types.Log) (*ValidatorPoolPendingBondReleased, error)

+ func (_ValidatorPool *ValidatorPoolFilterer) ParseUnbonded(log types.Log) (*ValidatorPoolUnbonded, error)

+ func (_ValidatorPool *ValidatorPoolFilterer) WatchBondIncreased(opts *bind.WatchOpts, sink chan<- *ValidatorPoolBondIncreased, ...) (event.Subscription, error)

+ func (_ValidatorPool *ValidatorPoolFilterer) WatchBonded(opts *bind.WatchOpts, sink chan<- *ValidatorPoolBonded, ...) (event.Subscription, error)

+ func (_ValidatorPool *ValidatorPoolFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *ValidatorPoolInitialized) (event.Subscription, error)

+ func (_ValidatorPool *ValidatorPoolFilterer) WatchPendingBondAdded(opts *bind.WatchOpts, sink chan<- *ValidatorPoolPendingBondAdded, ...) (event.Subscription, error)

+ func (_ValidatorPool *ValidatorPoolFilterer) WatchPendingBondReleased(opts *bind.WatchOpts, sink chan<- *ValidatorPoolPendingBondReleased, ...) (event.Subscription, error)

+ func (_ValidatorPool *ValidatorPoolFilterer) WatchUnbonded(opts *bind.WatchOpts, sink chan<- *ValidatorPoolUnbonded, ...) (event.Subscription, error)

+ type ValidatorPoolInitialized struct

+ Raw types.Log

+ Version uint8

+ type ValidatorPoolInitializedIterator struct

+ Event *ValidatorPoolInitialized

+ func (it *ValidatorPoolInitializedIterator) Close() error

+ func (it *ValidatorPoolInitializedIterator) Error() error

+ func (it *ValidatorPoolInitializedIterator) Next() bool

+ type ValidatorPoolPendingBondAdded struct

+ Amount *big.Int

+ Challenger common.Address

+ OutputIndex *big.Int

+ Raw types.Log

+ type ValidatorPoolPendingBondAddedIterator struct

+ Event *ValidatorPoolPendingBondAdded

+ func (it *ValidatorPoolPendingBondAddedIterator) Close() error

+ func (it *ValidatorPoolPendingBondAddedIterator) Error() error

+ func (it *ValidatorPoolPendingBondAddedIterator) Next() bool

+ type ValidatorPoolPendingBondReleased struct

+ Amount *big.Int

+ Challenger common.Address

+ OutputIndex *big.Int

+ Raw types.Log

+ Recipient common.Address

+ type ValidatorPoolPendingBondReleasedIterator struct

+ Event *ValidatorPoolPendingBondReleased

+ func (it *ValidatorPoolPendingBondReleasedIterator) Close() error

+ func (it *ValidatorPoolPendingBondReleasedIterator) Error() error

+ func (it *ValidatorPoolPendingBondReleasedIterator) Next() bool

+ type ValidatorPoolRaw struct

+ Contract *ValidatorPool

+ func (_ValidatorPool *ValidatorPoolRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_ValidatorPool *ValidatorPoolRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ValidatorPoolSession struct

+ CallOpts bind.CallOpts

+ Contract *ValidatorPool

+ TransactOpts bind.TransactOpts

+ func (_ValidatorPool *ValidatorPoolSession) AddPendingBond(_outputIndex *big.Int, _challenger common.Address) (*types.Transaction, error)

+ func (_ValidatorPool *ValidatorPoolSession) BalanceOf(_addr common.Address) (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolSession) CreateBond(_outputIndex *big.Int, _expiresAt *big.Int) (*types.Transaction, error)

+ func (_ValidatorPool *ValidatorPoolSession) Deposit() (*types.Transaction, error)

+ func (_ValidatorPool *ValidatorPoolSession) GetBond(_outputIndex *big.Int) (TypesBond, error)

+ func (_ValidatorPool *ValidatorPoolSession) GetPendingBond(_outputIndex *big.Int, _challenger common.Address) (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolSession) IncreaseBond(_outputIndex *big.Int, _challenger common.Address) (*types.Transaction, error)

+ func (_ValidatorPool *ValidatorPoolSession) Initialize() (*types.Transaction, error)

+ func (_ValidatorPool *ValidatorPoolSession) IsValidator(_addr common.Address) (bool, error)

+ func (_ValidatorPool *ValidatorPoolSession) L2ORACLE() (common.Address, error)

+ func (_ValidatorPool *ValidatorPoolSession) MAXUNBOND() (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolSession) NextValidator() (common.Address, error)

+ func (_ValidatorPool *ValidatorPoolSession) PORTAL() (common.Address, error)

+ func (_ValidatorPool *ValidatorPoolSession) REQUIREDBONDAMOUNT() (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolSession) ROUNDDURATION() (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolSession) ReleasePendingBond(_outputIndex *big.Int, _challenger common.Address, _recipient common.Address) (*types.Transaction, error)

+ func (_ValidatorPool *ValidatorPoolSession) SECURITYCOUNCIL() (common.Address, error)

+ func (_ValidatorPool *ValidatorPoolSession) TAXDENOMINATOR() (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolSession) TAXNUMERATOR() (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolSession) TRUSTEDVALIDATOR() (common.Address, error)

+ func (_ValidatorPool *ValidatorPoolSession) Unbond() (*types.Transaction, error)

+ func (_ValidatorPool *ValidatorPoolSession) VAULTREWARDGASLIMIT() (uint64, error)

+ func (_ValidatorPool *ValidatorPoolSession) ValidatorCount() (*big.Int, error)

+ func (_ValidatorPool *ValidatorPoolSession) Version() (string, error)

+ func (_ValidatorPool *ValidatorPoolSession) Withdraw(_amount *big.Int) (*types.Transaction, error)

+ type ValidatorPoolTransactor struct

+ func NewValidatorPoolTransactor(address common.Address, transactor bind.ContractTransactor) (*ValidatorPoolTransactor, error)

+ func (_ValidatorPool *ValidatorPoolTransactor) AddPendingBond(opts *bind.TransactOpts, _outputIndex *big.Int, _challenger common.Address) (*types.Transaction, error)

+ func (_ValidatorPool *ValidatorPoolTransactor) CreateBond(opts *bind.TransactOpts, _outputIndex *big.Int, _expiresAt *big.Int) (*types.Transaction, error)

+ func (_ValidatorPool *ValidatorPoolTransactor) Deposit(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_ValidatorPool *ValidatorPoolTransactor) IncreaseBond(opts *bind.TransactOpts, _outputIndex *big.Int, _challenger common.Address) (*types.Transaction, error)

+ func (_ValidatorPool *ValidatorPoolTransactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_ValidatorPool *ValidatorPoolTransactor) ReleasePendingBond(opts *bind.TransactOpts, _outputIndex *big.Int, _challenger common.Address, ...) (*types.Transaction, error)

+ func (_ValidatorPool *ValidatorPoolTransactor) Unbond(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_ValidatorPool *ValidatorPoolTransactor) Withdraw(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error)

+ type ValidatorPoolTransactorRaw struct

+ Contract *ValidatorPoolTransactor

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

+ func (_ValidatorPool *ValidatorPoolTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ValidatorPoolTransactorSession struct

+ Contract *ValidatorPoolTransactor

+ TransactOpts bind.TransactOpts

+ func (_ValidatorPool *ValidatorPoolTransactorSession) AddPendingBond(_outputIndex *big.Int, _challenger common.Address) (*types.Transaction, error)

+ func (_ValidatorPool *ValidatorPoolTransactorSession) CreateBond(_outputIndex *big.Int, _expiresAt *big.Int) (*types.Transaction, error)

+ func (_ValidatorPool *ValidatorPoolTransactorSession) Deposit() (*types.Transaction, error)

+ func (_ValidatorPool *ValidatorPoolTransactorSession) IncreaseBond(_outputIndex *big.Int, _challenger common.Address) (*types.Transaction, error)

+ func (_ValidatorPool *ValidatorPoolTransactorSession) Initialize() (*types.Transaction, error)

+ func (_ValidatorPool *ValidatorPoolTransactorSession) ReleasePendingBond(_outputIndex *big.Int, _challenger common.Address, _recipient common.Address) (*types.Transaction, error)

+ func (_ValidatorPool *ValidatorPoolTransactorSession) Unbond() (*types.Transaction, error)

+ func (_ValidatorPool *ValidatorPoolTransactorSession) Withdraw(_amount *big.Int) (*types.Transaction, error)

+ type ValidatorPoolUnbonded struct

+ Amount *big.Int

+ OutputIndex *big.Int

+ Raw types.Log

+ Recipient common.Address

+ type ValidatorPoolUnbondedIterator struct

+ Event *ValidatorPoolUnbonded

+ func (it *ValidatorPoolUnbondedIterator) Close() error

+ func (it *ValidatorPoolUnbondedIterator) Error() error

+ func (it *ValidatorPoolUnbondedIterator) Next() bool

+ type ValidatorRewardVault struct

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

+ func NewValidatorRewardVault(address common.Address, backend bind.ContractBackend) (*ValidatorRewardVault, error)

+ type ValidatorRewardVaultCaller struct

+ func NewValidatorRewardVaultCaller(address common.Address, caller bind.ContractCaller) (*ValidatorRewardVaultCaller, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultCaller) BalanceOf(opts *bind.CallOpts, _addr common.Address) (*big.Int, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultCaller) MINWITHDRAWALAMOUNT(opts *bind.CallOpts) (*big.Int, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultCaller) RECIPIENT(opts *bind.CallOpts) (common.Address, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultCaller) REWARDDIVIDER(opts *bind.CallOpts) (*big.Int, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultCaller) TotalProcessed(opts *bind.CallOpts) (*big.Int, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultCaller) TotalReserved(opts *bind.CallOpts) (*big.Int, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultCaller) VALIDATORPOOL(opts *bind.CallOpts) (common.Address, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultCaller) Version(opts *bind.CallOpts) (string, error)

+ type ValidatorRewardVaultCallerRaw struct

+ Contract *ValidatorRewardVaultCaller

+ func (_ValidatorRewardVault *ValidatorRewardVaultCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type ValidatorRewardVaultCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ValidatorRewardVaultCaller

+ func (_ValidatorRewardVault *ValidatorRewardVaultCallerSession) BalanceOf(_addr common.Address) (*big.Int, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultCallerSession) MINWITHDRAWALAMOUNT() (*big.Int, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultCallerSession) RECIPIENT() (common.Address, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultCallerSession) REWARDDIVIDER() (*big.Int, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultCallerSession) TotalProcessed() (*big.Int, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultCallerSession) TotalReserved() (*big.Int, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultCallerSession) VALIDATORPOOL() (common.Address, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultCallerSession) Version() (string, error)

+ type ValidatorRewardVaultFilterer struct

+ func NewValidatorRewardVaultFilterer(address common.Address, filterer bind.ContractFilterer) (*ValidatorRewardVaultFilterer, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultFilterer) FilterRewarded(opts *bind.FilterOpts, validator []common.Address, l2BlockNumber []*big.Int) (*ValidatorRewardVaultRewardedIterator, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultFilterer) FilterWithdrawal(opts *bind.FilterOpts) (*ValidatorRewardVaultWithdrawalIterator, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultFilterer) ParseRewarded(log types.Log) (*ValidatorRewardVaultRewarded, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultFilterer) ParseWithdrawal(log types.Log) (*ValidatorRewardVaultWithdrawal, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultFilterer) WatchRewarded(opts *bind.WatchOpts, sink chan<- *ValidatorRewardVaultRewarded, ...) (event.Subscription, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *ValidatorRewardVaultWithdrawal) (event.Subscription, error)

+ type ValidatorRewardVaultRaw struct

+ Contract *ValidatorRewardVault

+ func (_ValidatorRewardVault *ValidatorRewardVaultRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_ValidatorRewardVault *ValidatorRewardVaultRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ValidatorRewardVaultRewarded struct

+ Amount *big.Int

+ L2BlockNumber *big.Int

+ Raw types.Log

+ Validator common.Address

+ type ValidatorRewardVaultRewardedIterator struct

+ Event *ValidatorRewardVaultRewarded

+ func (it *ValidatorRewardVaultRewardedIterator) Close() error

+ func (it *ValidatorRewardVaultRewardedIterator) Error() error

+ func (it *ValidatorRewardVaultRewardedIterator) Next() bool

+ type ValidatorRewardVaultSession struct

+ CallOpts bind.CallOpts

+ Contract *ValidatorRewardVault

+ TransactOpts bind.TransactOpts

+ func (_ValidatorRewardVault *ValidatorRewardVaultSession) BalanceOf(_addr common.Address) (*big.Int, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultSession) MINWITHDRAWALAMOUNT() (*big.Int, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultSession) RECIPIENT() (common.Address, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultSession) REWARDDIVIDER() (*big.Int, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultSession) Receive() (*types.Transaction, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultSession) Reward(_validator common.Address, _l2BlockNumber *big.Int) (*types.Transaction, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultSession) TotalProcessed() (*big.Int, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultSession) TotalReserved() (*big.Int, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultSession) VALIDATORPOOL() (common.Address, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultSession) Version() (string, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultSession) Withdraw() (*types.Transaction, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultSession) WithdrawToL2() (*types.Transaction, error)

+ type ValidatorRewardVaultTransactor struct

+ func NewValidatorRewardVaultTransactor(address common.Address, transactor bind.ContractTransactor) (*ValidatorRewardVaultTransactor, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultTransactor) Reward(opts *bind.TransactOpts, _validator common.Address, _l2BlockNumber *big.Int) (*types.Transaction, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultTransactor) Withdraw(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultTransactor) WithdrawToL2(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ValidatorRewardVaultTransactorRaw struct

+ Contract *ValidatorRewardVaultTransactor

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

+ func (_ValidatorRewardVault *ValidatorRewardVaultTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ValidatorRewardVaultTransactorSession struct

+ Contract *ValidatorRewardVaultTransactor

+ TransactOpts bind.TransactOpts

+ func (_ValidatorRewardVault *ValidatorRewardVaultTransactorSession) Receive() (*types.Transaction, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultTransactorSession) Reward(_validator common.Address, _l2BlockNumber *big.Int) (*types.Transaction, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultTransactorSession) Withdraw() (*types.Transaction, error)

+ func (_ValidatorRewardVault *ValidatorRewardVaultTransactorSession) WithdrawToL2() (*types.Transaction, error)

+ type ValidatorRewardVaultWithdrawal struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type ValidatorRewardVaultWithdrawalIterator struct

+ Event *ValidatorRewardVaultWithdrawal

+ func (it *ValidatorRewardVaultWithdrawalIterator) Close() error

+ func (it *ValidatorRewardVaultWithdrawalIterator) Error() error

+ func (it *ValidatorRewardVaultWithdrawalIterator) Next() bool

+ type WETH9 struct

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

+ func NewWETH9(address common.Address, backend bind.ContractBackend) (*WETH9, error)

+ type WETH9Approval struct

+ Guy common.Address

+ Raw types.Log

+ Src common.Address

+ Wad *big.Int

+ type WETH9ApprovalIterator struct

+ Event *WETH9Approval

+ func (it *WETH9ApprovalIterator) Close() error

+ func (it *WETH9ApprovalIterator) Error() error

+ func (it *WETH9ApprovalIterator) Next() bool

+ type WETH9Caller struct

+ func NewWETH9Caller(address common.Address, caller bind.ContractCaller) (*WETH9Caller, error)

+ func (_WETH9 *WETH9Caller) Allowance(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_WETH9 *WETH9Caller) BalanceOf(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_WETH9 *WETH9Caller) Decimals(opts *bind.CallOpts) (uint8, error)

+ func (_WETH9 *WETH9Caller) Name(opts *bind.CallOpts) (string, error)

+ func (_WETH9 *WETH9Caller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_WETH9 *WETH9Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type WETH9CallerRaw struct

+ Contract *WETH9Caller

+ func (_WETH9 *WETH9CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type WETH9CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *WETH9Caller

+ func (_WETH9 *WETH9CallerSession) Allowance(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_WETH9 *WETH9CallerSession) BalanceOf(arg0 common.Address) (*big.Int, error)

+ func (_WETH9 *WETH9CallerSession) Decimals() (uint8, error)

+ func (_WETH9 *WETH9CallerSession) Name() (string, error)

+ func (_WETH9 *WETH9CallerSession) Symbol() (string, error)

+ func (_WETH9 *WETH9CallerSession) TotalSupply() (*big.Int, error)

+ type WETH9Deposit struct

+ Dst common.Address

+ Raw types.Log

+ Wad *big.Int

+ type WETH9DepositIterator struct

+ Event *WETH9Deposit

+ func (it *WETH9DepositIterator) Close() error

+ func (it *WETH9DepositIterator) Error() error

+ func (it *WETH9DepositIterator) Next() bool

+ type WETH9Filterer struct

+ func NewWETH9Filterer(address common.Address, filterer bind.ContractFilterer) (*WETH9Filterer, error)

+ func (_WETH9 *WETH9Filterer) FilterApproval(opts *bind.FilterOpts, src []common.Address, guy []common.Address) (*WETH9ApprovalIterator, error)

+ func (_WETH9 *WETH9Filterer) FilterDeposit(opts *bind.FilterOpts, dst []common.Address) (*WETH9DepositIterator, error)

+ func (_WETH9 *WETH9Filterer) FilterTransfer(opts *bind.FilterOpts, src []common.Address, dst []common.Address) (*WETH9TransferIterator, error)

+ func (_WETH9 *WETH9Filterer) FilterWithdrawal(opts *bind.FilterOpts, src []common.Address) (*WETH9WithdrawalIterator, error)

+ func (_WETH9 *WETH9Filterer) ParseApproval(log types.Log) (*WETH9Approval, error)

+ func (_WETH9 *WETH9Filterer) ParseDeposit(log types.Log) (*WETH9Deposit, error)

+ func (_WETH9 *WETH9Filterer) ParseTransfer(log types.Log) (*WETH9Transfer, error)

+ func (_WETH9 *WETH9Filterer) ParseWithdrawal(log types.Log) (*WETH9Withdrawal, error)

+ func (_WETH9 *WETH9Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *WETH9Approval, src []common.Address, ...) (event.Subscription, error)

+ func (_WETH9 *WETH9Filterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *WETH9Deposit, dst []common.Address) (event.Subscription, error)

+ func (_WETH9 *WETH9Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *WETH9Transfer, src []common.Address, ...) (event.Subscription, error)

+ func (_WETH9 *WETH9Filterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *WETH9Withdrawal, src []common.Address) (event.Subscription, error)

+ type WETH9Raw struct

+ Contract *WETH9

+ func (_WETH9 *WETH9Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_WETH9 *WETH9Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type WETH9Session struct

+ CallOpts bind.CallOpts

+ Contract *WETH9

+ TransactOpts bind.TransactOpts

+ func (_WETH9 *WETH9Session) Allowance(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_WETH9 *WETH9Session) Approve(guy common.Address, wad *big.Int) (*types.Transaction, error)

+ func (_WETH9 *WETH9Session) BalanceOf(arg0 common.Address) (*big.Int, error)

+ func (_WETH9 *WETH9Session) Decimals() (uint8, error)

+ func (_WETH9 *WETH9Session) Deposit() (*types.Transaction, error)

+ func (_WETH9 *WETH9Session) Fallback(calldata []byte) (*types.Transaction, error)

+ func (_WETH9 *WETH9Session) Name() (string, error)

+ func (_WETH9 *WETH9Session) Symbol() (string, error)

+ func (_WETH9 *WETH9Session) TotalSupply() (*big.Int, error)

+ func (_WETH9 *WETH9Session) Transfer(dst common.Address, wad *big.Int) (*types.Transaction, error)

+ func (_WETH9 *WETH9Session) TransferFrom(src common.Address, dst common.Address, wad *big.Int) (*types.Transaction, error)

+ func (_WETH9 *WETH9Session) Withdraw(wad *big.Int) (*types.Transaction, error)

+ type WETH9Transactor struct

+ func NewWETH9Transactor(address common.Address, transactor bind.ContractTransactor) (*WETH9Transactor, error)

+ func (_WETH9 *WETH9Transactor) Approve(opts *bind.TransactOpts, guy common.Address, wad *big.Int) (*types.Transaction, error)

+ func (_WETH9 *WETH9Transactor) Deposit(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_WETH9 *WETH9Transactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error)

+ func (_WETH9 *WETH9Transactor) Transfer(opts *bind.TransactOpts, dst common.Address, wad *big.Int) (*types.Transaction, error)

+ func (_WETH9 *WETH9Transactor) TransferFrom(opts *bind.TransactOpts, src common.Address, dst common.Address, wad *big.Int) (*types.Transaction, error)

+ func (_WETH9 *WETH9Transactor) Withdraw(opts *bind.TransactOpts, wad *big.Int) (*types.Transaction, error)

+ type WETH9TransactorRaw struct

+ Contract *WETH9Transactor

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

+ func (_WETH9 *WETH9TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type WETH9TransactorSession struct

+ Contract *WETH9Transactor

+ TransactOpts bind.TransactOpts

+ func (_WETH9 *WETH9TransactorSession) Approve(guy common.Address, wad *big.Int) (*types.Transaction, error)

+ func (_WETH9 *WETH9TransactorSession) Deposit() (*types.Transaction, error)

+ func (_WETH9 *WETH9TransactorSession) Fallback(calldata []byte) (*types.Transaction, error)

+ func (_WETH9 *WETH9TransactorSession) Transfer(dst common.Address, wad *big.Int) (*types.Transaction, error)

+ func (_WETH9 *WETH9TransactorSession) TransferFrom(src common.Address, dst common.Address, wad *big.Int) (*types.Transaction, error)

+ func (_WETH9 *WETH9TransactorSession) Withdraw(wad *big.Int) (*types.Transaction, error)

+ type WETH9Transfer struct

+ Dst common.Address

+ Raw types.Log

+ Src common.Address

+ Wad *big.Int

+ type WETH9TransferIterator struct

+ Event *WETH9Transfer

+ func (it *WETH9TransferIterator) Close() error

+ func (it *WETH9TransferIterator) Error() error

+ func (it *WETH9TransferIterator) Next() bool

+ type WETH9Withdrawal struct

+ Raw types.Log

+ Src common.Address

+ Wad *big.Int

+ type WETH9WithdrawalIterator struct

+ Event *WETH9Withdrawal

+ func (it *WETH9WithdrawalIterator) Close() error

+ func (it *WETH9WithdrawalIterator) Error() error

+ func (it *WETH9WithdrawalIterator) Next() bool

+ type ZKMerkleTrie struct

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

+ func NewZKMerkleTrie(address common.Address, backend bind.ContractBackend) (*ZKMerkleTrie, error)

+ type ZKMerkleTrieCaller struct

+ func NewZKMerkleTrieCaller(address common.Address, caller bind.ContractCaller) (*ZKMerkleTrieCaller, error)

+ func (_ZKMerkleTrie *ZKMerkleTrieCaller) Get(opts *bind.CallOpts, _key [32]byte, _proofs [][]byte, _root [32]byte) (bool, []byte, error)

+ func (_ZKMerkleTrie *ZKMerkleTrieCaller) POSEIDON2(opts *bind.CallOpts) (common.Address, error)

+ func (_ZKMerkleTrie *ZKMerkleTrieCaller) VerifyInclusionProof(opts *bind.CallOpts, _key [32]byte, _value []byte, _proofs [][]byte, ...) (bool, error)

+ type ZKMerkleTrieCallerRaw struct

+ Contract *ZKMerkleTrieCaller

+ func (_ZKMerkleTrie *ZKMerkleTrieCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type ZKMerkleTrieCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ZKMerkleTrieCaller

+ func (_ZKMerkleTrie *ZKMerkleTrieCallerSession) Get(_key [32]byte, _proofs [][]byte, _root [32]byte) (bool, []byte, error)

+ func (_ZKMerkleTrie *ZKMerkleTrieCallerSession) POSEIDON2() (common.Address, error)

+ func (_ZKMerkleTrie *ZKMerkleTrieCallerSession) VerifyInclusionProof(_key [32]byte, _value []byte, _proofs [][]byte, _root [32]byte) (bool, error)

+ type ZKMerkleTrieFilterer struct

+ func NewZKMerkleTrieFilterer(address common.Address, filterer bind.ContractFilterer) (*ZKMerkleTrieFilterer, error)

+ type ZKMerkleTrieRaw struct

+ Contract *ZKMerkleTrie

+ func (_ZKMerkleTrie *ZKMerkleTrieRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_ZKMerkleTrie *ZKMerkleTrieRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ZKMerkleTrieSession struct

+ CallOpts bind.CallOpts

+ Contract *ZKMerkleTrie

+ TransactOpts bind.TransactOpts

+ func (_ZKMerkleTrie *ZKMerkleTrieSession) Get(_key [32]byte, _proofs [][]byte, _root [32]byte) (bool, []byte, error)

+ func (_ZKMerkleTrie *ZKMerkleTrieSession) POSEIDON2() (common.Address, error)

+ func (_ZKMerkleTrie *ZKMerkleTrieSession) VerifyInclusionProof(_key [32]byte, _value []byte, _proofs [][]byte, _root [32]byte) (bool, error)

+ type ZKMerkleTrieTransactor struct

+ func NewZKMerkleTrieTransactor(address common.Address, transactor bind.ContractTransactor) (*ZKMerkleTrieTransactor, error)

+ type ZKMerkleTrieTransactorRaw struct

+ Contract *ZKMerkleTrieTransactor

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

+ func (_ZKMerkleTrie *ZKMerkleTrieTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ZKMerkleTrieTransactorSession struct

+ Contract *ZKMerkleTrieTransactor

+ TransactOpts bind.TransactOpts

+ type ZKVerifier struct

+ func DeployZKVerifier(auth *bind.TransactOpts, backend bind.ContractBackend, _hashScalar *big.Int, ...) (common.Address, *types.Transaction, *ZKVerifier, error)

+ func NewZKVerifier(address common.Address, backend bind.ContractBackend) (*ZKVerifier, error)

+ type ZKVerifierCaller struct

+ func NewZKVerifierCaller(address common.Address, caller bind.ContractCaller) (*ZKVerifierCaller, error)

+ func (_ZKVerifier *ZKVerifierCaller) Verify(opts *bind.CallOpts, proof []*big.Int, target_circuit_final_pair []*big.Int, ...) (bool, error)

+ func (_ZKVerifier *ZKVerifierCaller) Version(opts *bind.CallOpts) (string, error)

+ type ZKVerifierCallerRaw struct

+ Contract *ZKVerifierCaller

+ func (_ZKVerifier *ZKVerifierCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type ZKVerifierCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ZKVerifierCaller

+ func (_ZKVerifier *ZKVerifierCallerSession) Verify(proof []*big.Int, target_circuit_final_pair []*big.Int, ...) (bool, error)

+ func (_ZKVerifier *ZKVerifierCallerSession) Version() (string, error)

+ type ZKVerifierFilterer struct

+ func NewZKVerifierFilterer(address common.Address, filterer bind.ContractFilterer) (*ZKVerifierFilterer, error)

+ type ZKVerifierRaw struct

+ Contract *ZKVerifier

+ func (_ZKVerifier *ZKVerifierRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_ZKVerifier *ZKVerifierRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ZKVerifierSession struct

+ CallOpts bind.CallOpts

+ Contract *ZKVerifier

+ TransactOpts bind.TransactOpts

+ func (_ZKVerifier *ZKVerifierSession) Verify(proof []*big.Int, target_circuit_final_pair []*big.Int, ...) (bool, error)

+ func (_ZKVerifier *ZKVerifierSession) Version() (string, error)

+ type ZKVerifierTransactor struct

+ func NewZKVerifierTransactor(address common.Address, transactor bind.ContractTransactor) (*ZKVerifierTransactor, error)

+ type ZKVerifierTransactorRaw struct

+ Contract *ZKVerifierTransactor

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

+ func (_ZKVerifier *ZKVerifierTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ZKVerifierTransactorSession struct

+ Contract *ZKVerifierTransactor

+ TransactOpts bind.TransactOpts

v1.1.0-rc.3

Dec 23, 2023

v1.1.0-rc.2

Dec 6, 2023

v1.1.0-rc.1

Dec 4, 2023

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