bindings

package

Go to main page

Versions in this module

v1

v1.7.4

Apr 23, 2024

Changes in this version

type DelayedWETHSession

+ func (_DelayedWETH *DelayedWETHSession) Fallback(calldata []byte) (*types.Transaction, error)

type DelayedWETHTransactor

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

type DelayedWETHTransactorSession

+ func (_DelayedWETH *DelayedWETHTransactorSession) Fallback(calldata []byte) (*types.Transaction, error)

type ERC20Approval

+ Amount *big.Int

type ERC20Caller

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

+ func (_ERC20 *ERC20Caller) Nonces(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

type ERC20CallerSession

+ func (_ERC20 *ERC20CallerSession) DOMAINSEPARATOR() ([32]byte, error)

+ func (_ERC20 *ERC20CallerSession) Nonces(arg0 common.Address) (*big.Int, error)

type ERC20Session

+ func (_ERC20 *ERC20Session) DOMAINSEPARATOR() ([32]byte, error)

+ func (_ERC20 *ERC20Session) Nonces(arg0 common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20Session) Permit(owner common.Address, spender common.Address, value *big.Int, ...) (*types.Transaction, error)

type ERC20Transactor

+ func (_ERC20 *ERC20Transactor) Permit(opts *bind.TransactOpts, owner common.Address, spender common.Address, ...) (*types.Transaction, error)

type ERC20TransactorSession

+ func (_ERC20 *ERC20TransactorSession) Permit(owner common.Address, spender common.Address, value *big.Int, ...) (*types.Transaction, error)

type ERC20Transfer

+ Amount *big.Int

type FaultDisputeGameCaller

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

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

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

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

+ func (_FaultDisputeGame *FaultDisputeGameCaller) GetChallengerDuration(opts *bind.CallOpts, _claimIndex *big.Int) (uint64, error)

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

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

+ func (_FaultDisputeGame *FaultDisputeGameCaller) ResolutionCheckpoints(opts *bind.CallOpts, arg0 *big.Int) (struct{ ... }, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) ResolvedSubgames(opts *bind.CallOpts, arg0 *big.Int) (bool, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) Subgames(opts *bind.CallOpts, arg0 *big.Int, arg1 *big.Int) (*big.Int, error)

type FaultDisputeGameCallerSession

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

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) Claims(arg0 [32]byte) (bool, error)

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

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

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) GetChallengerDuration(_claimIndex *big.Int) (uint64, error)

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

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

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) ResolutionCheckpoints(arg0 *big.Int) (struct{ ... }, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) ResolvedSubgames(arg0 *big.Int) (bool, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) Subgames(arg0 *big.Int, arg1 *big.Int) (*big.Int, error)

type FaultDisputeGameSession

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

+ func (_FaultDisputeGame *FaultDisputeGameSession) Claims(arg0 [32]byte) (bool, error)

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

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

+ func (_FaultDisputeGame *FaultDisputeGameSession) GetChallengerDuration(_claimIndex *big.Int) (uint64, error)

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

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

+ func (_FaultDisputeGame *FaultDisputeGameSession) ResolutionCheckpoints(arg0 *big.Int) (struct{ ... }, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) ResolvedSubgames(arg0 *big.Int) (bool, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) Subgames(arg0 *big.Int, arg1 *big.Int) (*big.Int, error)

v1.7.3

Apr 8, 2024

v1.7.2

Mar 20, 2024

Changes in this version

+ const DataAvailabilityChallengeStorageLayoutJSON

+ const DelayedWETHStorageLayoutJSON

+ 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)

+ type Challenge struct

+ Challenger common.Address

+ LockedBond *big.Int

+ ResolvedBlock *big.Int

+ StartBlock *big.Int

+ 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 FaultDisputeGameCaller

+ func (_FaultDisputeGame *FaultDisputeGameCaller) L2ChainId(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) Weth(opts *bind.CallOpts) (common.Address, error)

type FaultDisputeGameCallerSession

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) L2ChainId() (*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) Weth() (common.Address, error)

type FaultDisputeGameSession

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

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

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

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

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

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

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

type FaultDisputeGameTransactor

+ 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) Fallback(calldata []byte) (*types.Transaction, error)

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

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 PreimageOracleCaller

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

type PreimageOracleCallerSession

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

type PreimageOracleSession

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

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

type PreimageOracleTransactor

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

type PreimageOracleTransactorSession

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

v1.7.0

Feb 22, 2024

Changes in this version

type PreimageOracleCaller

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

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

type PreimageOracleCallerSession

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

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

type PreimageOracleSession

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

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

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

type PreimageOracleTransactor

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

type PreimageOracleTransactorSession

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

v1.6.1

Feb 15, 2024

Changes in this version

type FaultDisputeGameCaller

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

type FaultDisputeGameCallerSession

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

type FaultDisputeGameSession

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

type PreimageOracleSession

+ func (_PreimageOracle *PreimageOracleSession) LoadKZGPointEvaluationPreimage(_input []byte) (*types.Transaction, error)

type PreimageOracleTransactor

+ func (_PreimageOracle *PreimageOracleTransactor) LoadKZGPointEvaluationPreimage(opts *bind.TransactOpts, _input []byte) (*types.Transaction, error)

type PreimageOracleTransactorSession

+ func (_PreimageOracle *PreimageOracleTransactorSession) LoadKZGPointEvaluationPreimage(_input []byte) (*types.Transaction, error)

v1.5.1

Feb 8, 2024

Changes in this version

type IDisputeGameFactoryGameSearchResult

+ ExtraData []byte

+ RootClaim [32]byte

+ Timestamp uint64

v1.5.0

Jan 31, 2024

Changes in this version

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 DisputeGameFactoryCaller

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

type DisputeGameFactoryCallerSession

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

type DisputeGameFactorySession

+ func (_DisputeGameFactory *DisputeGameFactorySession) FindLatestGames(_gameType uint32, _start *big.Int, _n *big.Int) ([]IDisputeGameFactoryGameSearchResult, 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 IDisputeGameFactoryGameSearchResult struct

+ Index *big.Int

+ Metadata [32]byte

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 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) 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) 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) 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) 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) 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) 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) LoadSha256PreimagePart(_partOffset *big.Int, _preimage []byte) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleSession) MAXLEAFCOUNT() (*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) 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) 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) 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) 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 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)

v1.5.0-rc.3

Jan 30, 2024

v1.4.3

Jan 6, 2024

Changes in this version

type DisputeGameFactoryCaller

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

type DisputeGameFactoryCallerSession

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

type DisputeGameFactoryFilterer

+ func (_DisputeGameFactory *DisputeGameFactoryFilterer) FilterInitBondUpdated(opts *bind.FilterOpts, gameType []uint8, 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 uint8

+ 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) InitBonds(arg0 uint8) (*big.Int, error)

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

type DisputeGameFactoryTransactor

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

type DisputeGameFactoryTransactorSession

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

type FaultDisputeGameCaller

+ func (_FaultDisputeGame *FaultDisputeGameCaller) AbsolutePrestate(opts *bind.CallOpts) ([32]byte, 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) GenesisBlockNumber(opts *bind.CallOpts) (*big.Int, error)

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

+ func (_FaultDisputeGame *FaultDisputeGameCaller) GetRequiredBond(opts *bind.CallOpts, _position *big.Int) (*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) Vm(opts *bind.CallOpts) (common.Address, error)

type FaultDisputeGameCallerSession

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

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

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

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

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

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) GetRequiredBond(_position *big.Int) (*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) Vm() (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) Credit(arg0 common.Address) (*big.Int, error)

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

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

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

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

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

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

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

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

type FaultDisputeGameTransactor

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

type FaultDisputeGameTransactorSession

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

type SystemConfigCaller

+ func (_SystemConfig *SystemConfigCaller) BasefeeScalar(opts *bind.CallOpts) (uint32, error)

+ func (_SystemConfig *SystemConfigCaller) BlobBasefeeScalar(opts *bind.CallOpts) (uint32, error)

type SystemConfigCallerSession

+ func (_SystemConfig *SystemConfigCallerSession) BasefeeScalar() (uint32, error)

+ func (_SystemConfig *SystemConfigCallerSession) BlobBasefeeScalar() (uint32, error)

type SystemConfigSession

+ func (_SystemConfig *SystemConfigSession) BasefeeScalar() (uint32, error)

+ func (_SystemConfig *SystemConfigSession) BlobBasefeeScalar() (uint32, error)

+ func (_SystemConfig *SystemConfigSession) SetGasConfigEcotone(_basefeeScalar uint32, _blobBasefeeScalar uint32) (*types.Transaction, error)

type SystemConfigTransactor

+ func (_SystemConfig *SystemConfigTransactor) SetGasConfigEcotone(opts *bind.TransactOpts, _basefeeScalar uint32, _blobBasefeeScalar uint32) (*types.Transaction, error)

type SystemConfigTransactorSession

+ func (_SystemConfig *SystemConfigTransactorSession) SetGasConfigEcotone(_basefeeScalar uint32, _blobBasefeeScalar uint32) (*types.Transaction, error)

v1.4.2

Dec 22, 2023

Changes in this version

+ const AlphabetVM2StorageLayoutJSON

+ const OutputBisectionGameStorageLayoutJSON

+ const StorageSetterStorageLayoutJSON

+ const SuperchainConfigStorageLayoutJSON

+ var AlphabetVM2ABI = AlphabetVM2MetaData.ABI

+ var AlphabetVM2Bin = AlphabetVM2MetaData.Bin

+ var AlphabetVM2MetaData = &bind.MetaData

+ var AlphabetVM2StorageLayout = new(solc.StorageLayout)

+ var Create2DeployerABI = Create2DeployerMetaData.ABI

+ var Create2DeployerBin = Create2DeployerMetaData.Bin

+ var Create2DeployerCodeHash = common.HexToHash("0xb0550b5b431e30d38000efb7107aaa0ade03d48a7198a140edda9d27134468b2")

+ var Create2DeployerMetaData = &bind.MetaData

+ 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 OutputBisectionGameABI = OutputBisectionGameMetaData.ABI

+ var OutputBisectionGameBin = OutputBisectionGameMetaData.Bin

+ var OutputBisectionGameMetaData = &bind.MetaData

+ var OutputBisectionGameStorageLayout = new(solc.StorageLayout)

+ 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

+ var StorageSetterABI = StorageSetterMetaData.ABI

+ var StorageSetterBin = StorageSetterMetaData.Bin

+ var StorageSetterMetaData = &bind.MetaData

+ var StorageSetterStorageLayout = new(solc.StorageLayout)

+ var SuperchainConfigABI = SuperchainConfigMetaData.ABI

+ var SuperchainConfigBin = SuperchainConfigMetaData.Bin

+ var SuperchainConfigMetaData = &bind.MetaData

+ var SuperchainConfigStorageLayout = new(solc.StorageLayout)

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

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

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

+ 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)

+ func (_AlphabetVM2 *AlphabetVM2Caller) Step(opts *bind.CallOpts, _stateData []byte, arg1 []byte, _localContext [32]byte) ([32]byte, 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)

+ func (_AlphabetVM2 *AlphabetVM2CallerSession) Step(_stateData []byte, arg1 []byte, _localContext [32]byte) ([32]byte, 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) ([32]byte, error)

+ type AlphabetVM2Transactor struct

+ func NewAlphabetVM2Transactor(address common.Address, transactor bind.ContractTransactor) (*AlphabetVM2Transactor, 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

+ 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) Paused(opts *bind.CallOpts) (bool, error)

type CrossDomainMessengerCallerSession

+ func (_CrossDomainMessenger *CrossDomainMessengerCallerSession) Paused() (bool, error)

type CrossDomainMessengerSession

+ func (_CrossDomainMessenger *CrossDomainMessengerSession) Paused() (bool, error)

+ 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 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 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 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 L1CrossDomainMessengerCaller

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCaller) Paused(opts *bind.CallOpts) (bool, error)

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

type L1CrossDomainMessengerCallerSession

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) Paused() (bool, error)

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

type L1CrossDomainMessengerSession

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) Paused() (bool, error)

+ 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 L2CrossDomainMessengerCaller

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) Paused(opts *bind.CallOpts) (bool, error)

type L2CrossDomainMessengerCallerSession

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) Paused() (bool, error)

type L2CrossDomainMessengerSession

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) Paused() (bool, 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 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 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) GameData(opts *bind.CallOpts) (struct{ ... }, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) GameDuration(opts *bind.CallOpts) (uint64, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) GameType(opts *bind.CallOpts) (uint8, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) GenesisBlockNumber(opts *bind.CallOpts) (*big.Int, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) GenesisOutputRoot(opts *bind.CallOpts) ([32]byte, 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) Version(opts *bind.CallOpts) (string, error)

+ func (_OutputBisectionGame *OutputBisectionGameCaller) Vm(opts *bind.CallOpts) (common.Address, 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) GameData() (struct{ ... }, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) GameDuration() (uint64, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) GameType() (uint8, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) GenesisBlockNumber() (*big.Int, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) GenesisOutputRoot() ([32]byte, 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) Version() (string, error)

+ func (_OutputBisectionGame *OutputBisectionGameCallerSession) Vm() (common.Address, 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) GameData() (struct{ ... }, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) GameDuration() (uint64, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) GameType() (uint8, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) GenesisBlockNumber() (*big.Int, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) GenesisOutputRoot() ([32]byte, 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) Version() (string, error)

+ func (_OutputBisectionGame *OutputBisectionGameSession) Vm() (common.Address, 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 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 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 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 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) GetBool(opts *bind.CallOpts, _slot [32]byte) (bool, 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) GetBool(_slot [32]byte) (bool, 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) GetBool(_slot [32]byte) (bool, 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) SetBool(_slot [32]byte, _value bool) (*types.Transaction, error)

+ func (_StorageSetter *StorageSetterSession) SetBytes32(slots []StorageSetterSlot) (*types.Transaction, error)

+ func (_StorageSetter *StorageSetterSession) SetBytes320(_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 StorageSetterSlot struct

+ Key [32]byte

+ Value [32]byte

+ 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) SetBool(opts *bind.TransactOpts, _slot [32]byte, _value bool) (*types.Transaction, error)

+ func (_StorageSetter *StorageSetterTransactor) SetBytes32(opts *bind.TransactOpts, slots []StorageSetterSlot) (*types.Transaction, error)

+ func (_StorageSetter *StorageSetterTransactor) SetBytes320(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) SetBool(_slot [32]byte, _value bool) (*types.Transaction, error)

+ func (_StorageSetter *StorageSetterTransactorSession) SetBytes32(slots []StorageSetterSlot) (*types.Transaction, error)

+ func (_StorageSetter *StorageSetterTransactorSession) SetBytes320(_slot [32]byte, _value [32]byte) (*types.Transaction, error)

+ func (_StorageSetter *StorageSetterTransactorSession) SetUint(_slot [32]byte, _value *big.Int) (*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, _paused bool) (*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, _paused bool) (*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, _paused bool) (*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

+ 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.3

Dec 4, 2023

v1.4.0-rc.2

Dec 1, 2023

v1.4.0-rc.1

Nov 30, 2023

v1.2.0

Oct 6, 2023

Changes in this version

+ const ISemverStorageLayoutJSON

+ var ISemverABI = ISemverMetaData.ABI

+ var ISemverDeployedBin = "0x"

+ var ISemverMetaData = &bind.MetaData

+ var ISemverStorageLayout = new(solc.StorageLayout)

type BlockOracleCaller

+ func (_BlockOracle *BlockOracleCaller) Version(opts *bind.CallOpts) (string, error)

type BlockOracleCallerSession

+ func (_BlockOracle *BlockOracleCallerSession) Version() (string, error)

type BlockOracleSession

+ func (_BlockOracle *BlockOracleSession) Version() (string, error)

+ 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

v1.1.6

Sep 25, 2023

Changes in this version

+ const DelayedVetoableStorageLayoutJSON

+ const ProtocolVersionsStorageLayoutJSON

+ const SafeProxyFactoryStorageLayoutJSON

+ const SafeStorageLayoutJSON

+ var DelayedVetoableABI = DelayedVetoableMetaData.ABI

+ var DelayedVetoableBin = DelayedVetoableMetaData.Bin

+ var DelayedVetoableMetaData = &bind.MetaData

+ var DelayedVetoableStorageLayout = 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)

+ 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

+ Deadline uint64

type DelegatedRevocationRequest

+ Deadline uint64

type EASAttested

+ SchemaUID [32]byte

type EASFilterer

+ func (_EAS *EASFilterer) FilterNonceIncreased(opts *bind.FilterOpts) (*EASNonceIncreasedIterator, error)

+ func (_EAS *EASFilterer) ParseNonceIncreased(log types.Log) (*EASNonceIncreased, error)

+ func (_EAS *EASFilterer) WatchNonceIncreased(opts *bind.WatchOpts, sink chan<- *EASNonceIncreased) (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 EASRevoked

+ SchemaUID [32]byte

type EASSession

+ func (_EAS *EASSession) IncreaseNonce(newNonce *big.Int) (*types.Transaction, error)

type EASTransactor

+ func (_EAS *EASTransactor) IncreaseNonce(opts *bind.TransactOpts, newNonce *big.Int) (*types.Transaction, error)

type EASTransactorSession

+ func (_EAS *EASTransactorSession) IncreaseNonce(newNonce *big.Int) (*types.Transaction, error)

type FaultDisputeGameSession

+ func (_FaultDisputeGame *FaultDisputeGameSession) ResolveClaim(_claimIndex *big.Int) (*types.Transaction, error)

type FaultDisputeGameTransactor

+ func (_FaultDisputeGame *FaultDisputeGameTransactor) ResolveClaim(opts *bind.TransactOpts, _claimIndex *big.Int) (*types.Transaction, error)

type FaultDisputeGameTransactorSession

+ func (_FaultDisputeGame *FaultDisputeGameTransactorSession) ResolveClaim(_claimIndex *big.Int) (*types.Transaction, error)

type MultiDelegatedAttestationRequest

+ Deadline uint64

type MultiDelegatedRevocationRequest

+ Deadline uint64

type OptimismMintableERC20FactoryCaller

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryCaller) Bridge(opts *bind.CallOpts) (common.Address, error)

type OptimismMintableERC20FactoryCallerSession

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryCallerSession) Bridge() (common.Address, error)

type OptimismMintableERC20FactoryFilterer

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryFilterer) FilterInitialized(opts *bind.FilterOpts) (*OptimismMintableERC20FactoryInitializedIterator, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryFilterer) ParseInitialized(log types.Log) (*OptimismMintableERC20FactoryInitialized, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *OptimismMintableERC20FactoryInitialized) (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 OptimismMintableERC20FactorySession

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactorySession) Bridge() (common.Address, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactorySession) CreateOptimismMintableERC20WithDecimals(_remoteToken common.Address, _name string, _symbol string, _decimals uint8) (*types.Transaction, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactorySession) Initialize(_bridge common.Address) (*types.Transaction, error)

type OptimismMintableERC20FactoryTransactor

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryTransactor) CreateOptimismMintableERC20WithDecimals(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 OptimismMintableERC20FactoryTransactorSession

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryTransactorSession) CreateOptimismMintableERC20WithDecimals(_remoteToken common.Address, _name string, _symbol string, _decimals uint8) (*types.Transaction, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryTransactorSession) Initialize(_bridge common.Address) (*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 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 SchemaRegistryRegistered

+ Schema SchemaRecord

v1.1.6-rc.2

Sep 25, 2023

v1.1.5-rc.1

Sep 6, 2023

v1.1.4

Aug 16, 2023

Changes in this version

+ const BlockOracleStorageLayoutJSON

+ var BlockOracleABI = BlockOracleMetaData.ABI

+ var BlockOracleBin = BlockOracleMetaData.Bin

+ var BlockOracleDeployedBin = "0x608060405234801561001057600080fd5b50600436106100365760003560e01c806399d548aa1461003b578063c2c4c5c114610078575b600080fd5b61004e6100493660046101b8565b61008e565b604080518251815260209283015167ffffffffffffffff1692810192909252015b60405180910390f35b61008061010d565b60405190815260200161006f565b604080518082018252600080825260209182018190528381528082528281208351808501909452805480855260019091015467ffffffffffffffff169284019290925203610108576040517f37cf270500000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b919050565b600061011a6001436101d1565b60408051808201825282408082524267ffffffffffffffff81811660208086018281526000898152918290528782209651875551600190960180547fffffffffffffffffffffffffffffffffffffffffffffffff000000000000000016969093169590951790915593519495509093909291849186917fb67ff58b33060fd371a35ae2d9f1c3cdaec9b8197969f6efe2594a1ff4ba68c691a4505090565b6000602082840312156101ca57600080fd5b5035919050565b60008282101561020a577f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b50039056fea164736f6c634300080f000a"

+ var BlockOracleMetaData = &bind.MetaData

+ var BlockOracleStorageLayout = new(solc.StorageLayout)

type AlphabetVMCaller

+ func (_AlphabetVM *AlphabetVMCaller) Oracle(opts *bind.CallOpts) (common.Address, error)

type AlphabetVMCallerSession

+ func (_AlphabetVM *AlphabetVMCallerSession) Oracle() (common.Address, error)

type AlphabetVMSession

+ func (_AlphabetVM *AlphabetVMSession) Oracle() (common.Address, error)

+ 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)

+ 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)

+ 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)

+ 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 FaultDisputeGameCaller

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

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

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

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

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

type FaultDisputeGameCallerSession

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

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

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

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

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

type FaultDisputeGameSession

+ func (_FaultDisputeGame *FaultDisputeGameSession) AddLocalData(_ident *big.Int, _partOffset *big.Int) (*types.Transaction, error)

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

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

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

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

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

type FaultDisputeGameTransactor

+ func (_FaultDisputeGame *FaultDisputeGameTransactor) AddLocalData(opts *bind.TransactOpts, _ident *big.Int, _partOffset *big.Int) (*types.Transaction, error)

type FaultDisputeGameTransactorSession

+ func (_FaultDisputeGame *FaultDisputeGameTransactorSession) AddLocalData(_ident *big.Int, _partOffset *big.Int) (*types.Transaction, error)

+ type IFaultDisputeGameOutputProposal struct

+ Index *big.Int

+ L2BlockNumber *big.Int

+ OutputRoot [32]byte

type L1CrossDomainMessengerCaller

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

type L1CrossDomainMessengerCallerSession

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

type L1CrossDomainMessengerSession

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) Portal() (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)

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 L1StandardBridgeCaller

+ func (_L1StandardBridge *L1StandardBridgeCaller) OtherBridge(opts *bind.CallOpts) (common.Address, error)

type L1StandardBridgeCallerSession

+ func (_L1StandardBridge *L1StandardBridgeCallerSession) OtherBridge() (common.Address, error)

type L1StandardBridgeFilterer

+ func (_L1StandardBridge *L1StandardBridgeFilterer) FilterInitialized(opts *bind.FilterOpts) (*L1StandardBridgeInitializedIterator, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) ParseInitialized(log types.Log) (*L1StandardBridgeInitialized, 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) Initialize(_messenger common.Address) (*types.Transaction, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) OtherBridge() (common.Address, error)

type L1StandardBridgeTransactor

+ func (_L1StandardBridge *L1StandardBridgeTransactor) Initialize(opts *bind.TransactOpts, _messenger common.Address) (*types.Transaction, error)

type L1StandardBridgeTransactorSession

+ func (_L1StandardBridge *L1StandardBridgeTransactorSession) Initialize(_messenger common.Address) (*types.Transaction, 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(_messenger common.Address) (*types.Transaction, error)

type L2ERC721BridgeTransactor

+ func (_L2ERC721Bridge *L2ERC721BridgeTransactor) Initialize(opts *bind.TransactOpts, _messenger common.Address) (*types.Transaction, error)

type L2ERC721BridgeTransactorSession

+ func (_L2ERC721Bridge *L2ERC721BridgeTransactorSession) Initialize(_messenger common.Address) (*types.Transaction, error)

type L2OutputOracleCaller

+ 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) SubmissionInterval(opts *bind.CallOpts) (*big.Int, error)

type L2OutputOracleCallerSession

+ 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) SubmissionInterval() (*big.Int, error)

type L2OutputOracleSession

+ func (_L2OutputOracle *L2OutputOracleSession) Challenger() (common.Address, 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) SubmissionInterval() (*big.Int, error)

type L2StandardBridgeCaller

+ func (_L2StandardBridge *L2StandardBridgeCaller) OtherBridge(opts *bind.CallOpts) (common.Address, error)

type L2StandardBridgeCallerSession

+ func (_L2StandardBridge *L2StandardBridgeCallerSession) OtherBridge() (common.Address, error)

type L2StandardBridgeFilterer

+ func (_L2StandardBridge *L2StandardBridgeFilterer) FilterInitialized(opts *bind.FilterOpts) (*L2StandardBridgeInitializedIterator, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) ParseInitialized(log types.Log) (*L2StandardBridgeInitialized, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *L2StandardBridgeInitialized) (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) Initialize() (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeSession) OtherBridge() (common.Address, error)

type L2StandardBridgeTransactor

+ func (_L2StandardBridge *L2StandardBridgeTransactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error)

type L2StandardBridgeTransactorSession

+ func (_L2StandardBridge *L2StandardBridgeTransactorSession) Initialize() (*types.Transaction, error)

type OptimismPortalCaller

+ func (_OptimismPortal *OptimismPortalCaller) Guardian(opts *bind.CallOpts) (common.Address, error)

+ func (_OptimismPortal *OptimismPortalCaller) L2Oracle(opts *bind.CallOpts) (common.Address, error)

+ func (_OptimismPortal *OptimismPortalCaller) SystemConfig(opts *bind.CallOpts) (common.Address, error)

type OptimismPortalCallerSession

+ func (_OptimismPortal *OptimismPortalCallerSession) Guardian() (common.Address, error)

+ func (_OptimismPortal *OptimismPortalCallerSession) L2Oracle() (common.Address, error)

+ func (_OptimismPortal *OptimismPortalCallerSession) SystemConfig() (common.Address, error)

type OptimismPortalSession

+ func (_OptimismPortal *OptimismPortalSession) Guardian() (common.Address, error)

+ func (_OptimismPortal *OptimismPortalSession) L2Oracle() (common.Address, error)

+ func (_OptimismPortal *OptimismPortalSession) SystemConfig() (common.Address, error)

type PreimageOracleSession

+ func (_PreimageOracle *PreimageOracleSession) LoadLocalData(_ident *big.Int, _word [32]byte, _size *big.Int, _partOffset *big.Int) (*types.Transaction, error)

type PreimageOracleTransactor

+ func (_PreimageOracle *PreimageOracleTransactor) LoadLocalData(opts *bind.TransactOpts, _ident *big.Int, _word [32]byte, _size *big.Int, ...) (*types.Transaction, error)

type PreimageOracleTransactorSession

+ func (_PreimageOracle *PreimageOracleTransactorSession) LoadLocalData(_ident *big.Int, _word [32]byte, _size *big.Int, _partOffset *big.Int) (*types.Transaction, error)

+ type Signature struct

+ R [32]byte

+ S [32]byte

+ V uint8

type StandardBridgeCaller

+ func (_StandardBridge *StandardBridgeCaller) OtherBridge(opts *bind.CallOpts) (common.Address, error)

type StandardBridgeCallerSession

+ func (_StandardBridge *StandardBridgeCallerSession) OtherBridge() (common.Address, error)

type StandardBridgeFilterer

+ func (_StandardBridge *StandardBridgeFilterer) FilterInitialized(opts *bind.FilterOpts) (*StandardBridgeInitializedIterator, error)

+ func (_StandardBridge *StandardBridgeFilterer) ParseInitialized(log types.Log) (*StandardBridgeInitialized, 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 StandardBridgeSession

+ func (_StandardBridge *StandardBridgeSession) OtherBridge() (common.Address, 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)

v1.1.4-rc.1

Aug 16, 2023

v1.1.2

Jul 25, 2023

Changes in this version

+ const AddressManagerStorageLayoutJSON

+ const AlphabetVMStorageLayoutJSON

+ const BaseFeeVaultStorageLayoutJSON

+ const CrossDomainMessengerStorageLayoutJSON

+ const DisputeGameFactoryStorageLayoutJSON

+ const EASStorageLayoutJSON

+ const ERC20StorageLayoutJSON

+ const FaultDisputeGameStorageLayoutJSON

+ const GasPriceOracleStorageLayoutJSON

+ const L1ERC721BridgeStorageLayoutJSON

+ const L1FeeVaultStorageLayoutJSON

+ const L1StandardBridgeStorageLayoutJSON

+ const L2OutputOracleStorageLayoutJSON

+ const MIPSStorageLayoutJSON

+ const OptimismMintableERC20StorageLayoutJSON

+ const PreimageOracleStorageLayoutJSON

+ const SchemaRegistryStorageLayoutJSON

+ const StandardBridgeStorageLayoutJSON

+ var AddressManagerStorageLayout = new(solc.StorageLayout)

+ var AlphabetVMABI = AlphabetVMMetaData.ABI

+ var AlphabetVMBin = AlphabetVMMetaData.Bin

+ var AlphabetVMDeployedBin = "0x608060405234801561001057600080fd5b506004361061002b5760003560e01c8063f8e0cb9614610030575b600080fd5b61004361003e366004610157565b610055565b60405190815260200160405180910390f35b60008060007f0000000000000000000000000000000000000000000000000000000000000000878760405161008b9291906101c3565b6040518091039020036100af57600091506100a8868801886101d3565b90506100ce565b6100bb868801886101ec565b9092509050816100ca8161023d565b9250505b816100da826001610275565b6040805160208101939093528201526060016040516020818303038152906040528051906020012092505050949350505050565b60008083601f84011261012057600080fd5b50813567ffffffffffffffff81111561013857600080fd5b60208301915083602082850101111561015057600080fd5b9250929050565b6000806000806040858703121561016d57600080fd5b843567ffffffffffffffff8082111561018557600080fd5b6101918883890161010e565b909650945060208701359150808211156101aa57600080fd5b506101b78782880161010e565b95989497509550505050565b8183823760009101908152919050565b6000602082840312156101e557600080fd5b5035919050565b600080604083850312156101ff57600080fd5b50508035926020909101359150565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff820361026e5761026e61020e565b5060010190565b600082198211156102885761028861020e565b50019056fea164736f6c634300080f000a"

+ var AlphabetVMMetaData = &bind.MetaData

+ var AlphabetVMStorageLayout = new(solc.StorageLayout)

+ var BaseFeeVaultStorageLayout = new(solc.StorageLayout)

+ var CrossDomainMessengerABI = CrossDomainMessengerMetaData.ABI

+ var CrossDomainMessengerDeployedBin = "0x"

+ var CrossDomainMessengerMetaData = &bind.MetaData

+ var CrossDomainMessengerStorageLayout = 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 L1ERC721BridgeStorageLayout = new(solc.StorageLayout)

+ var L1FeeVaultStorageLayout = new(solc.StorageLayout)

+ var L1StandardBridgeStorageLayout = new(solc.StorageLayout)

+ var L2OutputOracleStorageLayout = new(solc.StorageLayout)

+ var MIPSABI = MIPSMetaData.ABI

+ var MIPSBin = MIPSMetaData.Bin

+ var MIPSMetaData = &bind.MetaData

+ var MIPSStorageLayout = new(solc.StorageLayout)

+ var OptimismMintableERC20StorageLayout = new(solc.StorageLayout)

+ var PreimageOracleABI = PreimageOracleMetaData.ABI

+ var PreimageOracleBin = PreimageOracleMetaData.Bin

+ var PreimageOracleDeployedSourceMap = "144:4615:32:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;357:68;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;413:25:104;;;401:2;386:18;357:68:32;;;;;;;;501:66;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;614:14:104;;607:22;589:41;;577:2;562:18;501:66:32;449:187:104;2154:850:32;;;;;;:::i;:::-;;:::i;838:564::-;;;;;;:::i;:::-;;:::i;:::-;;;;1581:25:104;;;1637:2;1622:18;;1615:34;;;;1554:18;838:564:32;1407:248:104;3295:1462:32;;;;;;:::i;:::-;;:::i;:::-;;1744:262;;;;;;:::i;:::-;1877:19;;;;:14;:19;;;;;;;;:31;;;;;;;;:38;;;;1911:4;1877:38;;;;;;1925:18;;;;;;;;:30;;;;;;;;;:37;;;;1972:20;;;;;;;;;;:27;1744:262;238:50;;;;;;:::i;:::-;;;;;;;;;;;;;;;2154:850;2321:4;2308:18;2567:3;2563:14;;;2458:4;2551:27;2231:12;;2598:11;2308:18;2718:16;2598:11;2700:41;2840:20;2954:19;2947:27;2976:11;2944:44;;2154:850;-1:-1:-1;;;2154:850:32:o;838:564::-;938:12;991:20;;;:14;:20;;;;;;;;:29;;;;;;;;;938:12;;991:29;;983:62;;;;;;;3101:2:104;983:62:32;;;3083:21:104;3140:2;3120:18;;;3113:30;3179:22;3159:18;;;3152:50;3219:18;;983:62:32;;;;;;;;-1:-1:-1;1176:14:32;1193:21;;;1164:2;1193:21;;;;;;;;1244:10;1193:21;1253:1;1244:10;:::i;:::-;1228:12;:7;1238:2;1228:12;:::i;:::-;:26;1224:87;;1293:7;1280:10;:6;1289:1;1280:10;:::i;:::-;:20;;;;:::i;:::-;1270:30;;1224:87;-1:-1:-1;1367:19:32;;;;:13;:19;;;;;;;;:28;;;;;;;;;;;;838:564;;-1:-1:-1;838:564:32:o;3295:1462::-;3591:4;3578:18;3396:12;;3720:1;3710:12;;3694:29;;3691:77;;;3752:1;3749;3742:12;3691:77;4011:3;4007:14;;;3911:4;3995:27;4042:11;4016:4;4161:16;4042:11;4143:41;4374:29;;;4378:11;4374:29;4368:36;4426:20;;;;4573:19;4566:27;4595:11;4563:44;4626:19;;;;4604:1;4626:19;;;;;;;;:32;;;;;;;;:39;;;;4661:4;4626:39;;;;;;4675:18;;;;;;;;:31;;;;;;;;;:38;;;;4723:20;;;;;;;;;;;:27;;;;-1:-1:-1;;;;3295:1462:32:o;14:248:104:-;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:104;;;252:2;237:18;;;224:32;;-1:-1:-1;14:248:104:o;641:347::-;692:8;702:6;756:3;749:4;741:6;737:17;733:27;723:55;;774:1;771;764:12;723:55;-1:-1:-1;797:20:104;;840:18;829:30;;826:50;;;872:1;869;862:12;826:50;909:4;901:6;897:17;885:29;;961:3;954:4;945:6;937;933:19;929:30;926:39;923:59;;;978:1;975;968:12;923:59;641:347;;;;;:::o;993:409::-;1063:6;1071;1124:2;1112:9;1103:7;1099:23;1095:32;1092:52;;;1140:1;1137;1130:12;1092:52;1180:9;1167:23;1213:18;1205:6;1202:30;1199:50;;;1245:1;1242;1235:12;1199:50;1284:58;1334:7;1325:6;1314:9;1310:22;1284:58;:::i;:::-;1361:8;;1258:84;;-1:-1:-1;993:409:104;-1:-1:-1;;;;993:409:104:o;1660:477::-;1739:6;1747;1755;1808:2;1796:9;1787:7;1783:23;1779:32;1776:52;;;1824:1;1821;1814:12;1776:52;1860:9;1847:23;1837:33;;1921:2;1910:9;1906:18;1893:32;1948:18;1940:6;1937:30;1934:50;;;1980:1;1977;1970:12;1934:50;2019:58;2069:7;2060:6;2049:9;2045:22;2019:58;:::i;:::-;1660:477;;2096:8;;-1:-1:-1;1993:84:104;;-1:-1:-1;;;;1660:477:104:o;2142:385::-;2228:6;2236;2244;2252;2305:3;2293:9;2284:7;2280:23;2276:33;2273:53;;;2322:1;2319;2312:12;2273:53;-1:-1:-1;;2345:23:104;;;2415:2;2400:18;;2387:32;;-1:-1:-1;2466:2:104;2451:18;;2438:32;;2517:2;2502:18;2489:32;;-1:-1:-1;2142:385:104;-1:-1:-1;2142:385:104:o;2532:180::-;2591:6;2644:2;2632:9;2623:7;2619:23;2615:32;2612:52;;;2660:1;2657;2650:12;2612:52;-1:-1:-1;2683:23:104;;2532:180;-1:-1:-1;2532:180:104:o;3248:184::-;3300:77;3297:1;3290:88;3397:4;3394:1;3387:15;3421:4;3418:1;3411:15;3437:125;3502:9;;;3523:10;;;3520:36;;;3536:18;;:::i;:::-;3437:125;;;;:::o;3567:128::-;3634:9;;;3655:11;;;3652:37;;;3669:18;;:::i"

+ var PreimageOracleMetaData = &bind.MetaData

+ var PreimageOracleStorageLayout = new(solc.StorageLayout)

+ var SchemaRegistryABI = SchemaRegistryMetaData.ABI

+ var SchemaRegistryBin = SchemaRegistryMetaData.Bin

+ var SchemaRegistryMetaData = &bind.MetaData

+ var SchemaRegistryStorageLayout = new(solc.StorageLayout)

+ var StandardBridgeABI = StandardBridgeMetaData.ABI

+ var StandardBridgeDeployedBin = "0x"

+ var StandardBridgeMetaData = &bind.MetaData

+ var StandardBridgeStorageLayout = new(solc.StorageLayout)

+ 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) Step(opts *bind.CallOpts, _stateData []byte, arg1 []byte) ([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) Step(_stateData []byte, arg1 []byte) ([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) Step(_stateData []byte, arg1 []byte) ([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 BaseFeeVaultCaller

+ func (_BaseFeeVault *BaseFeeVaultCaller) WITHDRAWALNETWORK(opts *bind.CallOpts) (uint8, error)

type BaseFeeVaultCallerSession

+ func (_BaseFeeVault *BaseFeeVaultCallerSession) WITHDRAWALNETWORK() (uint8, error)

type BaseFeeVaultFilterer

+ func (_BaseFeeVault *BaseFeeVaultFilterer) FilterWithdrawal0(opts *bind.FilterOpts) (*BaseFeeVaultWithdrawal0Iterator, error)

+ func (_BaseFeeVault *BaseFeeVaultFilterer) ParseWithdrawal0(log types.Log) (*BaseFeeVaultWithdrawal0, error)

+ func (_BaseFeeVault *BaseFeeVaultFilterer) WatchWithdrawal0(opts *bind.WatchOpts, sink chan<- *BaseFeeVaultWithdrawal0) (event.Subscription, error)

type BaseFeeVaultSession

+ func (_BaseFeeVault *BaseFeeVaultSession) WITHDRAWALNETWORK() (uint8, error)

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

+ Attester common.Address

+ Data AttestationRequestData

+ Schema [32]byte

+ Signature EIP712Signature

+ type DelegatedRevocationRequest struct

+ Data RevocationRequestData

+ Revoker common.Address

+ Schema [32]byte

+ Signature EIP712Signature

+ 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, extraData []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

+ Schema [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) 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) 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) 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 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

+ Schema [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) 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) 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) 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 EIP712Signature struct

+ R [32]byte

+ S [32]byte

+ V uint8

+ type ERC20VotesCheckpoint struct

+ FromBlock uint32

+ Votes *big.Int

+ type FaultDisputeGame struct

+ func DeployFaultDisputeGame(auth *bind.TransactOpts, backend bind.ContractBackend, ...) (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) 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) GameStart(opts *bind.CallOpts) (uint64, error)

+ func (_FaultDisputeGame *FaultDisputeGameCaller) GameType(opts *bind.CallOpts) (uint8, error)

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

+ func (_FaultDisputeGame *FaultDisputeGameCaller) MAXGAMEDEPTH(opts *bind.CallOpts) (*big.Int, 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) 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) GameStart() (uint64, error)

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) GameType() (uint8, error)

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

+ func (_FaultDisputeGame *FaultDisputeGameCallerSession) MAXGAMEDEPTH() (*big.Int, 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) Attack(_parentIndex *big.Int, _claim [32]byte) (*types.Transaction, 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) GameStart() (uint64, error)

+ func (_FaultDisputeGame *FaultDisputeGameSession) GameType() (uint8, error)

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

+ func (_FaultDisputeGame *FaultDisputeGameSession) L2BlockNumber() (*big.Int, 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) Resolve() (*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) 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) 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) 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) Step(_claimIndex *big.Int, _isAttack bool, _stateData []byte, _proof []byte) (*types.Transaction, 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 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 MIPS struct

+ func DeployMIPS(auth *bind.TransactOpts, backend bind.ContractBackend) (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) (*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) (*types.Transaction, error)

+ type MultiAttestationRequest struct

+ Data []AttestationRequestData

+ Schema [32]byte

+ type MultiDelegatedAttestationRequest struct

+ Attester common.Address

+ Data []AttestationRequestData

+ Schema [32]byte

+ Signatures []EIP712Signature

+ type MultiDelegatedRevocationRequest struct

+ Data []RevocationRequestData

+ Revoker common.Address

+ Schema [32]byte

+ Signatures []EIP712Signature

+ type MultiRevocationRequest struct

+ Data []RevocationRequestData

+ Schema [32]byte

+ 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) ComputePreimageKey(opts *bind.CallOpts, _preimage []byte) ([32]byte, 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) ComputePreimageKey(_preimage []byte) ([32]byte, error)

+ 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) Cheat(partOffset *big.Int, key [32]byte, part [32]byte, size *big.Int) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleSession) ComputePreimageKey(_preimage []byte) ([32]byte, error)

+ func (_PreimageOracle *PreimageOracleSession) LoadKeccak256PreimagePart(_partOffset *big.Int, _preimage []byte) (*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) Cheat(opts *bind.TransactOpts, partOffset *big.Int, key [32]byte, part [32]byte, ...) (*types.Transaction, error)

+ func (_PreimageOracle *PreimageOracleTransactor) LoadKeccak256PreimagePart(opts *bind.TransactOpts, _partOffset *big.Int, _preimage []byte) (*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) Cheat(partOffset *big.Int, key [32]byte, part [32]byte, size *big.Int) (*types.Transaction, error)

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

+ type RevocationRequest struct

+ Data RevocationRequestData

+ Schema [32]byte

+ type RevocationRequestData struct

+ Uid [32]byte

+ Value *big.Int

+ 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) (*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

+ 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 SequencerFeeVaultCaller

+ func (_SequencerFeeVault *SequencerFeeVaultCaller) WITHDRAWALNETWORK(opts *bind.CallOpts) (uint8, error)

type SequencerFeeVaultCallerSession

+ func (_SequencerFeeVault *SequencerFeeVaultCallerSession) WITHDRAWALNETWORK() (uint8, error)

type SequencerFeeVaultFilterer

+ func (_SequencerFeeVault *SequencerFeeVaultFilterer) FilterWithdrawal0(opts *bind.FilterOpts) (*SequencerFeeVaultWithdrawal0Iterator, error)

+ func (_SequencerFeeVault *SequencerFeeVaultFilterer) ParseWithdrawal0(log types.Log) (*SequencerFeeVaultWithdrawal0, error)

+ func (_SequencerFeeVault *SequencerFeeVaultFilterer) WatchWithdrawal0(opts *bind.WatchOpts, sink chan<- *SequencerFeeVaultWithdrawal0) (event.Subscription, error)

type SequencerFeeVaultSession

+ func (_SequencerFeeVault *SequencerFeeVaultSession) WITHDRAWALNETWORK() (uint8, error)

+ 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 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)

+ 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)

+ 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) 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) 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)

+ 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) 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)

v1.0.9

May 22, 2023

v1.0.8

May 15, 2023

v1.0.7

May 8, 2023

v1.0.6

May 1, 2023

Changes in this version

type L1CrossDomainMessengerCaller

+ 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)

type L1CrossDomainMessengerCallerSession

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) RELAYCALLOVERHEAD() (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) RELAYCONSTANTOVERHEAD() (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) RELAYGASCHECKBUFFER() (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerCallerSession) RELAYRESERVEDGAS() (uint64, error)

type L1CrossDomainMessengerSession

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) RELAYCALLOVERHEAD() (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) RELAYCONSTANTOVERHEAD() (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) RELAYGASCHECKBUFFER() (uint64, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerSession) RELAYRESERVEDGAS() (uint64, error)

type L2CrossDomainMessengerCaller

+ 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)

type L2CrossDomainMessengerCallerSession

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) RELAYCALLOVERHEAD() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) RELAYCONSTANTOVERHEAD() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) RELAYGASCHECKBUFFER() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) RELAYRESERVEDGAS() (uint64, error)

type L2CrossDomainMessengerSession

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) RELAYCALLOVERHEAD() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) RELAYCONSTANTOVERHEAD() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) RELAYGASCHECKBUFFER() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) RELAYRESERVEDGAS() (uint64, error)

type OptimismPortalCaller

+ func (_OptimismPortal *OptimismPortalCaller) MinimumGasLimit(opts *bind.CallOpts, _byteCount uint64) (uint64, error)

type OptimismPortalCallerSession

+ func (_OptimismPortal *OptimismPortalCallerSession) MinimumGasLimit(_byteCount uint64) (uint64, error)

type OptimismPortalSession

+ func (_OptimismPortal *OptimismPortalSession) MinimumGasLimit(_byteCount uint64) (uint64, error)

v1.0.5

Apr 24, 2023

v1.0.4

Apr 17, 2023

v1.0.3

Apr 10, 2023

v1.0.2

Apr 3, 2023

v1.0.1

Mar 27, 2023

Changes in this version

+ const DeployerWhitelistStorageLayoutJSON

+ const GovernanceTokenStorageLayoutJSON

+ const L1BlockNumberStorageLayoutJSON

+ const L1BlockStorageLayoutJSON

+ const L1CrossDomainMessengerStorageLayoutJSON

+ const L2CrossDomainMessengerStorageLayoutJSON

+ const L2ERC721BridgeStorageLayoutJSON

+ const L2StandardBridgeStorageLayoutJSON

+ const L2ToL1MessagePasserStorageLayoutJSON

+ const LegacyERC20ETHStorageLayoutJSON

+ const LegacyMessagePasserStorageLayoutJSON

+ const OptimismMintableERC20FactoryStorageLayoutJSON

+ const OptimismMintableERC721FactoryStorageLayoutJSON

+ const OptimismPortalStorageLayoutJSON

+ const ProxyAdminStorageLayoutJSON

+ const ProxyStorageLayoutJSON

+ const SequencerFeeVaultStorageLayoutJSON

+ const SystemConfigStorageLayoutJSON

+ const WETH9StorageLayoutJSON

+ var AddressManagerABI = AddressManagerMetaData.ABI

+ var AddressManagerBin = AddressManagerMetaData.Bin

+ var AddressManagerMetaData = &bind.MetaData

+ var BaseFeeVaultABI = BaseFeeVaultMetaData.ABI

+ var BaseFeeVaultBin = BaseFeeVaultMetaData.Bin

+ var BaseFeeVaultMetaData = &bind.MetaData

+ var DeployerWhitelistABI = DeployerWhitelistMetaData.ABI

+ var DeployerWhitelistBin = DeployerWhitelistMetaData.Bin

+ var DeployerWhitelistMetaData = &bind.MetaData

+ var DeployerWhitelistStorageLayout = 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 GovernanceTokenStorageLayout = new(solc.StorageLayout)

+ var L1BlockABI = L1BlockMetaData.ABI

+ var L1BlockBin = L1BlockMetaData.Bin

+ var L1BlockMetaData = &bind.MetaData

+ var L1BlockNumberABI = L1BlockNumberMetaData.ABI

+ var L1BlockNumberBin = L1BlockNumberMetaData.Bin

+ var L1BlockNumberMetaData = &bind.MetaData

+ var L1BlockNumberStorageLayout = new(solc.StorageLayout)

+ 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 L1FeeVaultABI = L1FeeVaultMetaData.ABI

+ var L1FeeVaultBin = L1FeeVaultMetaData.Bin

+ var L1FeeVaultMetaData = &bind.MetaData

+ var L1StandardBridgeABI = L1StandardBridgeMetaData.ABI

+ var L1StandardBridgeBin = L1StandardBridgeMetaData.Bin

+ var L1StandardBridgeMetaData = &bind.MetaData

+ 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 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 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 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 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 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 SequencerFeeVaultABI = SequencerFeeVaultMetaData.ABI

+ var SequencerFeeVaultBin = SequencerFeeVaultMetaData.Bin

+ var SequencerFeeVaultMetaData = &bind.MetaData

+ var SequencerFeeVaultStorageLayout = new(solc.StorageLayout)

+ var SystemConfigABI = SystemConfigMetaData.ABI

+ var SystemConfigBin = SystemConfigMetaData.Bin

+ var SystemConfigMetaData = &bind.MetaData

+ var SystemConfigStorageLayout = new(solc.StorageLayout)

+ var WETH9ABI = WETH9MetaData.ABI

+ var WETH9Bin = WETH9MetaData.Bin

+ var WETH9MetaData = &bind.MetaData

+ var WETH9StorageLayout = new(solc.StorageLayout)

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

+ func GetStorageLayout(name string) (*solc.StorageLayout, error)

+ 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 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)

+ 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)

+ 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) ParseWithdrawal(log types.Log) (*BaseFeeVaultWithdrawal, error)

+ func (_BaseFeeVault *BaseFeeVaultFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *BaseFeeVaultWithdrawal) (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) 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 BaseFeeVaultWithdrawalIterator struct

+ Event *BaseFeeVaultWithdrawal

+ func (it *BaseFeeVaultWithdrawalIterator) Close() error

+ func (it *BaseFeeVaultWithdrawalIterator) Error() error

+ func (it *BaseFeeVaultWithdrawalIterator) Next() bool

+ 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 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) 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) 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) 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 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) 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) Version() (string, error)

+ type L1BlockFilterer struct

+ func NewL1BlockFilterer(address common.Address, filterer bind.ContractFilterer) (*L1BlockFilterer, error)

+ 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 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) 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) MINGASCONSTANTOVERHEAD(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) 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) MINGASCONSTANTOVERHEAD() (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) 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) FilterRelayedMessage(opts *bind.FilterOpts, msgHash [][32]byte) (*L1CrossDomainMessengerRelayedMessageIterator, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) FilterSentMessage(opts *bind.FilterOpts, target []common.Address) (*L1CrossDomainMessengerSentMessageIterator, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) FilterSentMessageExtension1(opts *bind.FilterOpts, sender []common.Address) (*L1CrossDomainMessengerSentMessageExtension1Iterator, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) ParseFailedRelayedMessage(log types.Log) (*L1CrossDomainMessengerFailedRelayedMessage, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) ParseInitialized(log types.Log) (*L1CrossDomainMessengerInitialized, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) ParseRelayedMessage(log types.Log) (*L1CrossDomainMessengerRelayedMessage, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) ParseSentMessage(log types.Log) (*L1CrossDomainMessengerSentMessage, error)

+ func (_L1CrossDomainMessenger *L1CrossDomainMessengerFilterer) ParseSentMessageExtension1(log types.Log) (*L1CrossDomainMessengerSentMessageExtension1, 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) 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) WatchSentMessageExtension1(opts *bind.WatchOpts, sink chan<- *L1CrossDomainMessengerSentMessageExtension1, ...) (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 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

+ 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 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) MINGASCONSTANTOVERHEAD() (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) 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 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) Messenger(opts *bind.CallOpts) (common.Address, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeCaller) OTHERBRIDGE(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) Messenger() (common.Address, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeCallerSession) OTHERBRIDGE() (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) Messenger() (common.Address, error)

+ func (_L1ERC721Bridge *L1ERC721BridgeSession) OTHERBRIDGE() (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)

+ 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)

+ 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)

+ 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) L2TokenBridge(opts *bind.CallOpts) (common.Address, error)

+ func (_L1StandardBridge *L1StandardBridgeCaller) MESSENGER(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)

+ 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) L2TokenBridge() (common.Address, error)

+ func (_L1StandardBridge *L1StandardBridgeCallerSession) MESSENGER() (common.Address, 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 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 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 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 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) 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) 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) 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) ParseERC20BridgeFinalized(log types.Log) (*L1StandardBridgeERC20BridgeFinalized, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) ParseERC20BridgeInitiated(log types.Log) (*L1StandardBridgeERC20BridgeInitiated, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) ParseERC20DepositInitiated(log types.Log) (*L1StandardBridgeERC20DepositInitiated, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) ParseERC20WithdrawalFinalized(log types.Log) (*L1StandardBridgeERC20WithdrawalFinalized, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) ParseETHBridgeFinalized(log types.Log) (*L1StandardBridgeETHBridgeFinalized, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) ParseETHBridgeInitiated(log types.Log) (*L1StandardBridgeETHBridgeInitiated, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) ParseETHDepositInitiated(log types.Log) (*L1StandardBridgeETHDepositInitiated, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) ParseETHWithdrawalFinalized(log types.Log) (*L1StandardBridgeETHWithdrawalFinalized, 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) 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) WatchETHBridgeFinalized(opts *bind.WatchOpts, sink chan<- *L1StandardBridgeETHBridgeFinalized, ...) (event.Subscription, error)

+ func (_L1StandardBridge *L1StandardBridgeFilterer) WatchETHBridgeInitiated(opts *bind.WatchOpts, sink chan<- *L1StandardBridgeETHBridgeInitiated, ...) (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)

+ 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) 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) 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) 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) L2TokenBridge() (common.Address, error)

+ func (_L1StandardBridge *L1StandardBridgeSession) MESSENGER() (common.Address, 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) 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) 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) 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) 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) 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) 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) 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) 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) L1CrossDomainMessenger(opts *bind.CallOpts) (common.Address, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) MESSAGEVERSION(opts *bind.CallOpts) (uint16, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) MINGASCALLDATAOVERHEAD(opts *bind.CallOpts) (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCaller) MINGASCONSTANTOVERHEAD(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) 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) L1CrossDomainMessenger() (common.Address, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) MESSAGEVERSION() (uint16, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) MINGASCALLDATAOVERHEAD() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerCallerSession) MINGASCONSTANTOVERHEAD() (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) 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) FilterRelayedMessage(opts *bind.FilterOpts, msgHash [][32]byte) (*L2CrossDomainMessengerRelayedMessageIterator, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) FilterSentMessage(opts *bind.FilterOpts, target []common.Address) (*L2CrossDomainMessengerSentMessageIterator, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) FilterSentMessageExtension1(opts *bind.FilterOpts, sender []common.Address) (*L2CrossDomainMessengerSentMessageExtension1Iterator, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) ParseFailedRelayedMessage(log types.Log) (*L2CrossDomainMessengerFailedRelayedMessage, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) ParseInitialized(log types.Log) (*L2CrossDomainMessengerInitialized, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) ParseRelayedMessage(log types.Log) (*L2CrossDomainMessengerRelayedMessage, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) ParseSentMessage(log types.Log) (*L2CrossDomainMessengerSentMessage, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerFilterer) ParseSentMessageExtension1(log types.Log) (*L2CrossDomainMessengerSentMessageExtension1, 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) 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) WatchSentMessageExtension1(opts *bind.WatchOpts, sink chan<- *L2CrossDomainMessengerSentMessageExtension1, ...) (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 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

+ 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 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) L1CrossDomainMessenger() (common.Address, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) MESSAGEVERSION() (uint16, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) MINGASCALLDATAOVERHEAD() (uint64, error)

+ func (_L2CrossDomainMessenger *L2CrossDomainMessengerSession) MINGASCONSTANTOVERHEAD() (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) 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 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) Messenger(opts *bind.CallOpts) (common.Address, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeCaller) OTHERBRIDGE(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) Messenger() (common.Address, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeCallerSession) OTHERBRIDGE() (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) Messenger() (common.Address, error)

+ func (_L2ERC721Bridge *L2ERC721BridgeSession) OTHERBRIDGE() (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) CHALLENGER(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) GetL2Output(opts *bind.CallOpts, _l2OutputIndex *big.Int) (TypesOutputProposal, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) GetL2OutputAfter(opts *bind.CallOpts, _l2BlockNumber *big.Int) (TypesOutputProposal, error)

+ func (_L2OutputOracle *L2OutputOracleCaller) GetL2OutputIndexAfter(opts *bind.CallOpts, _l2BlockNumber *big.Int) (*big.Int, 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) PROPOSER(opts *bind.CallOpts) (common.Address, 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) 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) CHALLENGER() (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) ComputeL2Timestamp(_l2BlockNumber *big.Int) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) FINALIZATIONPERIODSECONDS() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) GetL2Output(_l2OutputIndex *big.Int) (TypesOutputProposal, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) GetL2OutputAfter(_l2BlockNumber *big.Int) (TypesOutputProposal, error)

+ func (_L2OutputOracle *L2OutputOracleCallerSession) GetL2OutputIndexAfter(_l2BlockNumber *big.Int) (*big.Int, 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) PROPOSER() (common.Address, 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) 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) 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) ParseInitialized(log types.Log) (*L2OutputOracleInitialized, error)

+ func (_L2OutputOracle *L2OutputOracleFilterer) ParseOutputProposed(log types.Log) (*L2OutputOracleOutputProposed, error)

+ func (_L2OutputOracle *L2OutputOracleFilterer) ParseOutputsDeleted(log types.Log) (*L2OutputOracleOutputsDeleted, error)

+ func (_L2OutputOracle *L2OutputOracleFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *L2OutputOracleInitialized) (event.Subscription, 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 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 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 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) CHALLENGER() (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleSession) ComputeL2Timestamp(_l2BlockNumber *big.Int) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleSession) DeleteL2Outputs(_l2OutputIndex *big.Int) (*types.Transaction, error)

+ func (_L2OutputOracle *L2OutputOracleSession) FINALIZATIONPERIODSECONDS() (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleSession) GetL2Output(_l2OutputIndex *big.Int) (TypesOutputProposal, error)

+ func (_L2OutputOracle *L2OutputOracleSession) GetL2OutputAfter(_l2BlockNumber *big.Int) (TypesOutputProposal, error)

+ func (_L2OutputOracle *L2OutputOracleSession) GetL2OutputIndexAfter(_l2BlockNumber *big.Int) (*big.Int, error)

+ func (_L2OutputOracle *L2OutputOracleSession) Initialize(_startingBlockNumber *big.Int, _startingTimestamp *big.Int) (*types.Transaction, 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) PROPOSER() (common.Address, error)

+ func (_L2OutputOracle *L2OutputOracleSession) ProposeL2Output(_outputRoot [32]byte, _l2BlockNumber *big.Int, _l1BlockHash [32]byte, ...) (*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) Version() (string, error)

+ type L2OutputOracleTransactor struct

+ func NewL2OutputOracleTransactor(address common.Address, transactor bind.ContractTransactor) (*L2OutputOracleTransactor, error)

+ func (_L2OutputOracle *L2OutputOracleTransactor) DeleteL2Outputs(opts *bind.TransactOpts, _l2OutputIndex *big.Int) (*types.Transaction, error)

+ func (_L2OutputOracle *L2OutputOracleTransactor) Initialize(opts *bind.TransactOpts, _startingBlockNumber *big.Int, ...) (*types.Transaction, error)

+ func (_L2OutputOracle *L2OutputOracleTransactor) ProposeL2Output(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) DeleteL2Outputs(_l2OutputIndex *big.Int) (*types.Transaction, error)

+ func (_L2OutputOracle *L2OutputOracleTransactorSession) Initialize(_startingBlockNumber *big.Int, _startingTimestamp *big.Int) (*types.Transaction, error)

+ func (_L2OutputOracle *L2OutputOracleTransactorSession) ProposeL2Output(_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) L1TokenBridge(opts *bind.CallOpts) (common.Address, error)

+ func (_L2StandardBridge *L2StandardBridgeCaller) MESSENGER(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)

+ 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) L1TokenBridge() (common.Address, error)

+ func (_L2StandardBridge *L2StandardBridgeCallerSession) MESSENGER() (common.Address, error)

+ func (_L2StandardBridge *L2StandardBridgeCallerSession) Messenger() (common.Address, error)

+ func (_L2StandardBridge *L2StandardBridgeCallerSession) OTHERBRIDGE() (common.Address, error)

+ func (_L2StandardBridge *L2StandardBridgeCallerSession) Version() (string, 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 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) FilterDepositFinalized(opts *bind.FilterOpts, l1Token []common.Address, l2Token []common.Address, ...) (*L2StandardBridgeDepositFinalizedIterator, 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) FilterWithdrawalInitiated(opts *bind.FilterOpts, l1Token []common.Address, l2Token []common.Address, ...) (*L2StandardBridgeWithdrawalInitiatedIterator, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) ParseDepositFinalized(log types.Log) (*L2StandardBridgeDepositFinalized, 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) ParseWithdrawalInitiated(log types.Log) (*L2StandardBridgeWithdrawalInitiated, error)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) WatchDepositFinalized(opts *bind.WatchOpts, sink chan<- *L2StandardBridgeDepositFinalized, ...) (event.Subscription, 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)

+ func (_L2StandardBridge *L2StandardBridgeFilterer) WatchWithdrawalInitiated(opts *bind.WatchOpts, sink chan<- *L2StandardBridgeWithdrawalInitiated, ...) (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) FinalizeDeposit(_l1Token common.Address, _l2Token common.Address, _from common.Address, ...) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeSession) L1TokenBridge() (common.Address, error)

+ func (_L2StandardBridge *L2StandardBridgeSession) MESSENGER() (common.Address, 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)

+ 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 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) FinalizeDeposit(opts *bind.TransactOpts, _l1Token common.Address, _l2Token common.Address, ...) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeTransactor) Receive(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 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) FinalizeDeposit(_l1Token common.Address, _l2Token common.Address, _from common.Address, ...) (*types.Transaction, error)

+ func (_L2StandardBridge *L2StandardBridgeTransactorSession) Receive() (*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 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 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 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, _bridge common.Address) (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) 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) Version() (string, error)

+ type OptimismMintableERC20FactoryFilterer struct

+ func NewOptimismMintableERC20FactoryFilterer(address common.Address, filterer bind.ContractFilterer) (*OptimismMintableERC20FactoryFilterer, 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) ParseOptimismMintableERC20Created(log types.Log) (*OptimismMintableERC20FactoryOptimismMintableERC20Created, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryFilterer) ParseStandardL2TokenCreated(log types.Log) (*OptimismMintableERC20FactoryStandardL2TokenCreated, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryFilterer) WatchOptimismMintableERC20Created(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactoryFilterer) WatchStandardL2TokenCreated(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ 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) CreateOptimismMintableERC20(_remoteToken common.Address, _name string, _symbol string) (*types.Transaction, error)

+ func (_OptimismMintableERC20Factory *OptimismMintableERC20FactorySession) CreateStandardL2Token(_remoteToken common.Address, _name string, _symbol string) (*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) CreateStandardL2Token(opts *bind.TransactOpts, _remoteToken common.Address, _name string, ...) (*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) CreateStandardL2Token(_remoteToken common.Address, _name string, _symbol string) (*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) IsOutputFinalized(opts *bind.CallOpts, _l2OutputIndex *big.Int) (bool, error)

+ func (_OptimismPortal *OptimismPortalCaller) L2ORACLE(opts *bind.CallOpts) (common.Address, error)

+ func (_OptimismPortal *OptimismPortalCaller) L2Sender(opts *bind.CallOpts) (common.Address, 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) 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) IsOutputFinalized(_l2OutputIndex *big.Int) (bool, error)

+ func (_OptimismPortal *OptimismPortalCallerSession) L2ORACLE() (common.Address, error)

+ func (_OptimismPortal *OptimismPortalCallerSession) L2Sender() (common.Address, 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) 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) Initialize(_paused bool) (*types.Transaction, error)

+ func (_OptimismPortal *OptimismPortalSession) IsOutputFinalized(_l2OutputIndex *big.Int) (bool, error)

+ func (_OptimismPortal *OptimismPortalSession) L2ORACLE() (common.Address, error)

+ func (_OptimismPortal *OptimismPortalSession) L2Sender() (common.Address, 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) 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, _paused bool) (*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(_paused bool) (*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 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) AddressManager(opts *bind.CallOpts) (common.Address, 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) ImplementationName(opts *bind.CallOpts, arg0 common.Address) (string, error)

+ func (_ProxyAdmin *ProxyAdminCaller) IsUpgrading(opts *bind.CallOpts) (bool, error)

+ func (_ProxyAdmin *ProxyAdminCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_ProxyAdmin *ProxyAdminCaller) ProxyType(opts *bind.CallOpts, arg0 common.Address) (uint8, 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) AddressManager() (common.Address, error)

+ func (_ProxyAdmin *ProxyAdminCallerSession) GetProxyAdmin(_proxy common.Address) (common.Address, error)

+ func (_ProxyAdmin *ProxyAdminCallerSession) GetProxyImplementation(_proxy common.Address) (common.Address, error)

+ func (_ProxyAdmin *ProxyAdminCallerSession) ImplementationName(arg0 common.Address) (string, error)

+ func (_ProxyAdmin *ProxyAdminCallerSession) IsUpgrading() (bool, error)

+ func (_ProxyAdmin *ProxyAdminCallerSession) Owner() (common.Address, error)

+ func (_ProxyAdmin *ProxyAdminCallerSession) ProxyType(arg0 common.Address) (uint8, 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) AddressManager() (common.Address, error)

+ 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) ImplementationName(arg0 common.Address) (string, error)

+ func (_ProxyAdmin *ProxyAdminSession) IsUpgrading() (bool, error)

+ func (_ProxyAdmin *ProxyAdminSession) Owner() (common.Address, error)

+ func (_ProxyAdmin *ProxyAdminSession) ProxyType(arg0 common.Address) (uint8, error)

+ func (_ProxyAdmin *ProxyAdminSession) RenounceOwnership() (*types.Transaction, 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)

+ 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) 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)

+ 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) 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)

+ 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 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)

+ 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)

+ 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) ParseWithdrawal(log types.Log) (*SequencerFeeVaultWithdrawal, error)

+ func (_SequencerFeeVault *SequencerFeeVaultFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *SequencerFeeVaultWithdrawal) (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) 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 SequencerFeeVaultWithdrawalIterator struct

+ Event *SequencerFeeVaultWithdrawal

+ func (it *SequencerFeeVaultWithdrawalIterator) Close() error

+ func (it *SequencerFeeVaultWithdrawalIterator) Error() error

+ func (it *SequencerFeeVaultWithdrawalIterator) 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) 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) 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) 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) 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) 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) 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) 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) 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) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type TypesOutputProposal struct

+ L2BlockNumber *big.Int

+ OutputRoot [32]byte

+ Timestamp *big.Int

+ type TypesOutputRootProof struct

+ LatestBlockhash [32]byte

+ MessagePasserStorageRoot [32]byte

+ StateRoot [32]byte

+ Version [32]byte

+ type TypesWithdrawalTransaction struct

+ Data []byte

+ GasLimit *big.Int

+ Nonce *big.Int

+ Sender common.Address

+ Target common.Address

+ Value *big.Int

+ 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

Other modules containing this package

github.com/ethereum-optimism/optimism/op-bindings

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