bindings

package

Go to main page

Versions in this module

v0

v0.12.0

Jan 7, 2025

Changes in this version

+ var IERC20ABI = IERC20MetaData.ABI

+ var IERC20MetaData = &bind.MetaData

type AdminSession

+ func (_Admin *AdminSession) SetPortalFeeOracleV2(admin common.Address, portal common.Address, newFeeOracle common.Address) (*types.Transaction, error)

+ func (_Admin *AdminSession) UpgradeFeeOracleV2(admin common.Address, deployer common.Address, proxy common.Address, ...) (*types.Transaction, error)

type AdminTransactor

+ func (_Admin *AdminTransactor) SetPortalFeeOracleV2(opts *bind.TransactOpts, admin common.Address, portal common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminTransactor) UpgradeFeeOracleV2(opts *bind.TransactOpts, admin common.Address, deployer common.Address, ...) (*types.Transaction, error)

type AdminTransactorSession

+ func (_Admin *AdminTransactorSession) SetPortalFeeOracleV2(admin common.Address, portal common.Address, newFeeOracle common.Address) (*types.Transaction, error)

+ func (_Admin *AdminTransactorSession) UpgradeFeeOracleV2(admin common.Address, deployer common.Address, proxy common.Address, ...) (*types.Transaction, error)

+ type FeeOracleV2BaseBytesSet struct

+ BaseBytes uint32

+ DataCostId uint64

+ Raw types.Log

+ type FeeOracleV2BaseBytesSetIterator struct

+ Event *FeeOracleV2BaseBytesSet

+ func (it *FeeOracleV2BaseBytesSetIterator) Close() error

+ func (it *FeeOracleV2BaseBytesSetIterator) Error() error

+ func (it *FeeOracleV2BaseBytesSetIterator) Next() bool

type FeeOracleV2BaseGasLimitSet

+ ChainId uint64

type FeeOracleV2Caller

+ func (_FeeOracleV2 *FeeOracleV2Caller) BaseBytes(opts *bind.CallOpts, dataCostId uint64) (uint32, error)

+ func (_FeeOracleV2 *FeeOracleV2Caller) DataCostParams(opts *bind.CallOpts, dataCostId uint64) (IFeeOracleV2DataCostParams, error)

+ func (_FeeOracleV2 *FeeOracleV2Caller) DataGasPerByte(opts *bind.CallOpts, dataCostId uint64) (uint64, error)

+ func (_FeeOracleV2 *FeeOracleV2Caller) DataGasToken(opts *bind.CallOpts, dataCostId uint64) (uint16, error)

+ func (_FeeOracleV2 *FeeOracleV2Caller) ExecDataCostId(opts *bind.CallOpts, chainId uint64) (uint64, error)

+ func (_FeeOracleV2 *FeeOracleV2Caller) ExecGasToken(opts *bind.CallOpts, chainId uint64) (uint16, error)

+ func (_FeeOracleV2 *FeeOracleV2Caller) TokenToNativeRate(opts *bind.CallOpts, gasToken uint16) (*big.Int, error)

type FeeOracleV2CallerSession

+ func (_FeeOracleV2 *FeeOracleV2CallerSession) BaseBytes(dataCostId uint64) (uint32, error)

+ func (_FeeOracleV2 *FeeOracleV2CallerSession) DataCostParams(dataCostId uint64) (IFeeOracleV2DataCostParams, error)

+ func (_FeeOracleV2 *FeeOracleV2CallerSession) DataGasPerByte(dataCostId uint64) (uint64, error)

+ func (_FeeOracleV2 *FeeOracleV2CallerSession) DataGasToken(dataCostId uint64) (uint16, error)

+ func (_FeeOracleV2 *FeeOracleV2CallerSession) ExecDataCostId(chainId uint64) (uint64, error)

+ func (_FeeOracleV2 *FeeOracleV2CallerSession) ExecGasToken(chainId uint64) (uint16, error)

+ func (_FeeOracleV2 *FeeOracleV2CallerSession) TokenToNativeRate(gasToken uint16) (*big.Int, error)

+ type FeeOracleV2DataCostIdSet struct

+ ChainId uint64

+ DataCostId uint64

+ Raw types.Log

+ type FeeOracleV2DataCostIdSetIterator struct

+ Event *FeeOracleV2DataCostIdSet

+ func (it *FeeOracleV2DataCostIdSetIterator) Close() error

+ func (it *FeeOracleV2DataCostIdSetIterator) Error() error

+ func (it *FeeOracleV2DataCostIdSetIterator) Next() bool

+ type FeeOracleV2DataCostParamsSet struct

+ BaseBytes uint32

+ GasPerByte uint64

+ GasPrice uint64

+ GasToken uint16

+ Id uint64

+ Raw types.Log

+ type FeeOracleV2DataCostParamsSetIterator struct

+ Event *FeeOracleV2DataCostParamsSet

+ func (it *FeeOracleV2DataCostParamsSetIterator) Close() error

+ func (it *FeeOracleV2DataCostParamsSetIterator) Error() error

+ func (it *FeeOracleV2DataCostParamsSetIterator) Next() bool

type FeeOracleV2DataGasPriceSet

+ DataCostId uint64

type FeeOracleV2FeeParamsSet

+ BaseGasLimit uint32

+ DataCostId uint64

+ GasPrice uint64

+ GasToken uint16

type FeeOracleV2Filterer

+ func (_FeeOracleV2 *FeeOracleV2Filterer) FilterBaseBytesSet(opts *bind.FilterOpts) (*FeeOracleV2BaseBytesSetIterator, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) FilterDataCostIdSet(opts *bind.FilterOpts) (*FeeOracleV2DataCostIdSetIterator, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) FilterDataCostParamsSet(opts *bind.FilterOpts) (*FeeOracleV2DataCostParamsSetIterator, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) FilterGasPerByteSet(opts *bind.FilterOpts) (*FeeOracleV2GasPerByteSetIterator, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) ParseBaseBytesSet(log types.Log) (*FeeOracleV2BaseBytesSet, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) ParseDataCostIdSet(log types.Log) (*FeeOracleV2DataCostIdSet, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) ParseDataCostParamsSet(log types.Log) (*FeeOracleV2DataCostParamsSet, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) ParseGasPerByteSet(log types.Log) (*FeeOracleV2GasPerByteSet, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) WatchBaseBytesSet(opts *bind.WatchOpts, sink chan<- *FeeOracleV2BaseBytesSet) (event.Subscription, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) WatchDataCostIdSet(opts *bind.WatchOpts, sink chan<- *FeeOracleV2DataCostIdSet) (event.Subscription, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) WatchDataCostParamsSet(opts *bind.WatchOpts, sink chan<- *FeeOracleV2DataCostParamsSet) (event.Subscription, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) WatchGasPerByteSet(opts *bind.WatchOpts, sink chan<- *FeeOracleV2GasPerByteSet) (event.Subscription, error)

+ type FeeOracleV2GasPerByteSet struct

+ DataCostId uint64

+ GasPerByte uint64

+ Raw types.Log

+ type FeeOracleV2GasPerByteSetIterator struct

+ Event *FeeOracleV2GasPerByteSet

+ func (it *FeeOracleV2GasPerByteSetIterator) Close() error

+ func (it *FeeOracleV2GasPerByteSetIterator) Error() error

+ func (it *FeeOracleV2GasPerByteSetIterator) Next() bool

type FeeOracleV2Session

+ func (_FeeOracleV2 *FeeOracleV2Session) BaseBytes(dataCostId uint64) (uint32, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) BulkSetDataCostParams(params []IFeeOracleV2DataCostParams) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) BulkSetToNativeRate(params []IFeeOracleV2ToNativeRateParams) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) DataCostParams(dataCostId uint64) (IFeeOracleV2DataCostParams, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) DataGasPerByte(dataCostId uint64) (uint64, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) DataGasToken(dataCostId uint64) (uint16, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) ExecDataCostId(chainId uint64) (uint64, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) ExecGasToken(chainId uint64) (uint16, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) SetBaseBytes(dataCostId uint64, newBaseBytes uint32) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) SetDataCostId(chainId uint64, dataCostId uint64) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) SetGasPerByte(dataCostId uint64, gasPerByte uint64) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) TokenToNativeRate(gasToken uint16) (*big.Int, error)

type FeeOracleV2ToNativeRateSet

+ GasToken uint16

+ NativeRate *big.Int

type FeeOracleV2Transactor

+ func (_FeeOracleV2 *FeeOracleV2Transactor) BulkSetDataCostParams(opts *bind.TransactOpts, params []IFeeOracleV2DataCostParams) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Transactor) BulkSetToNativeRate(opts *bind.TransactOpts, params []IFeeOracleV2ToNativeRateParams) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Transactor) SetBaseBytes(opts *bind.TransactOpts, dataCostId uint64, newBaseBytes uint32) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Transactor) SetDataCostId(opts *bind.TransactOpts, chainId uint64, dataCostId uint64) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Transactor) SetGasPerByte(opts *bind.TransactOpts, dataCostId uint64, gasPerByte uint64) (*types.Transaction, error)

type FeeOracleV2TransactorSession

+ func (_FeeOracleV2 *FeeOracleV2TransactorSession) BulkSetDataCostParams(params []IFeeOracleV2DataCostParams) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2TransactorSession) BulkSetToNativeRate(params []IFeeOracleV2ToNativeRateParams) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2TransactorSession) SetBaseBytes(dataCostId uint64, newBaseBytes uint32) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2TransactorSession) SetDataCostId(chainId uint64, dataCostId uint64) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2TransactorSession) SetGasPerByte(dataCostId uint64, gasPerByte uint64) (*types.Transaction, error)

+ type IERC20 struct

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

+ type IERC20Approval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type IERC20ApprovalIterator struct

+ Event *IERC20Approval

+ func (it *IERC20ApprovalIterator) Close() error

+ func (it *IERC20ApprovalIterator) Error() error

+ func (it *IERC20ApprovalIterator) Next() bool

+ type IERC20Caller struct

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

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

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

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

+ type IERC20CallerRaw struct

+ Contract *IERC20Caller

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

+ type IERC20CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC20Caller

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

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

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

+ type IERC20Filterer struct

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

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

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

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

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

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

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

+ type IERC20Raw struct

+ Contract *IERC20

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

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

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

+ type IERC20Session struct

+ CallOpts bind.CallOpts

+ Contract *IERC20

+ TransactOpts bind.TransactOpts

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

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

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

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

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

+ func (_IERC20 *IERC20Session) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error)

+ type IERC20Transactor struct

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

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

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

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

+ type IERC20TransactorRaw struct

+ Contract *IERC20Transactor

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

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

+ type IERC20TransactorSession struct

+ Contract *IERC20Transactor

+ TransactOpts bind.TransactOpts

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

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

+ func (_IERC20 *IERC20TransactorSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error)

+ type IERC20Transfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type IERC20TransferIterator struct

+ Event *IERC20Transfer

+ func (it *IERC20TransferIterator) Close() error

+ func (it *IERC20TransferIterator) Error() error

+ func (it *IERC20TransferIterator) Next() bool

+ type IFeeOracleV2DataCostParams struct

+ BaseBytes uint32

+ GasPerByte uint64

+ GasPrice uint64

+ GasToken uint16

+ Id uint64

type IFeeOracleV2FeeParams

+ BaseGasLimit uint32

+ DataCostId uint64

+ GasPrice uint64

+ GasToken uint16

+ type IFeeOracleV2ToNativeRateParams struct

+ GasToken uint16

+ NativeRate *big.Int

type SolveCall

+ ChainId uint64

type SolveInboxCaller

+ func (_SolveInbox *SolveInboxCaller) GetLatestRequestByStatus(opts *bind.CallOpts, status uint8) (SolveRequest, error)

+ func (_SolveInbox *SolveInboxCaller) GetUpdateHistory(opts *bind.CallOpts, id [32]byte) ([]SolveStatusUpdate, error)

type SolveInboxCallerSession

+ func (_SolveInbox *SolveInboxCallerSession) GetLatestRequestByStatus(status uint8) (SolveRequest, error)

+ func (_SolveInbox *SolveInboxCallerSession) GetUpdateHistory(id [32]byte) ([]SolveStatusUpdate, error)

type SolveInboxSession

+ func (_SolveInbox *SolveInboxSession) GetLatestRequestByStatus(status uint8) (SolveRequest, error)

+ func (_SolveInbox *SolveInboxSession) GetUpdateHistory(id [32]byte) ([]SolveStatusUpdate, error)

type SolveRequest

+ History []SolveStatusUpdate

+ type SolveStatusUpdate struct

+ Status uint8

+ Timestamp *big.Int

type StakingSession

+ func (_Staking *StakingSession) DelegateFor(delegator common.Address, validator common.Address) (*types.Transaction, error)

type StakingTransactor

+ func (_Staking *StakingTransactor) DelegateFor(opts *bind.TransactOpts, delegator common.Address, validator common.Address) (*types.Transaction, error)

type StakingTransactorSession

+ func (_Staking *StakingTransactorSession) DelegateFor(delegator common.Address, validator common.Address) (*types.Transaction, error)

v0.11.0

Nov 25, 2024

Changes in this version

+ var FeeOracleV2ABI = FeeOracleV2MetaData.ABI

+ var FeeOracleV2Bin = FeeOracleV2MetaData.Bin

+ var FeeOracleV2MetaData = &bind.MetaData

+ var MockTokenABI = MockTokenMetaData.ABI

+ var MockTokenBin = MockTokenMetaData.Bin

+ var MockTokenMetaData = &bind.MetaData

+ var MockVaultABI = MockVaultMetaData.ABI

+ var MockVaultBin = MockVaultMetaData.Bin

+ var MockVaultMetaData = &bind.MetaData

+ var SolveInboxABI = SolveInboxMetaData.ABI

+ var SolveInboxBin = SolveInboxMetaData.Bin

+ var SolveInboxMetaData = &bind.MetaData

+ var SolveOutboxABI = SolveOutboxMetaData.ABI

+ var SolveOutboxBin = SolveOutboxMetaData.Bin

+ var SolveOutboxMetaData = &bind.MetaData

type Create3Transactor

+ func (_Create3 *Create3Transactor) DeployWithRetry(opts *bind.TransactOpts, salt [32]byte, creationCode []byte) (*types.Transaction, error)

+ type FeeOracleV2 struct

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

+ func NewFeeOracleV2(address common.Address, backend bind.ContractBackend) (*FeeOracleV2, error)

+ type FeeOracleV2BaseGasLimitSet struct

+ BaseGasLimit *big.Int

+ Raw types.Log

+ type FeeOracleV2BaseGasLimitSetIterator struct

+ Event *FeeOracleV2BaseGasLimitSet

+ func (it *FeeOracleV2BaseGasLimitSetIterator) Close() error

+ func (it *FeeOracleV2BaseGasLimitSetIterator) Error() error

+ func (it *FeeOracleV2BaseGasLimitSetIterator) Next() bool

+ type FeeOracleV2Caller struct

+ func NewFeeOracleV2Caller(address common.Address, caller bind.ContractCaller) (*FeeOracleV2Caller, error)

+ func (_FeeOracleV2 *FeeOracleV2Caller) BaseGasLimit(opts *bind.CallOpts) (*big.Int, error)

+ func (_FeeOracleV2 *FeeOracleV2Caller) CONVERSIONRATEDENOM(opts *bind.CallOpts) (*big.Int, error)

+ func (_FeeOracleV2 *FeeOracleV2Caller) DataGasPrice(opts *bind.CallOpts, chainId uint64) (uint64, error)

+ func (_FeeOracleV2 *FeeOracleV2Caller) ExecGasPrice(opts *bind.CallOpts, chainId uint64) (uint64, error)

+ func (_FeeOracleV2 *FeeOracleV2Caller) FeeFor(opts *bind.CallOpts, destChainId uint64, data []byte, gasLimit uint64) (*big.Int, error)

+ func (_FeeOracleV2 *FeeOracleV2Caller) FeeParams(opts *bind.CallOpts, chainId uint64) (IFeeOracleV2FeeParams, error)

+ func (_FeeOracleV2 *FeeOracleV2Caller) Manager(opts *bind.CallOpts) (common.Address, error)

+ func (_FeeOracleV2 *FeeOracleV2Caller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_FeeOracleV2 *FeeOracleV2Caller) ProtocolFee(opts *bind.CallOpts) (*big.Int, error)

+ func (_FeeOracleV2 *FeeOracleV2Caller) ToNativeRate(opts *bind.CallOpts, chainId uint64) (*big.Int, error)

+ func (_FeeOracleV2 *FeeOracleV2Caller) Version(opts *bind.CallOpts) (uint64, error)

+ type FeeOracleV2CallerRaw struct

+ Contract *FeeOracleV2Caller

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

+ type FeeOracleV2CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *FeeOracleV2Caller

+ func (_FeeOracleV2 *FeeOracleV2CallerSession) BaseGasLimit() (*big.Int, error)

+ func (_FeeOracleV2 *FeeOracleV2CallerSession) CONVERSIONRATEDENOM() (*big.Int, error)

+ func (_FeeOracleV2 *FeeOracleV2CallerSession) DataGasPrice(chainId uint64) (uint64, error)

+ func (_FeeOracleV2 *FeeOracleV2CallerSession) ExecGasPrice(chainId uint64) (uint64, error)

+ func (_FeeOracleV2 *FeeOracleV2CallerSession) FeeFor(destChainId uint64, data []byte, gasLimit uint64) (*big.Int, error)

+ func (_FeeOracleV2 *FeeOracleV2CallerSession) FeeParams(chainId uint64) (IFeeOracleV2FeeParams, error)

+ func (_FeeOracleV2 *FeeOracleV2CallerSession) Manager() (common.Address, error)

+ func (_FeeOracleV2 *FeeOracleV2CallerSession) Owner() (common.Address, error)

+ func (_FeeOracleV2 *FeeOracleV2CallerSession) ProtocolFee() (*big.Int, error)

+ func (_FeeOracleV2 *FeeOracleV2CallerSession) ToNativeRate(chainId uint64) (*big.Int, error)

+ func (_FeeOracleV2 *FeeOracleV2CallerSession) Version() (uint64, error)

+ type FeeOracleV2DataGasPriceSet struct

+ ChainId uint64

+ GasPrice uint64

+ Raw types.Log

+ type FeeOracleV2DataGasPriceSetIterator struct

+ Event *FeeOracleV2DataGasPriceSet

+ func (it *FeeOracleV2DataGasPriceSetIterator) Close() error

+ func (it *FeeOracleV2DataGasPriceSetIterator) Error() error

+ func (it *FeeOracleV2DataGasPriceSetIterator) Next() bool

+ type FeeOracleV2ExecGasPriceSet struct

+ ChainId uint64

+ GasPrice uint64

+ Raw types.Log

+ type FeeOracleV2ExecGasPriceSetIterator struct

+ Event *FeeOracleV2ExecGasPriceSet

+ func (it *FeeOracleV2ExecGasPriceSetIterator) Close() error

+ func (it *FeeOracleV2ExecGasPriceSetIterator) Error() error

+ func (it *FeeOracleV2ExecGasPriceSetIterator) Next() bool

+ type FeeOracleV2FeeParamsSet struct

+ ChainId uint64

+ DataGasPrice uint64

+ ExecGasPrice uint64

+ Raw types.Log

+ ToNativeRate uint64

+ type FeeOracleV2FeeParamsSetIterator struct

+ Event *FeeOracleV2FeeParamsSet

+ func (it *FeeOracleV2FeeParamsSetIterator) Close() error

+ func (it *FeeOracleV2FeeParamsSetIterator) Error() error

+ func (it *FeeOracleV2FeeParamsSetIterator) Next() bool

+ type FeeOracleV2Filterer struct

+ func NewFeeOracleV2Filterer(address common.Address, filterer bind.ContractFilterer) (*FeeOracleV2Filterer, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) FilterBaseGasLimitSet(opts *bind.FilterOpts) (*FeeOracleV2BaseGasLimitSetIterator, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) FilterDataGasPriceSet(opts *bind.FilterOpts) (*FeeOracleV2DataGasPriceSetIterator, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) FilterExecGasPriceSet(opts *bind.FilterOpts) (*FeeOracleV2ExecGasPriceSetIterator, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) FilterFeeParamsSet(opts *bind.FilterOpts) (*FeeOracleV2FeeParamsSetIterator, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) FilterInitialized(opts *bind.FilterOpts) (*FeeOracleV2InitializedIterator, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) FilterManagerSet(opts *bind.FilterOpts) (*FeeOracleV2ManagerSetIterator, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*FeeOracleV2OwnershipTransferredIterator, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) FilterProtocolFeeSet(opts *bind.FilterOpts) (*FeeOracleV2ProtocolFeeSetIterator, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) FilterToNativeRateSet(opts *bind.FilterOpts) (*FeeOracleV2ToNativeRateSetIterator, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) ParseBaseGasLimitSet(log types.Log) (*FeeOracleV2BaseGasLimitSet, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) ParseDataGasPriceSet(log types.Log) (*FeeOracleV2DataGasPriceSet, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) ParseExecGasPriceSet(log types.Log) (*FeeOracleV2ExecGasPriceSet, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) ParseFeeParamsSet(log types.Log) (*FeeOracleV2FeeParamsSet, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) ParseInitialized(log types.Log) (*FeeOracleV2Initialized, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) ParseManagerSet(log types.Log) (*FeeOracleV2ManagerSet, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) ParseOwnershipTransferred(log types.Log) (*FeeOracleV2OwnershipTransferred, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) ParseProtocolFeeSet(log types.Log) (*FeeOracleV2ProtocolFeeSet, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) ParseToNativeRateSet(log types.Log) (*FeeOracleV2ToNativeRateSet, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) WatchBaseGasLimitSet(opts *bind.WatchOpts, sink chan<- *FeeOracleV2BaseGasLimitSet) (event.Subscription, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) WatchDataGasPriceSet(opts *bind.WatchOpts, sink chan<- *FeeOracleV2DataGasPriceSet) (event.Subscription, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) WatchExecGasPriceSet(opts *bind.WatchOpts, sink chan<- *FeeOracleV2ExecGasPriceSet) (event.Subscription, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) WatchFeeParamsSet(opts *bind.WatchOpts, sink chan<- *FeeOracleV2FeeParamsSet) (event.Subscription, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *FeeOracleV2Initialized) (event.Subscription, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) WatchManagerSet(opts *bind.WatchOpts, sink chan<- *FeeOracleV2ManagerSet) (event.Subscription, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *FeeOracleV2OwnershipTransferred, ...) (event.Subscription, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) WatchProtocolFeeSet(opts *bind.WatchOpts, sink chan<- *FeeOracleV2ProtocolFeeSet) (event.Subscription, error)

+ func (_FeeOracleV2 *FeeOracleV2Filterer) WatchToNativeRateSet(opts *bind.WatchOpts, sink chan<- *FeeOracleV2ToNativeRateSet) (event.Subscription, error)

+ type FeeOracleV2Initialized struct

+ Raw types.Log

+ Version uint64

+ type FeeOracleV2InitializedIterator struct

+ Event *FeeOracleV2Initialized

+ func (it *FeeOracleV2InitializedIterator) Close() error

+ func (it *FeeOracleV2InitializedIterator) Error() error

+ func (it *FeeOracleV2InitializedIterator) Next() bool

+ type FeeOracleV2ManagerSet struct

+ Manager common.Address

+ Raw types.Log

+ type FeeOracleV2ManagerSetIterator struct

+ Event *FeeOracleV2ManagerSet

+ func (it *FeeOracleV2ManagerSetIterator) Close() error

+ func (it *FeeOracleV2ManagerSetIterator) Error() error

+ func (it *FeeOracleV2ManagerSetIterator) Next() bool

+ type FeeOracleV2OwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type FeeOracleV2OwnershipTransferredIterator struct

+ Event *FeeOracleV2OwnershipTransferred

+ func (it *FeeOracleV2OwnershipTransferredIterator) Close() error

+ func (it *FeeOracleV2OwnershipTransferredIterator) Error() error

+ func (it *FeeOracleV2OwnershipTransferredIterator) Next() bool

+ type FeeOracleV2ProtocolFeeSet struct

+ ProtocolFee *big.Int

+ Raw types.Log

+ type FeeOracleV2ProtocolFeeSetIterator struct

+ Event *FeeOracleV2ProtocolFeeSet

+ func (it *FeeOracleV2ProtocolFeeSetIterator) Close() error

+ func (it *FeeOracleV2ProtocolFeeSetIterator) Error() error

+ func (it *FeeOracleV2ProtocolFeeSetIterator) Next() bool

+ type FeeOracleV2Raw struct

+ Contract *FeeOracleV2

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

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

+ func (_FeeOracleV2 *FeeOracleV2Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type FeeOracleV2Session struct

+ CallOpts bind.CallOpts

+ Contract *FeeOracleV2

+ TransactOpts bind.TransactOpts

+ func (_FeeOracleV2 *FeeOracleV2Session) BaseGasLimit() (*big.Int, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) BulkSetFeeParams(params []IFeeOracleV2FeeParams) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) CONVERSIONRATEDENOM() (*big.Int, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) DataGasPrice(chainId uint64) (uint64, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) ExecGasPrice(chainId uint64) (uint64, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) FeeFor(destChainId uint64, data []byte, gasLimit uint64) (*big.Int, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) FeeParams(chainId uint64) (IFeeOracleV2FeeParams, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) Initialize(owner_ common.Address, manager_ common.Address, baseGasLimit_ *big.Int, ...) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) Manager() (common.Address, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) Owner() (common.Address, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) ProtocolFee() (*big.Int, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) RenounceOwnership() (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) SetBaseGasLimit(gasLimit *big.Int) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) SetDataGasPrice(chainId uint64, gasPrice uint64) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) SetExecGasPrice(chainId uint64, gasPrice uint64) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) SetManager(manager_ common.Address) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) SetProtocolFee(fee *big.Int) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) SetToNativeRate(chainId uint64, rate uint64) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) ToNativeRate(chainId uint64) (*big.Int, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Session) Version() (uint64, error)

+ type FeeOracleV2ToNativeRateSet struct

+ ChainId uint64

+ Raw types.Log

+ ToNativeRate uint64

+ type FeeOracleV2ToNativeRateSetIterator struct

+ Event *FeeOracleV2ToNativeRateSet

+ func (it *FeeOracleV2ToNativeRateSetIterator) Close() error

+ func (it *FeeOracleV2ToNativeRateSetIterator) Error() error

+ func (it *FeeOracleV2ToNativeRateSetIterator) Next() bool

+ type FeeOracleV2Transactor struct

+ func NewFeeOracleV2Transactor(address common.Address, transactor bind.ContractTransactor) (*FeeOracleV2Transactor, error)

+ func (_FeeOracleV2 *FeeOracleV2Transactor) BulkSetFeeParams(opts *bind.TransactOpts, params []IFeeOracleV2FeeParams) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Transactor) Initialize(opts *bind.TransactOpts, owner_ common.Address, manager_ common.Address, ...) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Transactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Transactor) SetBaseGasLimit(opts *bind.TransactOpts, gasLimit *big.Int) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Transactor) SetDataGasPrice(opts *bind.TransactOpts, chainId uint64, gasPrice uint64) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Transactor) SetExecGasPrice(opts *bind.TransactOpts, chainId uint64, gasPrice uint64) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Transactor) SetManager(opts *bind.TransactOpts, manager_ common.Address) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Transactor) SetProtocolFee(opts *bind.TransactOpts, fee *big.Int) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2Transactor) SetToNativeRate(opts *bind.TransactOpts, chainId uint64, rate uint64) (*types.Transaction, error)

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

+ type FeeOracleV2TransactorRaw struct

+ Contract *FeeOracleV2Transactor

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

+ func (_FeeOracleV2 *FeeOracleV2TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type FeeOracleV2TransactorSession struct

+ Contract *FeeOracleV2Transactor

+ TransactOpts bind.TransactOpts

+ func (_FeeOracleV2 *FeeOracleV2TransactorSession) BulkSetFeeParams(params []IFeeOracleV2FeeParams) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2TransactorSession) Initialize(owner_ common.Address, manager_ common.Address, baseGasLimit_ *big.Int, ...) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2TransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2TransactorSession) SetBaseGasLimit(gasLimit *big.Int) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2TransactorSession) SetDataGasPrice(chainId uint64, gasPrice uint64) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2TransactorSession) SetExecGasPrice(chainId uint64, gasPrice uint64) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2TransactorSession) SetManager(manager_ common.Address) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2TransactorSession) SetProtocolFee(fee *big.Int) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2TransactorSession) SetToNativeRate(chainId uint64, rate uint64) (*types.Transaction, error)

+ func (_FeeOracleV2 *FeeOracleV2TransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type IFeeOracleV2FeeParams struct

+ ChainId uint64

+ DataGasPrice uint64

+ ExecGasPrice uint64

+ ToNativeRate uint64

+ type MockToken struct

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

+ func NewMockToken(address common.Address, backend bind.ContractBackend) (*MockToken, error)

+ type MockTokenApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type MockTokenApprovalIterator struct

+ Event *MockTokenApproval

+ func (it *MockTokenApprovalIterator) Close() error

+ func (it *MockTokenApprovalIterator) Error() error

+ func (it *MockTokenApprovalIterator) Next() bool

+ type MockTokenCaller struct

+ func NewMockTokenCaller(address common.Address, caller bind.ContractCaller) (*MockTokenCaller, error)

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

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

+ func (_MockToken *MockTokenCaller) Decimals(opts *bind.CallOpts) (uint8, error)

+ func (_MockToken *MockTokenCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_MockToken *MockTokenCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_MockToken *MockTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type MockTokenCallerRaw struct

+ Contract *MockTokenCaller

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

+ type MockTokenCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *MockTokenCaller

+ func (_MockToken *MockTokenCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_MockToken *MockTokenCallerSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_MockToken *MockTokenCallerSession) Decimals() (uint8, error)

+ func (_MockToken *MockTokenCallerSession) Name() (string, error)

+ func (_MockToken *MockTokenCallerSession) Symbol() (string, error)

+ func (_MockToken *MockTokenCallerSession) TotalSupply() (*big.Int, error)

+ type MockTokenFilterer struct

+ func NewMockTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*MockTokenFilterer, error)

+ func (_MockToken *MockTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*MockTokenApprovalIterator, error)

+ func (_MockToken *MockTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*MockTokenTransferIterator, error)

+ func (_MockToken *MockTokenFilterer) ParseApproval(log types.Log) (*MockTokenApproval, error)

+ func (_MockToken *MockTokenFilterer) ParseTransfer(log types.Log) (*MockTokenTransfer, error)

+ func (_MockToken *MockTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *MockTokenApproval, owner []common.Address, ...) (event.Subscription, error)

+ func (_MockToken *MockTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *MockTokenTransfer, from []common.Address, ...) (event.Subscription, error)

+ type MockTokenRaw struct

+ Contract *MockToken

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

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

+ func (_MockToken *MockTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MockTokenSession struct

+ CallOpts bind.CallOpts

+ Contract *MockToken

+ TransactOpts bind.TransactOpts

+ func (_MockToken *MockTokenSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_MockToken *MockTokenSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error)

+ func (_MockToken *MockTokenSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_MockToken *MockTokenSession) Decimals() (uint8, error)

+ func (_MockToken *MockTokenSession) Mint(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_MockToken *MockTokenSession) Name() (string, error)

+ func (_MockToken *MockTokenSession) Symbol() (string, error)

+ func (_MockToken *MockTokenSession) TotalSupply() (*big.Int, error)

+ func (_MockToken *MockTokenSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error)

+ func (_MockToken *MockTokenSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error)

+ type MockTokenTransactor struct

+ func NewMockTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*MockTokenTransactor, error)

+ func (_MockToken *MockTokenTransactor) Approve(opts *bind.TransactOpts, spender common.Address, value *big.Int) (*types.Transaction, error)

+ func (_MockToken *MockTokenTransactor) Mint(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_MockToken *MockTokenTransactor) Transfer(opts *bind.TransactOpts, to common.Address, value *big.Int) (*types.Transaction, error)

+ func (_MockToken *MockTokenTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ type MockTokenTransactorRaw struct

+ Contract *MockTokenTransactor

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

+ func (_MockToken *MockTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MockTokenTransactorSession struct

+ Contract *MockTokenTransactor

+ TransactOpts bind.TransactOpts

+ func (_MockToken *MockTokenTransactorSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error)

+ func (_MockToken *MockTokenTransactorSession) Mint(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_MockToken *MockTokenTransactorSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error)

+ func (_MockToken *MockTokenTransactorSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error)

+ type MockTokenTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type MockTokenTransferIterator struct

+ Event *MockTokenTransfer

+ func (it *MockTokenTransferIterator) Close() error

+ func (it *MockTokenTransferIterator) Error() error

+ func (it *MockTokenTransferIterator) Next() bool

+ type MockVault struct

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

+ func NewMockVault(address common.Address, backend bind.ContractBackend) (*MockVault, error)

+ type MockVaultCaller struct

+ func NewMockVaultCaller(address common.Address, caller bind.ContractCaller) (*MockVaultCaller, error)

+ func (_MockVault *MockVaultCaller) Balances(opts *bind.CallOpts, depositor common.Address) (*big.Int, error)

+ func (_MockVault *MockVaultCaller) Collateral(opts *bind.CallOpts) (common.Address, error)

+ type MockVaultCallerRaw struct

+ Contract *MockVaultCaller

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

+ type MockVaultCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *MockVaultCaller

+ func (_MockVault *MockVaultCallerSession) Balances(depositor common.Address) (*big.Int, error)

+ func (_MockVault *MockVaultCallerSession) Collateral() (common.Address, error)

+ type MockVaultFilterer struct

+ func NewMockVaultFilterer(address common.Address, filterer bind.ContractFilterer) (*MockVaultFilterer, error)

+ type MockVaultRaw struct

+ Contract *MockVault

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

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

+ func (_MockVault *MockVaultRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MockVaultSession struct

+ CallOpts bind.CallOpts

+ Contract *MockVault

+ TransactOpts bind.TransactOpts

+ func (_MockVault *MockVaultSession) Balances(depositor common.Address) (*big.Int, error)

+ func (_MockVault *MockVaultSession) Collateral() (common.Address, error)

+ func (_MockVault *MockVaultSession) Deposit(onBehalfOf common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_MockVault *MockVaultSession) Withdraw(to common.Address, amount *big.Int) (*types.Transaction, error)

+ type MockVaultTransactor struct

+ func NewMockVaultTransactor(address common.Address, transactor bind.ContractTransactor) (*MockVaultTransactor, error)

+ func (_MockVault *MockVaultTransactor) Deposit(opts *bind.TransactOpts, onBehalfOf common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_MockVault *MockVaultTransactor) Withdraw(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error)

+ type MockVaultTransactorRaw struct

+ Contract *MockVaultTransactor

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

+ func (_MockVault *MockVaultTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MockVaultTransactorSession struct

+ Contract *MockVaultTransactor

+ TransactOpts bind.TransactOpts

+ func (_MockVault *MockVaultTransactorSession) Deposit(onBehalfOf common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_MockVault *MockVaultTransactorSession) Withdraw(to common.Address, amount *big.Int) (*types.Transaction, error)

type OmniBridgeNativeCaller

+ func (_OmniBridgeNative *OmniBridgeNativeCaller) L1Deposits(opts *bind.CallOpts) (*big.Int, error)

type OmniBridgeNativeCallerSession

+ func (_OmniBridgeNative *OmniBridgeNativeCallerSession) L1Deposits() (*big.Int, error)

type OmniBridgeNativeSession

+ func (_OmniBridgeNative *OmniBridgeNativeSession) L1Deposits() (*big.Int, error)

type OmniBridgeNativeSetup

+ L1Deposits *big.Int

+ type SolveCall struct

+ Data []byte

+ DestChainId uint64

+ Target common.Address

+ Value *big.Int

+ type SolveDeposit struct

+ Amount *big.Int

+ IsNative bool

+ Token common.Address

+ type SolveInbox struct

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

+ func NewSolveInbox(address common.Address, backend bind.ContractBackend) (*SolveInbox, error)

+ type SolveInboxAccepted struct

+ By common.Address

+ Id [32]byte

+ Raw types.Log

+ type SolveInboxAcceptedIterator struct

+ Event *SolveInboxAccepted

+ func (it *SolveInboxAcceptedIterator) Close() error

+ func (it *SolveInboxAcceptedIterator) Error() error

+ func (it *SolveInboxAcceptedIterator) Next() bool

+ type SolveInboxCaller struct

+ func NewSolveInboxCaller(address common.Address, caller bind.ContractCaller) (*SolveInboxCaller, error)

+ func (_SolveInbox *SolveInboxCaller) DefaultConfLevel(opts *bind.CallOpts) (uint8, error)

+ func (_SolveInbox *SolveInboxCaller) DeployedAt(opts *bind.CallOpts) (*big.Int, error)

+ func (_SolveInbox *SolveInboxCaller) GetRequest(opts *bind.CallOpts, id [32]byte) (SolveRequest, error)

+ func (_SolveInbox *SolveInboxCaller) HasAllRoles(opts *bind.CallOpts, user common.Address, roles *big.Int) (bool, error)

+ func (_SolveInbox *SolveInboxCaller) HasAnyRole(opts *bind.CallOpts, user common.Address, roles *big.Int) (bool, error)

+ func (_SolveInbox *SolveInboxCaller) Omni(opts *bind.CallOpts) (common.Address, error)

+ func (_SolveInbox *SolveInboxCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_SolveInbox *SolveInboxCaller) OwnershipHandoverExpiresAt(opts *bind.CallOpts, pendingOwner common.Address) (*big.Int, error)

+ func (_SolveInbox *SolveInboxCaller) RolesOf(opts *bind.CallOpts, user common.Address) (*big.Int, error)

+ func (_SolveInbox *SolveInboxCaller) SuggestNativePayment(opts *bind.CallOpts, call SolveCall, gasLimit uint64, gasPrice uint64, ...) (*big.Int, error)

+ type SolveInboxCallerRaw struct

+ Contract *SolveInboxCaller

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

+ type SolveInboxCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SolveInboxCaller

+ func (_SolveInbox *SolveInboxCallerSession) DefaultConfLevel() (uint8, error)

+ func (_SolveInbox *SolveInboxCallerSession) DeployedAt() (*big.Int, error)

+ func (_SolveInbox *SolveInboxCallerSession) GetRequest(id [32]byte) (SolveRequest, error)

+ func (_SolveInbox *SolveInboxCallerSession) HasAllRoles(user common.Address, roles *big.Int) (bool, error)

+ func (_SolveInbox *SolveInboxCallerSession) HasAnyRole(user common.Address, roles *big.Int) (bool, error)

+ func (_SolveInbox *SolveInboxCallerSession) Omni() (common.Address, error)

+ func (_SolveInbox *SolveInboxCallerSession) Owner() (common.Address, error)

+ func (_SolveInbox *SolveInboxCallerSession) OwnershipHandoverExpiresAt(pendingOwner common.Address) (*big.Int, error)

+ func (_SolveInbox *SolveInboxCallerSession) RolesOf(user common.Address) (*big.Int, error)

+ func (_SolveInbox *SolveInboxCallerSession) SuggestNativePayment(call SolveCall, gasLimit uint64, gasPrice uint64, fulfillFee *big.Int) (*big.Int, error)

+ type SolveInboxClaimed struct

+ By common.Address

+ Deposits []SolveDeposit

+ Id [32]byte

+ Raw types.Log

+ To common.Address

+ type SolveInboxClaimedIterator struct

+ Event *SolveInboxClaimed

+ func (it *SolveInboxClaimedIterator) Close() error

+ func (it *SolveInboxClaimedIterator) Error() error

+ func (it *SolveInboxClaimedIterator) Next() bool

+ type SolveInboxDefaultConfLevelSet struct

+ Conf uint8

+ Raw types.Log

+ type SolveInboxDefaultConfLevelSetIterator struct

+ Event *SolveInboxDefaultConfLevelSet

+ func (it *SolveInboxDefaultConfLevelSetIterator) Close() error

+ func (it *SolveInboxDefaultConfLevelSetIterator) Error() error

+ func (it *SolveInboxDefaultConfLevelSetIterator) Next() bool

+ type SolveInboxFilterer struct

+ func NewSolveInboxFilterer(address common.Address, filterer bind.ContractFilterer) (*SolveInboxFilterer, error)

+ func (_SolveInbox *SolveInboxFilterer) FilterAccepted(opts *bind.FilterOpts, id [][32]byte, by []common.Address) (*SolveInboxAcceptedIterator, error)

+ func (_SolveInbox *SolveInboxFilterer) FilterClaimed(opts *bind.FilterOpts, id [][32]byte, by []common.Address, to []common.Address) (*SolveInboxClaimedIterator, error)

+ func (_SolveInbox *SolveInboxFilterer) FilterDefaultConfLevelSet(opts *bind.FilterOpts) (*SolveInboxDefaultConfLevelSetIterator, error)

+ func (_SolveInbox *SolveInboxFilterer) FilterFulfilled(opts *bind.FilterOpts, id [][32]byte, callHash [][32]byte, ...) (*SolveInboxFulfilledIterator, error)

+ func (_SolveInbox *SolveInboxFilterer) FilterInitialized(opts *bind.FilterOpts) (*SolveInboxInitializedIterator, error)

+ func (_SolveInbox *SolveInboxFilterer) FilterOmniPortalSet(opts *bind.FilterOpts) (*SolveInboxOmniPortalSetIterator, error)

+ func (_SolveInbox *SolveInboxFilterer) FilterOwnershipHandoverCanceled(opts *bind.FilterOpts, pendingOwner []common.Address) (*SolveInboxOwnershipHandoverCanceledIterator, error)

+ func (_SolveInbox *SolveInboxFilterer) FilterOwnershipHandoverRequested(opts *bind.FilterOpts, pendingOwner []common.Address) (*SolveInboxOwnershipHandoverRequestedIterator, error)

+ func (_SolveInbox *SolveInboxFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*SolveInboxOwnershipTransferredIterator, error)

+ func (_SolveInbox *SolveInboxFilterer) FilterRejected(opts *bind.FilterOpts, id [][32]byte, by []common.Address, reason []uint8) (*SolveInboxRejectedIterator, error)

+ func (_SolveInbox *SolveInboxFilterer) FilterRequested(opts *bind.FilterOpts, id [][32]byte, from []common.Address) (*SolveInboxRequestedIterator, error)

+ func (_SolveInbox *SolveInboxFilterer) FilterReverted(opts *bind.FilterOpts, id [][32]byte) (*SolveInboxRevertedIterator, error)

+ func (_SolveInbox *SolveInboxFilterer) FilterRolesUpdated(opts *bind.FilterOpts, user []common.Address, roles []*big.Int) (*SolveInboxRolesUpdatedIterator, error)

+ func (_SolveInbox *SolveInboxFilterer) ParseAccepted(log types.Log) (*SolveInboxAccepted, error)

+ func (_SolveInbox *SolveInboxFilterer) ParseClaimed(log types.Log) (*SolveInboxClaimed, error)

+ func (_SolveInbox *SolveInboxFilterer) ParseDefaultConfLevelSet(log types.Log) (*SolveInboxDefaultConfLevelSet, error)

+ func (_SolveInbox *SolveInboxFilterer) ParseFulfilled(log types.Log) (*SolveInboxFulfilled, error)

+ func (_SolveInbox *SolveInboxFilterer) ParseInitialized(log types.Log) (*SolveInboxInitialized, error)

+ func (_SolveInbox *SolveInboxFilterer) ParseOmniPortalSet(log types.Log) (*SolveInboxOmniPortalSet, error)

+ func (_SolveInbox *SolveInboxFilterer) ParseOwnershipHandoverCanceled(log types.Log) (*SolveInboxOwnershipHandoverCanceled, error)

+ func (_SolveInbox *SolveInboxFilterer) ParseOwnershipHandoverRequested(log types.Log) (*SolveInboxOwnershipHandoverRequested, error)

+ func (_SolveInbox *SolveInboxFilterer) ParseOwnershipTransferred(log types.Log) (*SolveInboxOwnershipTransferred, error)

+ func (_SolveInbox *SolveInboxFilterer) ParseRejected(log types.Log) (*SolveInboxRejected, error)

+ func (_SolveInbox *SolveInboxFilterer) ParseRequested(log types.Log) (*SolveInboxRequested, error)

+ func (_SolveInbox *SolveInboxFilterer) ParseReverted(log types.Log) (*SolveInboxReverted, error)

+ func (_SolveInbox *SolveInboxFilterer) ParseRolesUpdated(log types.Log) (*SolveInboxRolesUpdated, error)

+ func (_SolveInbox *SolveInboxFilterer) WatchAccepted(opts *bind.WatchOpts, sink chan<- *SolveInboxAccepted, id [][32]byte, ...) (event.Subscription, error)

+ func (_SolveInbox *SolveInboxFilterer) WatchClaimed(opts *bind.WatchOpts, sink chan<- *SolveInboxClaimed, id [][32]byte, ...) (event.Subscription, error)

+ func (_SolveInbox *SolveInboxFilterer) WatchDefaultConfLevelSet(opts *bind.WatchOpts, sink chan<- *SolveInboxDefaultConfLevelSet) (event.Subscription, error)

+ func (_SolveInbox *SolveInboxFilterer) WatchFulfilled(opts *bind.WatchOpts, sink chan<- *SolveInboxFulfilled, id [][32]byte, ...) (event.Subscription, error)

+ func (_SolveInbox *SolveInboxFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *SolveInboxInitialized) (event.Subscription, error)

+ func (_SolveInbox *SolveInboxFilterer) WatchOmniPortalSet(opts *bind.WatchOpts, sink chan<- *SolveInboxOmniPortalSet) (event.Subscription, error)

+ func (_SolveInbox *SolveInboxFilterer) WatchOwnershipHandoverCanceled(opts *bind.WatchOpts, sink chan<- *SolveInboxOwnershipHandoverCanceled, ...) (event.Subscription, error)

+ func (_SolveInbox *SolveInboxFilterer) WatchOwnershipHandoverRequested(opts *bind.WatchOpts, sink chan<- *SolveInboxOwnershipHandoverRequested, ...) (event.Subscription, error)

+ func (_SolveInbox *SolveInboxFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *SolveInboxOwnershipTransferred, ...) (event.Subscription, error)

+ func (_SolveInbox *SolveInboxFilterer) WatchRejected(opts *bind.WatchOpts, sink chan<- *SolveInboxRejected, id [][32]byte, ...) (event.Subscription, error)

+ func (_SolveInbox *SolveInboxFilterer) WatchRequested(opts *bind.WatchOpts, sink chan<- *SolveInboxRequested, id [][32]byte, ...) (event.Subscription, error)

+ func (_SolveInbox *SolveInboxFilterer) WatchReverted(opts *bind.WatchOpts, sink chan<- *SolveInboxReverted, id [][32]byte) (event.Subscription, error)

+ func (_SolveInbox *SolveInboxFilterer) WatchRolesUpdated(opts *bind.WatchOpts, sink chan<- *SolveInboxRolesUpdated, ...) (event.Subscription, error)

+ type SolveInboxFulfilled struct

+ CallHash [32]byte

+ CreditedTo common.Address

+ Id [32]byte

+ Raw types.Log

+ type SolveInboxFulfilledIterator struct

+ Event *SolveInboxFulfilled

+ func (it *SolveInboxFulfilledIterator) Close() error

+ func (it *SolveInboxFulfilledIterator) Error() error

+ func (it *SolveInboxFulfilledIterator) Next() bool

+ type SolveInboxInitialized struct

+ Raw types.Log

+ Version uint64

+ type SolveInboxInitializedIterator struct

+ Event *SolveInboxInitialized

+ func (it *SolveInboxInitializedIterator) Close() error

+ func (it *SolveInboxInitializedIterator) Error() error

+ func (it *SolveInboxInitializedIterator) Next() bool

+ type SolveInboxOmniPortalSet struct

+ Omni common.Address

+ Raw types.Log

+ type SolveInboxOmniPortalSetIterator struct

+ Event *SolveInboxOmniPortalSet

+ func (it *SolveInboxOmniPortalSetIterator) Close() error

+ func (it *SolveInboxOmniPortalSetIterator) Error() error

+ func (it *SolveInboxOmniPortalSetIterator) Next() bool

+ type SolveInboxOwnershipHandoverCanceled struct

+ PendingOwner common.Address

+ Raw types.Log

+ type SolveInboxOwnershipHandoverCanceledIterator struct

+ Event *SolveInboxOwnershipHandoverCanceled

+ func (it *SolveInboxOwnershipHandoverCanceledIterator) Close() error

+ func (it *SolveInboxOwnershipHandoverCanceledIterator) Error() error

+ func (it *SolveInboxOwnershipHandoverCanceledIterator) Next() bool

+ type SolveInboxOwnershipHandoverRequested struct

+ PendingOwner common.Address

+ Raw types.Log

+ type SolveInboxOwnershipHandoverRequestedIterator struct

+ Event *SolveInboxOwnershipHandoverRequested

+ func (it *SolveInboxOwnershipHandoverRequestedIterator) Close() error

+ func (it *SolveInboxOwnershipHandoverRequestedIterator) Error() error

+ func (it *SolveInboxOwnershipHandoverRequestedIterator) Next() bool

+ type SolveInboxOwnershipTransferred struct

+ NewOwner common.Address

+ OldOwner common.Address

+ Raw types.Log

+ type SolveInboxOwnershipTransferredIterator struct

+ Event *SolveInboxOwnershipTransferred

+ func (it *SolveInboxOwnershipTransferredIterator) Close() error

+ func (it *SolveInboxOwnershipTransferredIterator) Error() error

+ func (it *SolveInboxOwnershipTransferredIterator) Next() bool

+ type SolveInboxRaw struct

+ Contract *SolveInbox

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

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

+ func (_SolveInbox *SolveInboxRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SolveInboxRejected struct

+ By common.Address

+ Id [32]byte

+ Raw types.Log

+ Reason uint8

+ type SolveInboxRejectedIterator struct

+ Event *SolveInboxRejected

+ func (it *SolveInboxRejectedIterator) Close() error

+ func (it *SolveInboxRejectedIterator) Error() error

+ func (it *SolveInboxRejectedIterator) Next() bool

+ type SolveInboxRequested struct

+ Call SolveCall

+ Deposits []SolveDeposit

+ From common.Address

+ Id [32]byte

+ Raw types.Log

+ type SolveInboxRequestedIterator struct

+ Event *SolveInboxRequested

+ func (it *SolveInboxRequestedIterator) Close() error

+ func (it *SolveInboxRequestedIterator) Error() error

+ func (it *SolveInboxRequestedIterator) Next() bool

+ type SolveInboxReverted struct

+ Id [32]byte

+ Raw types.Log

+ type SolveInboxRevertedIterator struct

+ Event *SolveInboxReverted

+ func (it *SolveInboxRevertedIterator) Close() error

+ func (it *SolveInboxRevertedIterator) Error() error

+ func (it *SolveInboxRevertedIterator) Next() bool

+ type SolveInboxRolesUpdated struct

+ Raw types.Log

+ Roles *big.Int

+ User common.Address

+ type SolveInboxRolesUpdatedIterator struct

+ Event *SolveInboxRolesUpdated

+ func (it *SolveInboxRolesUpdatedIterator) Close() error

+ func (it *SolveInboxRolesUpdatedIterator) Error() error

+ func (it *SolveInboxRolesUpdatedIterator) Next() bool

+ type SolveInboxSession struct

+ CallOpts bind.CallOpts

+ Contract *SolveInbox

+ TransactOpts bind.TransactOpts

+ func (_SolveInbox *SolveInboxSession) Accept(id [32]byte) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxSession) Cancel(id [32]byte) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxSession) CancelOwnershipHandover() (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxSession) Claim(id [32]byte, to common.Address) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxSession) CompleteOwnershipHandover(pendingOwner common.Address) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxSession) DefaultConfLevel() (uint8, error)

+ func (_SolveInbox *SolveInboxSession) DeployedAt() (*big.Int, error)

+ func (_SolveInbox *SolveInboxSession) GetRequest(id [32]byte) (SolveRequest, error)

+ func (_SolveInbox *SolveInboxSession) GrantRoles(user common.Address, roles *big.Int) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxSession) HasAllRoles(user common.Address, roles *big.Int) (bool, error)

+ func (_SolveInbox *SolveInboxSession) HasAnyRole(user common.Address, roles *big.Int) (bool, error)

+ func (_SolveInbox *SolveInboxSession) Initialize(owner_ common.Address, solver_ common.Address, omni_ common.Address, ...) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxSession) MarkFulfilled(id [32]byte, callHash [32]byte) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxSession) Omni() (common.Address, error)

+ func (_SolveInbox *SolveInboxSession) Owner() (common.Address, error)

+ func (_SolveInbox *SolveInboxSession) OwnershipHandoverExpiresAt(pendingOwner common.Address) (*big.Int, error)

+ func (_SolveInbox *SolveInboxSession) Reject(id [32]byte, reason uint8) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxSession) RenounceOwnership() (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxSession) RenounceRoles(roles *big.Int) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxSession) Request(call SolveCall, deposits []SolveTokenDeposit) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxSession) RequestOwnershipHandover() (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxSession) RevokeRoles(user common.Address, roles *big.Int) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxSession) RolesOf(user common.Address) (*big.Int, error)

+ func (_SolveInbox *SolveInboxSession) SuggestNativePayment(call SolveCall, gasLimit uint64, gasPrice uint64, fulfillFee *big.Int) (*big.Int, error)

+ func (_SolveInbox *SolveInboxSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type SolveInboxTransactor struct

+ func NewSolveInboxTransactor(address common.Address, transactor bind.ContractTransactor) (*SolveInboxTransactor, error)

+ func (_SolveInbox *SolveInboxTransactor) Accept(opts *bind.TransactOpts, id [32]byte) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactor) Cancel(opts *bind.TransactOpts, id [32]byte) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactor) CancelOwnershipHandover(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactor) Claim(opts *bind.TransactOpts, id [32]byte, to common.Address) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactor) CompleteOwnershipHandover(opts *bind.TransactOpts, pendingOwner common.Address) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactor) GrantRoles(opts *bind.TransactOpts, user common.Address, roles *big.Int) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactor) Initialize(opts *bind.TransactOpts, owner_ common.Address, solver_ common.Address, ...) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactor) MarkFulfilled(opts *bind.TransactOpts, id [32]byte, callHash [32]byte) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactor) Reject(opts *bind.TransactOpts, id [32]byte, reason uint8) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactor) RenounceRoles(opts *bind.TransactOpts, roles *big.Int) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactor) Request(opts *bind.TransactOpts, call SolveCall, deposits []SolveTokenDeposit) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactor) RequestOwnershipHandover(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactor) RevokeRoles(opts *bind.TransactOpts, user common.Address, roles *big.Int) (*types.Transaction, error)

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

+ type SolveInboxTransactorRaw struct

+ Contract *SolveInboxTransactor

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

+ func (_SolveInbox *SolveInboxTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SolveInboxTransactorSession struct

+ Contract *SolveInboxTransactor

+ TransactOpts bind.TransactOpts

+ func (_SolveInbox *SolveInboxTransactorSession) Accept(id [32]byte) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactorSession) Cancel(id [32]byte) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactorSession) CancelOwnershipHandover() (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactorSession) Claim(id [32]byte, to common.Address) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactorSession) CompleteOwnershipHandover(pendingOwner common.Address) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactorSession) GrantRoles(user common.Address, roles *big.Int) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactorSession) Initialize(owner_ common.Address, solver_ common.Address, omni_ common.Address, ...) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactorSession) MarkFulfilled(id [32]byte, callHash [32]byte) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactorSession) Reject(id [32]byte, reason uint8) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactorSession) RenounceRoles(roles *big.Int) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactorSession) Request(call SolveCall, deposits []SolveTokenDeposit) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactorSession) RequestOwnershipHandover() (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactorSession) RevokeRoles(user common.Address, roles *big.Int) (*types.Transaction, error)

+ func (_SolveInbox *SolveInboxTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type SolveOutbox struct

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

+ func NewSolveOutbox(address common.Address, backend bind.ContractBackend) (*SolveOutbox, error)

+ type SolveOutboxAllowedCallSet struct

+ Allowed bool

+ Raw types.Log

+ Selector [4]byte

+ Target common.Address

+ type SolveOutboxAllowedCallSetIterator struct

+ Event *SolveOutboxAllowedCallSet

+ func (it *SolveOutboxAllowedCallSetIterator) Close() error

+ func (it *SolveOutboxAllowedCallSetIterator) Error() error

+ func (it *SolveOutboxAllowedCallSetIterator) Next() bool

+ type SolveOutboxCaller struct

+ func NewSolveOutboxCaller(address common.Address, caller bind.ContractCaller) (*SolveOutboxCaller, error)

+ func (_SolveOutbox *SolveOutboxCaller) AllowedCalls(opts *bind.CallOpts, target common.Address, selector [4]byte) (bool, error)

+ func (_SolveOutbox *SolveOutboxCaller) DefaultConfLevel(opts *bind.CallOpts) (uint8, error)

+ func (_SolveOutbox *SolveOutboxCaller) DeployedAt(opts *bind.CallOpts) (*big.Int, error)

+ func (_SolveOutbox *SolveOutboxCaller) DidFulfill(opts *bind.CallOpts, srcReqId [32]byte, srcChainId uint64, call SolveCall) (bool, error)

+ func (_SolveOutbox *SolveOutboxCaller) FulfillFee(opts *bind.CallOpts, srcChainId uint64) (*big.Int, error)

+ func (_SolveOutbox *SolveOutboxCaller) FulfilledCalls(opts *bind.CallOpts, callHash [32]byte) (bool, error)

+ func (_SolveOutbox *SolveOutboxCaller) HasAllRoles(opts *bind.CallOpts, user common.Address, roles *big.Int) (bool, error)

+ func (_SolveOutbox *SolveOutboxCaller) HasAnyRole(opts *bind.CallOpts, user common.Address, roles *big.Int) (bool, error)

+ func (_SolveOutbox *SolveOutboxCaller) Omni(opts *bind.CallOpts) (common.Address, error)

+ func (_SolveOutbox *SolveOutboxCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_SolveOutbox *SolveOutboxCaller) OwnershipHandoverExpiresAt(opts *bind.CallOpts, pendingOwner common.Address) (*big.Int, error)

+ func (_SolveOutbox *SolveOutboxCaller) RolesOf(opts *bind.CallOpts, user common.Address) (*big.Int, error)

+ type SolveOutboxCallerRaw struct

+ Contract *SolveOutboxCaller

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

+ type SolveOutboxCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SolveOutboxCaller

+ func (_SolveOutbox *SolveOutboxCallerSession) AllowedCalls(target common.Address, selector [4]byte) (bool, error)

+ func (_SolveOutbox *SolveOutboxCallerSession) DefaultConfLevel() (uint8, error)

+ func (_SolveOutbox *SolveOutboxCallerSession) DeployedAt() (*big.Int, error)

+ func (_SolveOutbox *SolveOutboxCallerSession) DidFulfill(srcReqId [32]byte, srcChainId uint64, call SolveCall) (bool, error)

+ func (_SolveOutbox *SolveOutboxCallerSession) FulfillFee(srcChainId uint64) (*big.Int, error)

+ func (_SolveOutbox *SolveOutboxCallerSession) FulfilledCalls(callHash [32]byte) (bool, error)

+ func (_SolveOutbox *SolveOutboxCallerSession) HasAllRoles(user common.Address, roles *big.Int) (bool, error)

+ func (_SolveOutbox *SolveOutboxCallerSession) HasAnyRole(user common.Address, roles *big.Int) (bool, error)

+ func (_SolveOutbox *SolveOutboxCallerSession) Omni() (common.Address, error)

+ func (_SolveOutbox *SolveOutboxCallerSession) Owner() (common.Address, error)

+ func (_SolveOutbox *SolveOutboxCallerSession) OwnershipHandoverExpiresAt(pendingOwner common.Address) (*big.Int, error)

+ func (_SolveOutbox *SolveOutboxCallerSession) RolesOf(user common.Address) (*big.Int, error)

+ type SolveOutboxDefaultConfLevelSet struct

+ Conf uint8

+ Raw types.Log

+ type SolveOutboxDefaultConfLevelSetIterator struct

+ Event *SolveOutboxDefaultConfLevelSet

+ func (it *SolveOutboxDefaultConfLevelSetIterator) Close() error

+ func (it *SolveOutboxDefaultConfLevelSetIterator) Error() error

+ func (it *SolveOutboxDefaultConfLevelSetIterator) Next() bool

+ type SolveOutboxFilterer struct

+ func NewSolveOutboxFilterer(address common.Address, filterer bind.ContractFilterer) (*SolveOutboxFilterer, error)

+ func (_SolveOutbox *SolveOutboxFilterer) FilterAllowedCallSet(opts *bind.FilterOpts, target []common.Address, selector [][4]byte) (*SolveOutboxAllowedCallSetIterator, error)

+ func (_SolveOutbox *SolveOutboxFilterer) FilterDefaultConfLevelSet(opts *bind.FilterOpts) (*SolveOutboxDefaultConfLevelSetIterator, error)

+ func (_SolveOutbox *SolveOutboxFilterer) FilterFulfilled(opts *bind.FilterOpts, reqId [][32]byte, callHash [][32]byte, ...) (*SolveOutboxFulfilledIterator, error)

+ func (_SolveOutbox *SolveOutboxFilterer) FilterInitialized(opts *bind.FilterOpts) (*SolveOutboxInitializedIterator, error)

+ func (_SolveOutbox *SolveOutboxFilterer) FilterOmniPortalSet(opts *bind.FilterOpts) (*SolveOutboxOmniPortalSetIterator, error)

+ func (_SolveOutbox *SolveOutboxFilterer) FilterOwnershipHandoverCanceled(opts *bind.FilterOpts, pendingOwner []common.Address) (*SolveOutboxOwnershipHandoverCanceledIterator, error)

+ func (_SolveOutbox *SolveOutboxFilterer) FilterOwnershipHandoverRequested(opts *bind.FilterOpts, pendingOwner []common.Address) (*SolveOutboxOwnershipHandoverRequestedIterator, error)

+ func (_SolveOutbox *SolveOutboxFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*SolveOutboxOwnershipTransferredIterator, error)

+ func (_SolveOutbox *SolveOutboxFilterer) FilterRolesUpdated(opts *bind.FilterOpts, user []common.Address, roles []*big.Int) (*SolveOutboxRolesUpdatedIterator, error)

+ func (_SolveOutbox *SolveOutboxFilterer) ParseAllowedCallSet(log types.Log) (*SolveOutboxAllowedCallSet, error)

+ func (_SolveOutbox *SolveOutboxFilterer) ParseDefaultConfLevelSet(log types.Log) (*SolveOutboxDefaultConfLevelSet, error)

+ func (_SolveOutbox *SolveOutboxFilterer) ParseFulfilled(log types.Log) (*SolveOutboxFulfilled, error)

+ func (_SolveOutbox *SolveOutboxFilterer) ParseInitialized(log types.Log) (*SolveOutboxInitialized, error)

+ func (_SolveOutbox *SolveOutboxFilterer) ParseOmniPortalSet(log types.Log) (*SolveOutboxOmniPortalSet, error)

+ func (_SolveOutbox *SolveOutboxFilterer) ParseOwnershipHandoverCanceled(log types.Log) (*SolveOutboxOwnershipHandoverCanceled, error)

+ func (_SolveOutbox *SolveOutboxFilterer) ParseOwnershipHandoverRequested(log types.Log) (*SolveOutboxOwnershipHandoverRequested, error)

+ func (_SolveOutbox *SolveOutboxFilterer) ParseOwnershipTransferred(log types.Log) (*SolveOutboxOwnershipTransferred, error)

+ func (_SolveOutbox *SolveOutboxFilterer) ParseRolesUpdated(log types.Log) (*SolveOutboxRolesUpdated, error)

+ func (_SolveOutbox *SolveOutboxFilterer) WatchAllowedCallSet(opts *bind.WatchOpts, sink chan<- *SolveOutboxAllowedCallSet, ...) (event.Subscription, error)

+ func (_SolveOutbox *SolveOutboxFilterer) WatchDefaultConfLevelSet(opts *bind.WatchOpts, sink chan<- *SolveOutboxDefaultConfLevelSet) (event.Subscription, error)

+ func (_SolveOutbox *SolveOutboxFilterer) WatchFulfilled(opts *bind.WatchOpts, sink chan<- *SolveOutboxFulfilled, reqId [][32]byte, ...) (event.Subscription, error)

+ func (_SolveOutbox *SolveOutboxFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *SolveOutboxInitialized) (event.Subscription, error)

+ func (_SolveOutbox *SolveOutboxFilterer) WatchOmniPortalSet(opts *bind.WatchOpts, sink chan<- *SolveOutboxOmniPortalSet) (event.Subscription, error)

+ func (_SolveOutbox *SolveOutboxFilterer) WatchOwnershipHandoverCanceled(opts *bind.WatchOpts, sink chan<- *SolveOutboxOwnershipHandoverCanceled, ...) (event.Subscription, error)

+ func (_SolveOutbox *SolveOutboxFilterer) WatchOwnershipHandoverRequested(opts *bind.WatchOpts, sink chan<- *SolveOutboxOwnershipHandoverRequested, ...) (event.Subscription, error)

+ func (_SolveOutbox *SolveOutboxFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *SolveOutboxOwnershipTransferred, ...) (event.Subscription, error)

+ func (_SolveOutbox *SolveOutboxFilterer) WatchRolesUpdated(opts *bind.WatchOpts, sink chan<- *SolveOutboxRolesUpdated, ...) (event.Subscription, error)

+ type SolveOutboxFulfilled struct

+ CallHash [32]byte

+ Raw types.Log

+ ReqId [32]byte

+ SolvedBy common.Address

+ type SolveOutboxFulfilledIterator struct

+ Event *SolveOutboxFulfilled

+ func (it *SolveOutboxFulfilledIterator) Close() error

+ func (it *SolveOutboxFulfilledIterator) Error() error

+ func (it *SolveOutboxFulfilledIterator) Next() bool

+ type SolveOutboxInitialized struct

+ Raw types.Log

+ Version uint64

+ type SolveOutboxInitializedIterator struct

+ Event *SolveOutboxInitialized

+ func (it *SolveOutboxInitializedIterator) Close() error

+ func (it *SolveOutboxInitializedIterator) Error() error

+ func (it *SolveOutboxInitializedIterator) Next() bool

+ type SolveOutboxOmniPortalSet struct

+ Omni common.Address

+ Raw types.Log

+ type SolveOutboxOmniPortalSetIterator struct

+ Event *SolveOutboxOmniPortalSet

+ func (it *SolveOutboxOmniPortalSetIterator) Close() error

+ func (it *SolveOutboxOmniPortalSetIterator) Error() error

+ func (it *SolveOutboxOmniPortalSetIterator) Next() bool

+ type SolveOutboxOwnershipHandoverCanceled struct

+ PendingOwner common.Address

+ Raw types.Log

+ type SolveOutboxOwnershipHandoverCanceledIterator struct

+ Event *SolveOutboxOwnershipHandoverCanceled

+ func (it *SolveOutboxOwnershipHandoverCanceledIterator) Close() error

+ func (it *SolveOutboxOwnershipHandoverCanceledIterator) Error() error

+ func (it *SolveOutboxOwnershipHandoverCanceledIterator) Next() bool

+ type SolveOutboxOwnershipHandoverRequested struct

+ PendingOwner common.Address

+ Raw types.Log

+ type SolveOutboxOwnershipHandoverRequestedIterator struct

+ Event *SolveOutboxOwnershipHandoverRequested

+ func (it *SolveOutboxOwnershipHandoverRequestedIterator) Close() error

+ func (it *SolveOutboxOwnershipHandoverRequestedIterator) Error() error

+ func (it *SolveOutboxOwnershipHandoverRequestedIterator) Next() bool

+ type SolveOutboxOwnershipTransferred struct

+ NewOwner common.Address

+ OldOwner common.Address

+ Raw types.Log

+ type SolveOutboxOwnershipTransferredIterator struct

+ Event *SolveOutboxOwnershipTransferred

+ func (it *SolveOutboxOwnershipTransferredIterator) Close() error

+ func (it *SolveOutboxOwnershipTransferredIterator) Error() error

+ func (it *SolveOutboxOwnershipTransferredIterator) Next() bool

+ type SolveOutboxRaw struct

+ Contract *SolveOutbox

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

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

+ func (_SolveOutbox *SolveOutboxRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SolveOutboxRolesUpdated struct

+ Raw types.Log

+ Roles *big.Int

+ User common.Address

+ type SolveOutboxRolesUpdatedIterator struct

+ Event *SolveOutboxRolesUpdated

+ func (it *SolveOutboxRolesUpdatedIterator) Close() error

+ func (it *SolveOutboxRolesUpdatedIterator) Error() error

+ func (it *SolveOutboxRolesUpdatedIterator) Next() bool

+ type SolveOutboxSession struct

+ CallOpts bind.CallOpts

+ Contract *SolveOutbox

+ TransactOpts bind.TransactOpts

+ func (_SolveOutbox *SolveOutboxSession) AllowedCalls(target common.Address, selector [4]byte) (bool, error)

+ func (_SolveOutbox *SolveOutboxSession) CancelOwnershipHandover() (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxSession) CompleteOwnershipHandover(pendingOwner common.Address) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxSession) DefaultConfLevel() (uint8, error)

+ func (_SolveOutbox *SolveOutboxSession) DeployedAt() (*big.Int, error)

+ func (_SolveOutbox *SolveOutboxSession) DidFulfill(srcReqId [32]byte, srcChainId uint64, call SolveCall) (bool, error)

+ func (_SolveOutbox *SolveOutboxSession) Fulfill(srcReqId [32]byte, srcChainId uint64, call SolveCall, ...) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxSession) FulfillFee(srcChainId uint64) (*big.Int, error)

+ func (_SolveOutbox *SolveOutboxSession) FulfilledCalls(callHash [32]byte) (bool, error)

+ func (_SolveOutbox *SolveOutboxSession) GrantRoles(user common.Address, roles *big.Int) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxSession) HasAllRoles(user common.Address, roles *big.Int) (bool, error)

+ func (_SolveOutbox *SolveOutboxSession) HasAnyRole(user common.Address, roles *big.Int) (bool, error)

+ func (_SolveOutbox *SolveOutboxSession) Initialize(owner_ common.Address, solver_ common.Address, omni_ common.Address, ...) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxSession) Omni() (common.Address, error)

+ func (_SolveOutbox *SolveOutboxSession) Owner() (common.Address, error)

+ func (_SolveOutbox *SolveOutboxSession) OwnershipHandoverExpiresAt(pendingOwner common.Address) (*big.Int, error)

+ func (_SolveOutbox *SolveOutboxSession) RenounceOwnership() (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxSession) RenounceRoles(roles *big.Int) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxSession) RequestOwnershipHandover() (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxSession) RevokeRoles(user common.Address, roles *big.Int) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxSession) RolesOf(user common.Address) (*big.Int, error)

+ func (_SolveOutbox *SolveOutboxSession) SetAllowedCall(target common.Address, selector [4]byte, allowed bool) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type SolveOutboxTransactor struct

+ func NewSolveOutboxTransactor(address common.Address, transactor bind.ContractTransactor) (*SolveOutboxTransactor, error)

+ func (_SolveOutbox *SolveOutboxTransactor) CancelOwnershipHandover(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxTransactor) CompleteOwnershipHandover(opts *bind.TransactOpts, pendingOwner common.Address) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxTransactor) Fulfill(opts *bind.TransactOpts, srcReqId [32]byte, srcChainId uint64, call SolveCall, ...) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxTransactor) GrantRoles(opts *bind.TransactOpts, user common.Address, roles *big.Int) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxTransactor) Initialize(opts *bind.TransactOpts, owner_ common.Address, solver_ common.Address, ...) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxTransactor) RenounceRoles(opts *bind.TransactOpts, roles *big.Int) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxTransactor) RequestOwnershipHandover(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxTransactor) RevokeRoles(opts *bind.TransactOpts, user common.Address, roles *big.Int) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxTransactor) SetAllowedCall(opts *bind.TransactOpts, target common.Address, selector [4]byte, allowed bool) (*types.Transaction, error)

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

+ type SolveOutboxTransactorRaw struct

+ Contract *SolveOutboxTransactor

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

+ func (_SolveOutbox *SolveOutboxTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SolveOutboxTransactorSession struct

+ Contract *SolveOutboxTransactor

+ TransactOpts bind.TransactOpts

+ func (_SolveOutbox *SolveOutboxTransactorSession) CancelOwnershipHandover() (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxTransactorSession) CompleteOwnershipHandover(pendingOwner common.Address) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxTransactorSession) Fulfill(srcReqId [32]byte, srcChainId uint64, call SolveCall, ...) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxTransactorSession) GrantRoles(user common.Address, roles *big.Int) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxTransactorSession) Initialize(owner_ common.Address, solver_ common.Address, omni_ common.Address, ...) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxTransactorSession) RenounceRoles(roles *big.Int) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxTransactorSession) RequestOwnershipHandover() (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxTransactorSession) RevokeRoles(user common.Address, roles *big.Int) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxTransactorSession) SetAllowedCall(target common.Address, selector [4]byte, allowed bool) (*types.Transaction, error)

+ func (_SolveOutbox *SolveOutboxTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type SolveRequest struct

+ AcceptedBy common.Address

+ Call SolveCall

+ Deposits []SolveDeposit

+ From common.Address

+ Id [32]byte

+ Status uint8

+ UpdatedAt *big.Int

+ type SolveTokenDeposit struct

+ Amount *big.Int

+ Token common.Address

+ type SolveTokenPrereq struct

+ Amount *big.Int

+ Spender common.Address

+ Token common.Address

type StakingCaller

+ func (_Staking *StakingCaller) Eip712Domain(opts *bind.CallOpts) (struct{ ... }, error)

+ func (_Staking *StakingCaller) GetValidatorPubkeyDigest(opts *bind.CallOpts, x [32]byte, y [32]byte) ([32]byte, error)

type StakingCallerSession

+ func (_Staking *StakingCallerSession) Eip712Domain() (struct{ ... }, error)

+ func (_Staking *StakingCallerSession) GetValidatorPubkeyDigest(x [32]byte, y [32]byte) ([32]byte, error)

+ type StakingEIP712DomainChanged struct

+ Raw types.Log

+ type StakingEIP712DomainChangedIterator struct

+ Event *StakingEIP712DomainChanged

+ func (it *StakingEIP712DomainChangedIterator) Close() error

+ func (it *StakingEIP712DomainChangedIterator) Error() error

+ func (it *StakingEIP712DomainChangedIterator) Next() bool

type StakingFilterer

+ func (_Staking *StakingFilterer) FilterEIP712DomainChanged(opts *bind.FilterOpts) (*StakingEIP712DomainChangedIterator, error)

+ func (_Staking *StakingFilterer) ParseEIP712DomainChanged(log types.Log) (*StakingEIP712DomainChanged, error)

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

type StakingSession

+ func (_Staking *StakingSession) CreateValidator0(x [32]byte, y [32]byte, signature []byte) (*types.Transaction, error)

+ func (_Staking *StakingSession) Eip712Domain() (struct{ ... }, error)

+ func (_Staking *StakingSession) GetValidatorPubkeyDigest(x [32]byte, y [32]byte) ([32]byte, error)

+ func (_Staking *StakingSession) InitializeV1(owner_ common.Address, isAllowlistEnabled_ bool) (*types.Transaction, error)

+ func (_Staking *StakingSession) InitializeV2() (*types.Transaction, error)

type StakingTransactor

+ func (_Staking *StakingTransactor) CreateValidator0(opts *bind.TransactOpts, x [32]byte, y [32]byte, signature []byte) (*types.Transaction, error)

+ func (_Staking *StakingTransactor) InitializeV1(opts *bind.TransactOpts, owner_ common.Address, isAllowlistEnabled_ bool) (*types.Transaction, error)

+ func (_Staking *StakingTransactor) InitializeV2(opts *bind.TransactOpts) (*types.Transaction, error)

type StakingTransactorSession

+ func (_Staking *StakingTransactorSession) CreateValidator0(x [32]byte, y [32]byte, signature []byte) (*types.Transaction, error)

+ func (_Staking *StakingTransactorSession) InitializeV1(owner_ common.Address, isAllowlistEnabled_ bool) (*types.Transaction, error)

+ func (_Staking *StakingTransactorSession) InitializeV2() (*types.Transaction, error)

v0.10.0

Oct 28, 2024

Changes in this version

type AllocPredeploysConfig

+ Manager common.Address

+ NativeBridgeBalance *big.Int

+ Upgrader common.Address

v0.9.0

Oct 4, 2024

v0.8.1

Oct 3, 2024

v0.8.0

Sep 26, 2024

v0.8.0-rc1

Oct 1, 2024

v0.7.0

Sep 12, 2024

v0.6.0

Sep 5, 2024

v0.5.0

Aug 19, 2024

v0.4.0

Aug 14, 2024

v0.3.1

Jul 30, 2024

v0.3.0

Jul 30, 2024

v0.2.0

Jul 23, 2024

Changes in this version

type PortalRegistryDeployment

+ BlockPeriod uint64

type PortalRegistryPortalRegistered

+ BlockPeriod uint64

v0.1.10

Jun 19, 2024

Changes in this version

type OmniPortalFilterer

+ func (_OmniPortal *OmniPortalFilterer) FilterXMsgMaxDataSizeChanged(opts *bind.FilterOpts, oldMax []uint16, newMax []uint16) (*OmniPortalXMsgMaxDataSizeChangedIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterXReceiptMaxErrorSizeChanged(opts *bind.FilterOpts, oldMax []uint16, newMax []uint16) (*OmniPortalXReceiptMaxErrorSizeChangedIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseXMsgMaxDataSizeChanged(log types.Log) (*OmniPortalXMsgMaxDataSizeChanged, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseXReceiptMaxErrorSizeChanged(log types.Log) (*OmniPortalXReceiptMaxErrorSizeChanged, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchXMsgMaxDataSizeChanged(opts *bind.WatchOpts, sink chan<- *OmniPortalXMsgMaxDataSizeChanged, ...) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchXReceiptMaxErrorSizeChanged(opts *bind.WatchOpts, sink chan<- *OmniPortalXReceiptMaxErrorSizeChanged, ...) (event.Subscription, error)

+ type OmniPortalXMsgMaxDataSizeChanged struct

+ NewMax uint16

+ OldMax uint16

+ Raw types.Log

+ type OmniPortalXMsgMaxDataSizeChangedIterator struct

+ Event *OmniPortalXMsgMaxDataSizeChanged

+ func (it *OmniPortalXMsgMaxDataSizeChangedIterator) Close() error

+ func (it *OmniPortalXMsgMaxDataSizeChangedIterator) Error() error

+ func (it *OmniPortalXMsgMaxDataSizeChangedIterator) Next() bool

+ type OmniPortalXReceiptMaxErrorSizeChanged struct

+ NewMax uint16

+ OldMax uint16

+ Raw types.Log

+ type OmniPortalXReceiptMaxErrorSizeChangedIterator struct

+ Event *OmniPortalXReceiptMaxErrorSizeChanged

+ func (it *OmniPortalXReceiptMaxErrorSizeChangedIterator) Close() error

+ func (it *OmniPortalXReceiptMaxErrorSizeChangedIterator) Error() error

+ func (it *OmniPortalXReceiptMaxErrorSizeChangedIterator) Next() bool

v0.1.9

Jun 14, 2024

Changes in this version

+ const OmniBridgeNativeDeployedBytecode

+ const SlashingDeployedBytecode

+ const StakingDeployedBytecode

+ var OmniBridgeNativeStorageLayout = mustGetStorageLayout(omnibridgenativeStorageLayoutJSON)

+ var SlashingStorageLayout = mustGetStorageLayout(slashingStorageLayoutJSON)

+ var StakingStorageLayout = mustGetStorageLayout(stakingStorageLayoutJSON)

type OmniBridgeL1Caller

+ func (_OmniBridgeL1 *OmniBridgeL1Caller) TotalL1Supply(opts *bind.CallOpts) (*big.Int, error)

type OmniBridgeL1CallerSession

+ func (_OmniBridgeL1 *OmniBridgeL1CallerSession) TotalL1Supply() (*big.Int, error)

type OmniBridgeL1Session

+ func (_OmniBridgeL1 *OmniBridgeL1Session) TotalL1Supply() (*big.Int, error)

type OmniBridgeNativeCaller

+ func (_OmniBridgeNative *OmniBridgeNativeCaller) TotalL1Supply(opts *bind.CallOpts) (*big.Int, error)

type OmniBridgeNativeCallerSession

+ func (_OmniBridgeNative *OmniBridgeNativeCallerSession) TotalL1Supply() (*big.Int, error)

type OmniBridgeNativeSession

+ func (_OmniBridgeNative *OmniBridgeNativeSession) TotalL1Supply() (*big.Int, error)

type OmniPortalCaller

+ func (_OmniPortal *OmniPortalCaller) XSUBVALSETCUTOFF(opts *bind.CallOpts) (uint8, error)

type OmniPortalCallerSession

+ func (_OmniPortal *OmniPortalCallerSession) XSUBVALSETCUTOFF() (uint8, error)

type OmniPortalSession

+ func (_OmniPortal *OmniPortalSession) XSUBVALSETCUTOFF() (uint8, error)

type StakingCaller

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

type StakingCallerSession

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

type StakingSession

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

v0.1.8

May 22, 2024

v0.1.7

May 22, 2024

v0.1.6

May 16, 2024

v0.1.5

May 13, 2024

v0.1.4

May 6, 2024

Changes in this version

+ const PortalRegistryDeployedBytecode

+ const XRegistryDeployedBytecode

+ var PortalRegistryStorageLayout = mustGetStorageLayout(portalregistryStorageLayoutJSON)

+ var XRegistryABI = XRegistryMetaData.ABI

+ var XRegistryBin = XRegistryMetaData.Bin

+ var XRegistryMetaData = &bind.MetaData

+ var XRegistryReplicaABI = XRegistryReplicaMetaData.ABI

+ var XRegistryReplicaBin = XRegistryReplicaMetaData.Bin

+ var XRegistryReplicaMetaData = &bind.MetaData

+ var XRegistryStorageLayout = mustGetStorageLayout(xregistryStorageLayoutJSON)

type FeeOracleV1Filterer

+ func (_FeeOracleV1 *FeeOracleV1Filterer) FilterManagerChanged(opts *bind.FilterOpts) (*FeeOracleV1ManagerChangedIterator, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) ParseManagerChanged(log types.Log) (*FeeOracleV1ManagerChanged, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) WatchManagerChanged(opts *bind.WatchOpts, sink chan<- *FeeOracleV1ManagerChanged) (event.Subscription, error)

+ type FeeOracleV1ManagerChanged struct

+ NewManager common.Address

+ OldManager common.Address

+ Raw types.Log

+ type FeeOracleV1ManagerChangedIterator struct

+ Event *FeeOracleV1ManagerChanged

+ func (it *FeeOracleV1ManagerChangedIterator) Close() error

+ func (it *FeeOracleV1ManagerChangedIterator) Error() error

+ func (it *FeeOracleV1ManagerChangedIterator) Next() bool

type OmniPortalCaller

+ func (_OmniPortal *OmniPortalCaller) IsSupportedChain(opts *bind.CallOpts, destChainId uint64) (bool, error)

+ func (_OmniPortal *OmniPortalCaller) Paused(opts *bind.CallOpts) (bool, error)

+ func (_OmniPortal *OmniPortalCaller) XRECEIPTERROREXCEEDSMAXBYTES(opts *bind.CallOpts) ([]byte, error)

+ func (_OmniPortal *OmniPortalCaller) XmsgDefaultGasLimit(opts *bind.CallOpts) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) XreceiptMaxErrorBytes(opts *bind.CallOpts) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) Xregistry(opts *bind.CallOpts) (common.Address, error)

type OmniPortalCallerSession

+ func (_OmniPortal *OmniPortalCallerSession) IsSupportedChain(destChainId uint64) (bool, error)

+ func (_OmniPortal *OmniPortalCallerSession) Paused() (bool, error)

+ func (_OmniPortal *OmniPortalCallerSession) XRECEIPTERROREXCEEDSMAXBYTES() ([]byte, error)

+ func (_OmniPortal *OmniPortalCallerSession) XmsgDefaultGasLimit() (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) XreceiptMaxErrorBytes() (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) Xregistry() (common.Address, error)

type OmniPortalFeeOracleChanged

+ NewOrcale common.Address

+ OldOracle common.Address

type OmniPortalFilterer

+ func (_OmniPortal *OmniPortalFilterer) FilterXMsgDefaultGasLimitChanged(opts *bind.FilterOpts, oldDefault []uint64, newDefault []uint64) (*OmniPortalXMsgDefaultGasLimitChangedIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterXMsgMaxGasLimitChanged(opts *bind.FilterOpts, oldMax []uint64, newMax []uint64) (*OmniPortalXMsgMaxGasLimitChangedIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterXMsgMinGasLimitChanged(opts *bind.FilterOpts, oldMin []uint64, newMin []uint64) (*OmniPortalXMsgMinGasLimitChangedIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterXReceiptMaxErrorBytesChanged(opts *bind.FilterOpts, oldMax []uint64, newMax []uint64) (*OmniPortalXReceiptMaxErrorBytesChangedIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseXMsgDefaultGasLimitChanged(log types.Log) (*OmniPortalXMsgDefaultGasLimitChanged, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseXMsgMaxGasLimitChanged(log types.Log) (*OmniPortalXMsgMaxGasLimitChanged, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseXMsgMinGasLimitChanged(log types.Log) (*OmniPortalXMsgMinGasLimitChanged, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseXReceiptMaxErrorBytesChanged(log types.Log) (*OmniPortalXReceiptMaxErrorBytesChanged, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchXMsgDefaultGasLimitChanged(opts *bind.WatchOpts, sink chan<- *OmniPortalXMsgDefaultGasLimitChanged, ...) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchXMsgMaxGasLimitChanged(opts *bind.WatchOpts, sink chan<- *OmniPortalXMsgMaxGasLimitChanged, ...) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchXMsgMinGasLimitChanged(opts *bind.WatchOpts, sink chan<- *OmniPortalXMsgMinGasLimitChanged, ...) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchXReceiptMaxErrorBytesChanged(opts *bind.WatchOpts, sink chan<- *OmniPortalXReceiptMaxErrorBytesChanged, ...) (event.Subscription, error)

type OmniPortalPaused

+ Account common.Address

type OmniPortalSession

+ func (_OmniPortal *OmniPortalSession) IsSupportedChain(destChainId uint64) (bool, error)

+ func (_OmniPortal *OmniPortalSession) Paused() (bool, error)

+ func (_OmniPortal *OmniPortalSession) SetXMsgDefaultGasLimit(gasLimit uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) SetXReceiptMaxErrorBytes(maxErrorBytes uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) SetXRegistry(xregistry_ common.Address) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) XRECEIPTERROREXCEEDSMAXBYTES() ([]byte, error)

+ func (_OmniPortal *OmniPortalSession) XmsgDefaultGasLimit() (uint64, error)

+ func (_OmniPortal *OmniPortalSession) XreceiptMaxErrorBytes() (uint64, error)

+ func (_OmniPortal *OmniPortalSession) Xregistry() (common.Address, error)

type OmniPortalTransactor

+ func (_OmniPortal *OmniPortalTransactor) SetXMsgDefaultGasLimit(opts *bind.TransactOpts, gasLimit uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) SetXReceiptMaxErrorBytes(opts *bind.TransactOpts, maxErrorBytes uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) SetXRegistry(opts *bind.TransactOpts, xregistry_ common.Address) (*types.Transaction, error)

type OmniPortalTransactorSession

+ func (_OmniPortal *OmniPortalTransactorSession) SetXMsgDefaultGasLimit(gasLimit uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) SetXReceiptMaxErrorBytes(maxErrorBytes uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) SetXRegistry(xregistry_ common.Address) (*types.Transaction, error)

type OmniPortalUnpaused

+ Account common.Address

+ type OmniPortalXMsgDefaultGasLimitChanged struct

+ NewDefault uint64

+ OldDefault uint64

+ Raw types.Log

+ type OmniPortalXMsgDefaultGasLimitChangedIterator struct

+ Event *OmniPortalXMsgDefaultGasLimitChanged

+ func (it *OmniPortalXMsgDefaultGasLimitChangedIterator) Close() error

+ func (it *OmniPortalXMsgDefaultGasLimitChangedIterator) Error() error

+ func (it *OmniPortalXMsgDefaultGasLimitChangedIterator) Next() bool

+ type OmniPortalXMsgMaxGasLimitChanged struct

+ NewMax uint64

+ OldMax uint64

+ Raw types.Log

+ type OmniPortalXMsgMaxGasLimitChangedIterator struct

+ Event *OmniPortalXMsgMaxGasLimitChanged

+ func (it *OmniPortalXMsgMaxGasLimitChangedIterator) Close() error

+ func (it *OmniPortalXMsgMaxGasLimitChangedIterator) Error() error

+ func (it *OmniPortalXMsgMaxGasLimitChangedIterator) Next() bool

+ type OmniPortalXMsgMinGasLimitChanged struct

+ NewMin uint64

+ OldMin uint64

+ Raw types.Log

+ type OmniPortalXMsgMinGasLimitChangedIterator struct

+ Event *OmniPortalXMsgMinGasLimitChanged

+ func (it *OmniPortalXMsgMinGasLimitChangedIterator) Close() error

+ func (it *OmniPortalXMsgMinGasLimitChangedIterator) Error() error

+ func (it *OmniPortalXMsgMinGasLimitChangedIterator) Next() bool

type OmniPortalXReceipt

+ Error []byte

+ type OmniPortalXReceiptMaxErrorBytesChanged struct

+ NewMax uint64

+ OldMax uint64

+ Raw types.Log

+ type OmniPortalXReceiptMaxErrorBytesChangedIterator struct

+ Event *OmniPortalXReceiptMaxErrorBytesChanged

+ func (it *OmniPortalXReceiptMaxErrorBytesChangedIterator) Close() error

+ func (it *OmniPortalXReceiptMaxErrorBytesChangedIterator) Error() error

+ func (it *OmniPortalXReceiptMaxErrorBytesChangedIterator) Next() bool

type PortalRegistryCaller

+ func (_PortalRegistry *PortalRegistryCaller) IsRegistered(opts *bind.CallOpts, chainId uint64) (bool, error)

+ func (_PortalRegistry *PortalRegistryCaller) RegistrationFee(opts *bind.CallOpts, deployment PortalRegistryDeployment) (*big.Int, error)

+ func (_PortalRegistry *PortalRegistryCaller) Xregistry(opts *bind.CallOpts) (common.Address, error)

type PortalRegistryCallerSession

+ func (_PortalRegistry *PortalRegistryCallerSession) IsRegistered(chainId uint64) (bool, error)

+ func (_PortalRegistry *PortalRegistryCallerSession) RegistrationFee(deployment PortalRegistryDeployment) (*big.Int, error)

+ func (_PortalRegistry *PortalRegistryCallerSession) Xregistry() (common.Address, error)

type PortalRegistryDeployment

+ FinalizationStrat string

type PortalRegistryPortalRegistered

+ FinalizationStrat string

type PortalRegistrySession

+ func (_PortalRegistry *PortalRegistrySession) IsRegistered(chainId uint64) (bool, error)

+ func (_PortalRegistry *PortalRegistrySession) RegistrationFee(deployment PortalRegistryDeployment) (*big.Int, error)

+ func (_PortalRegistry *PortalRegistrySession) Xregistry() (common.Address, error)

+ type XRegistry struct

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

+ func NewXRegistry(address common.Address, backend bind.ContractBackend) (*XRegistry, error)

+ type XRegistryCaller struct

+ func NewXRegistryCaller(address common.Address, caller bind.ContractCaller) (*XRegistryCaller, error)

+ func (_XRegistry *XRegistryCaller) ChainIds(opts *bind.CallOpts) ([]uint64, error)

+ func (_XRegistry *XRegistryCaller) Get(opts *bind.CallOpts, chainId uint64, name string, registrant common.Address) (common.Address, error)

+ func (_XRegistry *XRegistryCaller) Has(opts *bind.CallOpts, chainId uint64, name string, registrant common.Address) (bool, error)

+ func (_XRegistry *XRegistryCaller) IsSupportedChain(opts *bind.CallOpts, chainId uint64) (bool, error)

+ func (_XRegistry *XRegistryCaller) Omni(opts *bind.CallOpts) (common.Address, error)

+ func (_XRegistry *XRegistryCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_XRegistry *XRegistryCaller) RegistrationFee(opts *bind.CallOpts, chainId uint64, name string, addr common.Address) (*big.Int, error)

+ func (_XRegistry *XRegistryCaller) Replicas(opts *bind.CallOpts, arg0 uint64) (common.Address, error)

+ func (_XRegistry *XRegistryCaller) XSETGASLIMIT(opts *bind.CallOpts) (uint64, error)

+ type XRegistryCallerRaw struct

+ Contract *XRegistryCaller

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

+ type XRegistryCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *XRegistryCaller

+ func (_XRegistry *XRegistryCallerSession) ChainIds() ([]uint64, error)

+ func (_XRegistry *XRegistryCallerSession) Get(chainId uint64, name string, registrant common.Address) (common.Address, error)

+ func (_XRegistry *XRegistryCallerSession) Has(chainId uint64, name string, registrant common.Address) (bool, error)

+ func (_XRegistry *XRegistryCallerSession) IsSupportedChain(chainId uint64) (bool, error)

+ func (_XRegistry *XRegistryCallerSession) Omni() (common.Address, error)

+ func (_XRegistry *XRegistryCallerSession) Owner() (common.Address, error)

+ func (_XRegistry *XRegistryCallerSession) RegistrationFee(chainId uint64, name string, addr common.Address) (*big.Int, error)

+ func (_XRegistry *XRegistryCallerSession) Replicas(arg0 uint64) (common.Address, error)

+ func (_XRegistry *XRegistryCallerSession) XSETGASLIMIT() (uint64, error)

+ type XRegistryContractRegistered struct

+ Addr common.Address

+ ChainId uint64

+ Name common.Hash

+ Raw types.Log

+ Registrant common.Address

+ type XRegistryContractRegisteredIterator struct

+ Event *XRegistryContractRegistered

+ func (it *XRegistryContractRegisteredIterator) Close() error

+ func (it *XRegistryContractRegisteredIterator) Error() error

+ func (it *XRegistryContractRegisteredIterator) Next() bool

+ type XRegistryFilterer struct

+ func NewXRegistryFilterer(address common.Address, filterer bind.ContractFilterer) (*XRegistryFilterer, error)

+ func (_XRegistry *XRegistryFilterer) FilterContractRegistered(opts *bind.FilterOpts, chainId []uint64, name []string, ...) (*XRegistryContractRegisteredIterator, error)

+ func (_XRegistry *XRegistryFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*XRegistryOwnershipTransferredIterator, error)

+ func (_XRegistry *XRegistryFilterer) ParseContractRegistered(log types.Log) (*XRegistryContractRegistered, error)

+ func (_XRegistry *XRegistryFilterer) ParseOwnershipTransferred(log types.Log) (*XRegistryOwnershipTransferred, error)

+ func (_XRegistry *XRegistryFilterer) WatchContractRegistered(opts *bind.WatchOpts, sink chan<- *XRegistryContractRegistered, ...) (event.Subscription, error)

+ func (_XRegistry *XRegistryFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *XRegistryOwnershipTransferred, ...) (event.Subscription, error)

+ type XRegistryOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type XRegistryOwnershipTransferredIterator struct

+ Event *XRegistryOwnershipTransferred

+ func (it *XRegistryOwnershipTransferredIterator) Close() error

+ func (it *XRegistryOwnershipTransferredIterator) Error() error

+ func (it *XRegistryOwnershipTransferredIterator) Next() bool

+ type XRegistryRaw struct

+ Contract *XRegistry

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

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

+ func (_XRegistry *XRegistryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type XRegistryReplica struct

+ func DeployXRegistryReplica(auth *bind.TransactOpts, backend bind.ContractBackend, omni_ common.Address) (common.Address, *types.Transaction, *XRegistryReplica, error)

+ func NewXRegistryReplica(address common.Address, backend bind.ContractBackend) (*XRegistryReplica, error)

+ type XRegistryReplicaCaller struct

+ func NewXRegistryReplicaCaller(address common.Address, caller bind.ContractCaller) (*XRegistryReplicaCaller, error)

+ func (_XRegistryReplica *XRegistryReplicaCaller) Get(opts *bind.CallOpts, chainId uint64, name string, registrant common.Address) (common.Address, error)

+ func (_XRegistryReplica *XRegistryReplicaCaller) Has(opts *bind.CallOpts, chainId uint64, name string, registrant common.Address) (bool, error)

+ type XRegistryReplicaCallerRaw struct

+ Contract *XRegistryReplicaCaller

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

+ type XRegistryReplicaCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *XRegistryReplicaCaller

+ func (_XRegistryReplica *XRegistryReplicaCallerSession) Get(chainId uint64, name string, registrant common.Address) (common.Address, error)

+ func (_XRegistryReplica *XRegistryReplicaCallerSession) Has(chainId uint64, name string, registrant common.Address) (bool, error)

+ type XRegistryReplicaFilterer struct

+ func NewXRegistryReplicaFilterer(address common.Address, filterer bind.ContractFilterer) (*XRegistryReplicaFilterer, error)

+ type XRegistryReplicaRaw struct

+ Contract *XRegistryReplica

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

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

+ func (_XRegistryReplica *XRegistryReplicaRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type XRegistryReplicaSession struct

+ CallOpts bind.CallOpts

+ Contract *XRegistryReplica

+ TransactOpts bind.TransactOpts

+ func (_XRegistryReplica *XRegistryReplicaSession) Get(chainId uint64, name string, registrant common.Address) (common.Address, error)

+ func (_XRegistryReplica *XRegistryReplicaSession) Has(chainId uint64, name string, registrant common.Address) (bool, error)

+ func (_XRegistryReplica *XRegistryReplicaSession) Set(chainId uint64, name string, registrant common.Address, addr common.Address) (*types.Transaction, error)

+ type XRegistryReplicaTransactor struct

+ func NewXRegistryReplicaTransactor(address common.Address, transactor bind.ContractTransactor) (*XRegistryReplicaTransactor, error)

+ func (_XRegistryReplica *XRegistryReplicaTransactor) Set(opts *bind.TransactOpts, chainId uint64, name string, ...) (*types.Transaction, error)

+ type XRegistryReplicaTransactorRaw struct

+ Contract *XRegistryReplicaTransactor

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

+ func (_XRegistryReplica *XRegistryReplicaTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type XRegistryReplicaTransactorSession struct

+ Contract *XRegistryReplicaTransactor

+ TransactOpts bind.TransactOpts

+ func (_XRegistryReplica *XRegistryReplicaTransactorSession) Set(chainId uint64, name string, registrant common.Address, addr common.Address) (*types.Transaction, error)

+ type XRegistrySession struct

+ CallOpts bind.CallOpts

+ Contract *XRegistry

+ TransactOpts bind.TransactOpts

+ func (_XRegistry *XRegistrySession) ChainIds() ([]uint64, error)

+ func (_XRegistry *XRegistrySession) Get(chainId uint64, name string, registrant common.Address) (common.Address, error)

+ func (_XRegistry *XRegistrySession) Has(chainId uint64, name string, registrant common.Address) (bool, error)

+ func (_XRegistry *XRegistrySession) IsSupportedChain(chainId uint64) (bool, error)

+ func (_XRegistry *XRegistrySession) Omni() (common.Address, error)

+ func (_XRegistry *XRegistrySession) Owner() (common.Address, error)

+ func (_XRegistry *XRegistrySession) Register(chainId uint64, name string, addr common.Address) (*types.Transaction, error)

+ func (_XRegistry *XRegistrySession) RegistrationFee(chainId uint64, name string, addr common.Address) (*big.Int, error)

+ func (_XRegistry *XRegistrySession) RenounceOwnership() (*types.Transaction, error)

+ func (_XRegistry *XRegistrySession) Replicas(arg0 uint64) (common.Address, error)

+ func (_XRegistry *XRegistrySession) SetPortal(_omni common.Address) (*types.Transaction, error)

+ func (_XRegistry *XRegistrySession) SetReplica(chainId uint64, replica common.Address) (*types.Transaction, error)

+ func (_XRegistry *XRegistrySession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_XRegistry *XRegistrySession) XSETGASLIMIT() (uint64, error)

+ type XRegistryTransactor struct

+ func NewXRegistryTransactor(address common.Address, transactor bind.ContractTransactor) (*XRegistryTransactor, error)

+ func (_XRegistry *XRegistryTransactor) Register(opts *bind.TransactOpts, chainId uint64, name string, addr common.Address) (*types.Transaction, error)

+ func (_XRegistry *XRegistryTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_XRegistry *XRegistryTransactor) SetPortal(opts *bind.TransactOpts, _omni common.Address) (*types.Transaction, error)

+ func (_XRegistry *XRegistryTransactor) SetReplica(opts *bind.TransactOpts, chainId uint64, replica common.Address) (*types.Transaction, error)

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

+ type XRegistryTransactorRaw struct

+ Contract *XRegistryTransactor

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

+ func (_XRegistry *XRegistryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type XRegistryTransactorSession struct

+ Contract *XRegistryTransactor

+ TransactOpts bind.TransactOpts

+ func (_XRegistry *XRegistryTransactorSession) Register(chainId uint64, name string, addr common.Address) (*types.Transaction, error)

+ func (_XRegistry *XRegistryTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_XRegistry *XRegistryTransactorSession) SetPortal(_omni common.Address) (*types.Transaction, error)

+ func (_XRegistry *XRegistryTransactorSession) SetReplica(chainId uint64, replica common.Address) (*types.Transaction, error)

+ func (_XRegistry *XRegistryTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

v0.1.3

Apr 12, 2024

Changes in this version

+ const ProxyAdminDeployedBytecode

+ const TransparentUpgradeableProxyDeployedBytecode

+ var Create3StorageLayout = mustGetStorageLayout(create3StorageLayoutJSON)

+ var OmniStakeStorageLayout = mustGetStorageLayout(omnistakeStorageLayoutJSON)

+ var ProxyAdminStorageLayout = mustGetStorageLayout(proxyadminStorageLayoutJSON)

+ var TransparentUpgradeableProxyStorageLayout = mustGetStorageLayout(transparentupgradeableproxyStorageLayoutJSON)

type OmniPortalCaller

+ func (_OmniPortal *OmniPortalCaller) OmniCChainID(opts *bind.CallOpts) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) OmniEChainId(opts *bind.CallOpts) (uint64, error)

type OmniPortalCallerSession

+ func (_OmniPortal *OmniPortalCallerSession) OmniCChainID() (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) OmniEChainId() (uint64, error)

type OmniPortalSession

+ func (_OmniPortal *OmniPortalSession) OmniCChainID() (uint64, error)

+ func (_OmniPortal *OmniPortalSession) OmniEChainId() (uint64, error)

v0.1.2

Mar 27, 2024

Changes in this version

+ const Create3DeployedBytecode

+ const OmniStakeDeployedBytecode

type OmniAVSSession

+ func (_OmniAVS *OmniAVSSession) DeregisterOperator() (*types.Transaction, error)

type OmniAVSTransactor

+ func (_OmniAVS *OmniAVSTransactor) DeregisterOperator(opts *bind.TransactOpts) (*types.Transaction, error)

type OmniAVSTransactorSession

+ func (_OmniAVS *OmniAVSTransactorSession) DeregisterOperator() (*types.Transaction, error)

type OmniPortalCaller

+ func (_OmniPortal *OmniPortalCaller) InXStreamValidatorSetId(opts *bind.CallOpts, arg0 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) ValidatorSet(opts *bind.CallOpts, arg0 uint64, arg1 common.Address) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) ValidatorSetTotalPower(opts *bind.CallOpts, arg0 uint64) (uint64, error)

type OmniPortalCallerSession

+ func (_OmniPortal *OmniPortalCallerSession) InXStreamValidatorSetId(arg0 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) ValidatorSet(arg0 uint64, arg1 common.Address) (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) ValidatorSetTotalPower(arg0 uint64) (uint64, error)

type OmniPortalSession

+ func (_OmniPortal *OmniPortalSession) InXStreamValidatorSetId(arg0 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalSession) ValidatorSet(arg0 uint64, arg1 common.Address) (uint64, error)

+ func (_OmniPortal *OmniPortalSession) ValidatorSetTotalPower(arg0 uint64) (uint64, error)

type OmniStakeDeposit

+ Pubkey []byte

v0.1.1

Mar 12, 2024

Changes in this version

+ var OmniStakeABI = OmniStakeMetaData.ABI

+ var OmniStakeBin = OmniStakeMetaData.Bin

+ var OmniStakeMetaData = &bind.MetaData

+ type OmniStake struct

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

+ func NewOmniStake(address common.Address, backend bind.ContractBackend) (*OmniStake, error)

+ type OmniStakeCaller struct

+ func NewOmniStakeCaller(address common.Address, caller bind.ContractCaller) (*OmniStakeCaller, error)

+ type OmniStakeCallerRaw struct

+ Contract *OmniStakeCaller

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

+ type OmniStakeCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OmniStakeCaller

+ type OmniStakeDeposit struct

+ Amount *big.Int

+ Depositor common.Address

+ Raw types.Log

+ type OmniStakeDepositIterator struct

+ Event *OmniStakeDeposit

+ func (it *OmniStakeDepositIterator) Close() error

+ func (it *OmniStakeDepositIterator) Error() error

+ func (it *OmniStakeDepositIterator) Next() bool

+ type OmniStakeFilterer struct

+ func NewOmniStakeFilterer(address common.Address, filterer bind.ContractFilterer) (*OmniStakeFilterer, error)

+ func (_OmniStake *OmniStakeFilterer) FilterDeposit(opts *bind.FilterOpts, depositor []common.Address) (*OmniStakeDepositIterator, error)

+ func (_OmniStake *OmniStakeFilterer) ParseDeposit(log types.Log) (*OmniStakeDeposit, error)

+ func (_OmniStake *OmniStakeFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *OmniStakeDeposit, ...) (event.Subscription, error)

+ type OmniStakeRaw struct

+ Contract *OmniStake

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

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

+ func (_OmniStake *OmniStakeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OmniStakeSession struct

+ CallOpts bind.CallOpts

+ Contract *OmniStake

+ TransactOpts bind.TransactOpts

+ func (_OmniStake *OmniStakeSession) Deposit() (*types.Transaction, error)

+ type OmniStakeTransactor struct

+ func NewOmniStakeTransactor(address common.Address, transactor bind.ContractTransactor) (*OmniStakeTransactor, error)

+ func (_OmniStake *OmniStakeTransactor) Deposit(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OmniStakeTransactorRaw struct

+ Contract *OmniStakeTransactor

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

+ func (_OmniStake *OmniStakeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OmniStakeTransactorSession struct

+ Contract *OmniStakeTransactor

+ TransactOpts bind.TransactOpts

+ func (_OmniStake *OmniStakeTransactorSession) Deposit() (*types.Transaction, error)

v0.1.0

Mar 5, 2024

Changes in this version

type FeeOracleV1Caller

+ func (_FeeOracleV1 *FeeOracleV1Caller) Fee(opts *bind.CallOpts) (*big.Int, error)

type FeeOracleV1CallerSession

+ func (_FeeOracleV1 *FeeOracleV1CallerSession) Fee() (*big.Int, error)

+ type FeeOracleV1FeeChanged struct

+ NewFee *big.Int

+ OldFee *big.Int

+ Raw types.Log

+ type FeeOracleV1FeeChangedIterator struct

+ Event *FeeOracleV1FeeChanged

+ func (it *FeeOracleV1FeeChangedIterator) Close() error

+ func (it *FeeOracleV1FeeChangedIterator) Error() error

+ func (it *FeeOracleV1FeeChangedIterator) Next() bool

type FeeOracleV1Filterer

+ func (_FeeOracleV1 *FeeOracleV1Filterer) FilterFeeChanged(opts *bind.FilterOpts) (*FeeOracleV1FeeChangedIterator, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) ParseFeeChanged(log types.Log) (*FeeOracleV1FeeChanged, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) WatchFeeChanged(opts *bind.WatchOpts, sink chan<- *FeeOracleV1FeeChanged) (event.Subscription, error)

type FeeOracleV1Session

+ func (_FeeOracleV1 *FeeOracleV1Session) Fee() (*big.Int, error)

+ func (_FeeOracleV1 *FeeOracleV1Session) SetFee(fee_ *big.Int) (*types.Transaction, error)

type FeeOracleV1Transactor

+ func (_FeeOracleV1 *FeeOracleV1Transactor) SetFee(opts *bind.TransactOpts, fee_ *big.Int) (*types.Transaction, error)

type FeeOracleV1TransactorSession

+ func (_FeeOracleV1 *FeeOracleV1TransactorSession) SetFee(fee_ *big.Int) (*types.Transaction, error)

type OmniAVSSession

+ func (_OmniAVS *OmniAVSSession) DeregisterOperatorFromAVS(operator common.Address) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSSession) RegisterOperatorToAVS(operator common.Address, ...) (*types.Transaction, error)

type OmniAVSTransactor

+ func (_OmniAVS *OmniAVSTransactor) DeregisterOperatorFromAVS(opts *bind.TransactOpts, operator common.Address) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactor) RegisterOperatorToAVS(opts *bind.TransactOpts, operator common.Address, ...) (*types.Transaction, error)

type OmniAVSTransactorSession

+ func (_OmniAVS *OmniAVSTransactorSession) DeregisterOperatorFromAVS(operator common.Address) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactorSession) RegisterOperatorToAVS(operator common.Address, ...) (*types.Transaction, error)

type OmniPortalCaller

+ func (_OmniPortal *OmniPortalCaller) FeeFor0(opts *bind.CallOpts, destChainId uint64, data []byte, gasLimit uint64) (*big.Int, error)

+ func (_OmniPortal *OmniPortalCaller) InXStreamBlockHeight(opts *bind.CallOpts, arg0 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) InXStreamOffset(opts *bind.CallOpts, arg0 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) OutXStreamOffset(opts *bind.CallOpts, arg0 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) XMSGDEFAULTGASLIMIT(opts *bind.CallOpts) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) XMSGMAXGASLIMIT(opts *bind.CallOpts) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) XMSGMINGASLIMIT(opts *bind.CallOpts) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) XSUBQUORUMDENOMINATOR(opts *bind.CallOpts) (uint8, error)

+ func (_OmniPortal *OmniPortalCaller) XSUBQUORUMNUMERATOR(opts *bind.CallOpts) (uint8, error)

type OmniPortalCallerSession

+ func (_OmniPortal *OmniPortalCallerSession) FeeFor0(destChainId uint64, data []byte, gasLimit uint64) (*big.Int, error)

+ func (_OmniPortal *OmniPortalCallerSession) InXStreamBlockHeight(arg0 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) InXStreamOffset(arg0 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) OutXStreamOffset(arg0 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) XMSGDEFAULTGASLIMIT() (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) XMSGMAXGASLIMIT() (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) XMSGMINGASLIMIT() (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) XSUBQUORUMDENOMINATOR() (uint8, error)

+ func (_OmniPortal *OmniPortalCallerSession) XSUBQUORUMNUMERATOR() (uint8, error)

+ type OmniPortalFeeOracleChanged struct

+ NewFeeOracle common.Address

+ OldFeeOracle common.Address

+ Raw types.Log

+ type OmniPortalFeeOracleChangedIterator struct

+ Event *OmniPortalFeeOracleChanged

+ func (it *OmniPortalFeeOracleChangedIterator) Close() error

+ func (it *OmniPortalFeeOracleChangedIterator) Error() error

+ func (it *OmniPortalFeeOracleChangedIterator) Next() bool

type OmniPortalFilterer

+ func (_OmniPortal *OmniPortalFilterer) FilterFeeOracleChanged(opts *bind.FilterOpts, oldFeeOracle []common.Address, ...) (*OmniPortalFeeOracleChangedIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseFeeOracleChanged(log types.Log) (*OmniPortalFeeOracleChanged, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchFeeOracleChanged(opts *bind.WatchOpts, sink chan<- *OmniPortalFeeOracleChanged, ...) (event.Subscription, error)

type OmniPortalSession

+ func (_OmniPortal *OmniPortalSession) FeeFor0(destChainId uint64, data []byte, gasLimit uint64) (*big.Int, error)

+ func (_OmniPortal *OmniPortalSession) InXStreamBlockHeight(arg0 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalSession) InXStreamOffset(arg0 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalSession) OutXStreamOffset(arg0 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalSession) XMSGDEFAULTGASLIMIT() (uint64, error)

+ func (_OmniPortal *OmniPortalSession) XMSGMAXGASLIMIT() (uint64, error)

+ func (_OmniPortal *OmniPortalSession) XMSGMINGASLIMIT() (uint64, error)

+ func (_OmniPortal *OmniPortalSession) XSUBQUORUMDENOMINATOR() (uint8, error)

+ func (_OmniPortal *OmniPortalSession) XSUBQUORUMNUMERATOR() (uint8, error)

+ func (_OmniPortal *OmniPortalSession) Xcall0(destChainId uint64, to common.Address, data []byte, gasLimit uint64) (*types.Transaction, error)

type OmniPortalTransactor

+ func (_OmniPortal *OmniPortalTransactor) Xcall0(opts *bind.TransactOpts, destChainId uint64, to common.Address, data []byte, ...) (*types.Transaction, error)

type OmniPortalTransactorSession

+ func (_OmniPortal *OmniPortalTransactorSession) Xcall0(destChainId uint64, to common.Address, data []byte, gasLimit uint64) (*types.Transaction, error)

type OmniPortalXMsg

+ StreamOffset uint64

type OmniPortalXReceipt

+ StreamOffset uint64

type ProxyAdminCaller

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

type ProxyAdminCallerSession

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

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

type ProxyAdminSession

+ 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) Upgrade(proxy common.Address, implementation common.Address) (*types.Transaction, error)

type ProxyAdminTransactor

+ func (_ProxyAdmin *ProxyAdminTransactor) ChangeProxyAdmin(opts *bind.TransactOpts, proxy common.Address, newAdmin common.Address) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminTransactor) Upgrade(opts *bind.TransactOpts, proxy common.Address, implementation common.Address) (*types.Transaction, error)

type ProxyAdminTransactorSession

+ func (_ProxyAdmin *ProxyAdminTransactorSession) ChangeProxyAdmin(proxy common.Address, newAdmin common.Address) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminTransactorSession) Upgrade(proxy common.Address, implementation common.Address) (*types.Transaction, error)

+ type TransparentUpgradeableProxyBeaconUpgraded struct

+ Beacon common.Address

+ Raw types.Log

+ type TransparentUpgradeableProxyBeaconUpgradedIterator struct

+ Event *TransparentUpgradeableProxyBeaconUpgraded

+ func (it *TransparentUpgradeableProxyBeaconUpgradedIterator) Close() error

+ func (it *TransparentUpgradeableProxyBeaconUpgradedIterator) Error() error

+ func (it *TransparentUpgradeableProxyBeaconUpgradedIterator) Next() bool

type TransparentUpgradeableProxyFilterer

+ func (_TransparentUpgradeableProxy *TransparentUpgradeableProxyFilterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*TransparentUpgradeableProxyBeaconUpgradedIterator, error)

+ func (_TransparentUpgradeableProxy *TransparentUpgradeableProxyFilterer) ParseBeaconUpgraded(log types.Log) (*TransparentUpgradeableProxyBeaconUpgraded, error)

+ func (_TransparentUpgradeableProxy *TransparentUpgradeableProxyFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *TransparentUpgradeableProxyBeaconUpgraded, ...) (event.Subscription, error)

type TransparentUpgradeableProxySession

+ func (_TransparentUpgradeableProxy *TransparentUpgradeableProxySession) Receive() (*types.Transaction, error)

type TransparentUpgradeableProxyTransactor

+ func (_TransparentUpgradeableProxy *TransparentUpgradeableProxyTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

type TransparentUpgradeableProxyTransactorSession

+ func (_TransparentUpgradeableProxy *TransparentUpgradeableProxyTransactorSession) Receive() (*types.Transaction, error)

+ type XMsgShort = XTypesMsgShort

type XTypesBlockHeader

+ BlockHash [32]byte

+ BlockHeight uint64

type XTypesMsg

+ SourceChainId uint64

+ StreamOffset uint64

+ type XTypesMsgShort struct

+ Sender common.Address

+ SourceChainId uint64

v0.1.0-rc3

Mar 6, 2024

v0.1.0-rc2

Mar 5, 2024

v0.1.0-rc1

Mar 5, 2024

v0.0.1

Oct 1, 2024

Changes in this version

+ var AVSDirectoryABI = AVSDirectoryMetaData.ABI

+ var AVSDirectoryBin = AVSDirectoryMetaData.Bin

+ var AVSDirectoryMetaData = &bind.MetaData

+ var AdminABI = AdminMetaData.ABI

+ var AdminBin = AdminMetaData.Bin

+ var AdminMetaData = &bind.MetaData

+ var AllocPredeploysABI = AllocPredeploysMetaData.ABI

+ var AllocPredeploysBin = AllocPredeploysMetaData.Bin

+ var AllocPredeploysMetaData = &bind.MetaData

+ var Create3ABI = Create3MetaData.ABI

+ var Create3Bin = Create3MetaData.Bin

+ var Create3MetaData = &bind.MetaData

+ var DelegationManagerABI = DelegationManagerMetaData.ABI

+ var DelegationManagerBin = DelegationManagerMetaData.Bin

+ var DelegationManagerMetaData = &bind.MetaData

+ var FeeOracleV1ABI = FeeOracleV1MetaData.ABI

+ var FeeOracleV1Bin = FeeOracleV1MetaData.Bin

+ var FeeOracleV1MetaData = &bind.MetaData

+ var MockERC20ABI = MockERC20MetaData.ABI

+ var MockERC20Bin = MockERC20MetaData.Bin

+ var MockERC20MetaData = &bind.MetaData

+ var OmniABI = OmniMetaData.ABI

+ var OmniAVSABI = OmniAVSMetaData.ABI

+ var OmniAVSBin = OmniAVSMetaData.Bin

+ var OmniAVSMetaData = &bind.MetaData

+ var OmniBin = OmniMetaData.Bin

+ var OmniBridgeL1ABI = OmniBridgeL1MetaData.ABI

+ var OmniBridgeL1Bin = OmniBridgeL1MetaData.Bin

+ var OmniBridgeL1MetaData = &bind.MetaData

+ var OmniBridgeNativeABI = OmniBridgeNativeMetaData.ABI

+ var OmniBridgeNativeBin = OmniBridgeNativeMetaData.Bin

+ var OmniBridgeNativeMetaData = &bind.MetaData

+ var OmniGasPumpABI = OmniGasPumpMetaData.ABI

+ var OmniGasPumpBin = OmniGasPumpMetaData.Bin

+ var OmniGasPumpMetaData = &bind.MetaData

+ var OmniGasStationABI = OmniGasStationMetaData.ABI

+ var OmniGasStationBin = OmniGasStationMetaData.Bin

+ var OmniGasStationMetaData = &bind.MetaData

+ var OmniMetaData = &bind.MetaData

+ var OmniPortalABI = OmniPortalMetaData.ABI

+ var OmniPortalBin = OmniPortalMetaData.Bin

+ var OmniPortalMetaData = &bind.MetaData

+ var PingPongABI = PingPongMetaData.ABI

+ var PingPongBin = PingPongMetaData.Bin

+ var PingPongMetaData = &bind.MetaData

+ var PortalRegistryABI = PortalRegistryMetaData.ABI

+ var PortalRegistryBin = PortalRegistryMetaData.Bin

+ var PortalRegistryMetaData = &bind.MetaData

+ var ProxyAdminABI = ProxyAdminMetaData.ABI

+ var ProxyAdminBin = ProxyAdminMetaData.Bin

+ var ProxyAdminMetaData = &bind.MetaData

+ var SlashingABI = SlashingMetaData.ABI

+ var SlashingBin = SlashingMetaData.Bin

+ var SlashingMetaData = &bind.MetaData

+ var StakingABI = StakingMetaData.ABI

+ var StakingBin = StakingMetaData.Bin

+ var StakingMetaData = &bind.MetaData

+ var StrategyBaseABI = StrategyBaseMetaData.ABI

+ var StrategyBaseBin = StrategyBaseMetaData.Bin

+ var StrategyBaseMetaData = &bind.MetaData

+ var StrategyManagerABI = StrategyManagerMetaData.ABI

+ var StrategyManagerBin = StrategyManagerMetaData.Bin

+ var StrategyManagerMetaData = &bind.MetaData

+ var TransparentUpgradeableProxyABI = TransparentUpgradeableProxyMetaData.ABI

+ var TransparentUpgradeableProxyBin = TransparentUpgradeableProxyMetaData.Bin

+ var TransparentUpgradeableProxyMetaData = &bind.MetaData

+ var UpgradeABI = UpgradeMetaData.ABI

+ var UpgradeBin = UpgradeMetaData.Bin

+ var UpgradeMetaData = &bind.MetaData

+ var WOmniABI = WOmniMetaData.ABI

+ var WOmniBin = WOmniMetaData.Bin

+ var WOmniMetaData = &bind.MetaData

+ type AVSDirectory struct

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

+ func NewAVSDirectory(address common.Address, backend bind.ContractBackend) (*AVSDirectory, error)

+ type AVSDirectoryAVSMetadataURIUpdated struct

+ Avs common.Address

+ MetadataURI string

+ Raw types.Log

+ type AVSDirectoryAVSMetadataURIUpdatedIterator struct

+ Event *AVSDirectoryAVSMetadataURIUpdated

+ func (it *AVSDirectoryAVSMetadataURIUpdatedIterator) Close() error

+ func (it *AVSDirectoryAVSMetadataURIUpdatedIterator) Error() error

+ func (it *AVSDirectoryAVSMetadataURIUpdatedIterator) Next() bool

+ type AVSDirectoryCaller struct

+ func NewAVSDirectoryCaller(address common.Address, caller bind.ContractCaller) (*AVSDirectoryCaller, error)

+ func (_AVSDirectory *AVSDirectoryCaller) AvsOperatorStatus(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (uint8, error)

+ func (_AVSDirectory *AVSDirectoryCaller) CalculateOperatorAVSRegistrationDigestHash(opts *bind.CallOpts, operator common.Address, avs common.Address, ...) ([32]byte, error)

+ func (_AVSDirectory *AVSDirectoryCaller) DOMAINTYPEHASH(opts *bind.CallOpts) ([32]byte, error)

+ func (_AVSDirectory *AVSDirectoryCaller) Delegation(opts *bind.CallOpts) (common.Address, error)

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

+ func (_AVSDirectory *AVSDirectoryCaller) OPERATORAVSREGISTRATIONTYPEHASH(opts *bind.CallOpts) ([32]byte, error)

+ func (_AVSDirectory *AVSDirectoryCaller) OperatorSaltIsSpent(opts *bind.CallOpts, arg0 common.Address, arg1 [32]byte) (bool, error)

+ func (_AVSDirectory *AVSDirectoryCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_AVSDirectory *AVSDirectoryCaller) Paused(opts *bind.CallOpts, index uint8) (bool, error)

+ func (_AVSDirectory *AVSDirectoryCaller) Paused0(opts *bind.CallOpts) (*big.Int, error)

+ func (_AVSDirectory *AVSDirectoryCaller) PauserRegistry(opts *bind.CallOpts) (common.Address, error)

+ type AVSDirectoryCallerRaw struct

+ Contract *AVSDirectoryCaller

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

+ type AVSDirectoryCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *AVSDirectoryCaller

+ func (_AVSDirectory *AVSDirectoryCallerSession) AvsOperatorStatus(arg0 common.Address, arg1 common.Address) (uint8, error)

+ func (_AVSDirectory *AVSDirectoryCallerSession) CalculateOperatorAVSRegistrationDigestHash(operator common.Address, avs common.Address, salt [32]byte, expiry *big.Int) ([32]byte, error)

+ func (_AVSDirectory *AVSDirectoryCallerSession) DOMAINTYPEHASH() ([32]byte, error)

+ func (_AVSDirectory *AVSDirectoryCallerSession) Delegation() (common.Address, error)

+ func (_AVSDirectory *AVSDirectoryCallerSession) DomainSeparator() ([32]byte, error)

+ func (_AVSDirectory *AVSDirectoryCallerSession) OPERATORAVSREGISTRATIONTYPEHASH() ([32]byte, error)

+ func (_AVSDirectory *AVSDirectoryCallerSession) OperatorSaltIsSpent(arg0 common.Address, arg1 [32]byte) (bool, error)

+ func (_AVSDirectory *AVSDirectoryCallerSession) Owner() (common.Address, error)

+ func (_AVSDirectory *AVSDirectoryCallerSession) Paused(index uint8) (bool, error)

+ func (_AVSDirectory *AVSDirectoryCallerSession) Paused0() (*big.Int, error)

+ func (_AVSDirectory *AVSDirectoryCallerSession) PauserRegistry() (common.Address, error)

+ type AVSDirectoryFilterer struct

+ func NewAVSDirectoryFilterer(address common.Address, filterer bind.ContractFilterer) (*AVSDirectoryFilterer, error)

+ func (_AVSDirectory *AVSDirectoryFilterer) FilterAVSMetadataURIUpdated(opts *bind.FilterOpts, avs []common.Address) (*AVSDirectoryAVSMetadataURIUpdatedIterator, error)

+ func (_AVSDirectory *AVSDirectoryFilterer) FilterInitialized(opts *bind.FilterOpts) (*AVSDirectoryInitializedIterator, error)

+ func (_AVSDirectory *AVSDirectoryFilterer) FilterOperatorAVSRegistrationStatusUpdated(opts *bind.FilterOpts, operator []common.Address, avs []common.Address) (*AVSDirectoryOperatorAVSRegistrationStatusUpdatedIterator, error)

+ func (_AVSDirectory *AVSDirectoryFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*AVSDirectoryOwnershipTransferredIterator, error)

+ func (_AVSDirectory *AVSDirectoryFilterer) FilterPaused(opts *bind.FilterOpts, account []common.Address) (*AVSDirectoryPausedIterator, error)

+ func (_AVSDirectory *AVSDirectoryFilterer) FilterPauserRegistrySet(opts *bind.FilterOpts) (*AVSDirectoryPauserRegistrySetIterator, error)

+ func (_AVSDirectory *AVSDirectoryFilterer) FilterUnpaused(opts *bind.FilterOpts, account []common.Address) (*AVSDirectoryUnpausedIterator, error)

+ func (_AVSDirectory *AVSDirectoryFilterer) ParseAVSMetadataURIUpdated(log types.Log) (*AVSDirectoryAVSMetadataURIUpdated, error)

+ func (_AVSDirectory *AVSDirectoryFilterer) ParseInitialized(log types.Log) (*AVSDirectoryInitialized, error)

+ func (_AVSDirectory *AVSDirectoryFilterer) ParseOperatorAVSRegistrationStatusUpdated(log types.Log) (*AVSDirectoryOperatorAVSRegistrationStatusUpdated, error)

+ func (_AVSDirectory *AVSDirectoryFilterer) ParseOwnershipTransferred(log types.Log) (*AVSDirectoryOwnershipTransferred, error)

+ func (_AVSDirectory *AVSDirectoryFilterer) ParsePaused(log types.Log) (*AVSDirectoryPaused, error)

+ func (_AVSDirectory *AVSDirectoryFilterer) ParsePauserRegistrySet(log types.Log) (*AVSDirectoryPauserRegistrySet, error)

+ func (_AVSDirectory *AVSDirectoryFilterer) ParseUnpaused(log types.Log) (*AVSDirectoryUnpaused, error)

+ func (_AVSDirectory *AVSDirectoryFilterer) WatchAVSMetadataURIUpdated(opts *bind.WatchOpts, sink chan<- *AVSDirectoryAVSMetadataURIUpdated, ...) (event.Subscription, error)

+ func (_AVSDirectory *AVSDirectoryFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *AVSDirectoryInitialized) (event.Subscription, error)

+ func (_AVSDirectory *AVSDirectoryFilterer) WatchOperatorAVSRegistrationStatusUpdated(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ func (_AVSDirectory *AVSDirectoryFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *AVSDirectoryOwnershipTransferred, ...) (event.Subscription, error)

+ func (_AVSDirectory *AVSDirectoryFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *AVSDirectoryPaused, ...) (event.Subscription, error)

+ func (_AVSDirectory *AVSDirectoryFilterer) WatchPauserRegistrySet(opts *bind.WatchOpts, sink chan<- *AVSDirectoryPauserRegistrySet) (event.Subscription, error)

+ func (_AVSDirectory *AVSDirectoryFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *AVSDirectoryUnpaused, ...) (event.Subscription, error)

+ type AVSDirectoryInitialized struct

+ Raw types.Log

+ Version uint8

+ type AVSDirectoryInitializedIterator struct

+ Event *AVSDirectoryInitialized

+ func (it *AVSDirectoryInitializedIterator) Close() error

+ func (it *AVSDirectoryInitializedIterator) Error() error

+ func (it *AVSDirectoryInitializedIterator) Next() bool

+ type AVSDirectoryOperatorAVSRegistrationStatusUpdated struct

+ Avs common.Address

+ Operator common.Address

+ Raw types.Log

+ Status uint8

+ type AVSDirectoryOperatorAVSRegistrationStatusUpdatedIterator struct

+ Event *AVSDirectoryOperatorAVSRegistrationStatusUpdated

+ func (it *AVSDirectoryOperatorAVSRegistrationStatusUpdatedIterator) Close() error

+ func (it *AVSDirectoryOperatorAVSRegistrationStatusUpdatedIterator) Error() error

+ func (it *AVSDirectoryOperatorAVSRegistrationStatusUpdatedIterator) Next() bool

+ type AVSDirectoryOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type AVSDirectoryOwnershipTransferredIterator struct

+ Event *AVSDirectoryOwnershipTransferred

+ func (it *AVSDirectoryOwnershipTransferredIterator) Close() error

+ func (it *AVSDirectoryOwnershipTransferredIterator) Error() error

+ func (it *AVSDirectoryOwnershipTransferredIterator) Next() bool

+ type AVSDirectoryPaused struct

+ Account common.Address

+ NewPausedStatus *big.Int

+ Raw types.Log

+ type AVSDirectoryPausedIterator struct

+ Event *AVSDirectoryPaused

+ func (it *AVSDirectoryPausedIterator) Close() error

+ func (it *AVSDirectoryPausedIterator) Error() error

+ func (it *AVSDirectoryPausedIterator) Next() bool

+ type AVSDirectoryPauserRegistrySet struct

+ NewPauserRegistry common.Address

+ PauserRegistry common.Address

+ Raw types.Log

+ type AVSDirectoryPauserRegistrySetIterator struct

+ Event *AVSDirectoryPauserRegistrySet

+ func (it *AVSDirectoryPauserRegistrySetIterator) Close() error

+ func (it *AVSDirectoryPauserRegistrySetIterator) Error() error

+ func (it *AVSDirectoryPauserRegistrySetIterator) Next() bool

+ type AVSDirectoryRaw struct

+ Contract *AVSDirectory

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

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

+ func (_AVSDirectory *AVSDirectoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AVSDirectorySession struct

+ CallOpts bind.CallOpts

+ Contract *AVSDirectory

+ TransactOpts bind.TransactOpts

+ func (_AVSDirectory *AVSDirectorySession) AvsOperatorStatus(arg0 common.Address, arg1 common.Address) (uint8, error)

+ func (_AVSDirectory *AVSDirectorySession) CalculateOperatorAVSRegistrationDigestHash(operator common.Address, avs common.Address, salt [32]byte, expiry *big.Int) ([32]byte, error)

+ func (_AVSDirectory *AVSDirectorySession) CancelSalt(salt [32]byte) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectorySession) DOMAINTYPEHASH() ([32]byte, error)

+ func (_AVSDirectory *AVSDirectorySession) Delegation() (common.Address, error)

+ func (_AVSDirectory *AVSDirectorySession) DeregisterOperatorFromAVS(operator common.Address) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectorySession) DomainSeparator() ([32]byte, error)

+ func (_AVSDirectory *AVSDirectorySession) Initialize(initialOwner common.Address, _pauserRegistry common.Address, ...) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectorySession) OPERATORAVSREGISTRATIONTYPEHASH() ([32]byte, error)

+ func (_AVSDirectory *AVSDirectorySession) OperatorSaltIsSpent(arg0 common.Address, arg1 [32]byte) (bool, error)

+ func (_AVSDirectory *AVSDirectorySession) Owner() (common.Address, error)

+ func (_AVSDirectory *AVSDirectorySession) Pause(newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectorySession) PauseAll() (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectorySession) Paused(index uint8) (bool, error)

+ func (_AVSDirectory *AVSDirectorySession) Paused0() (*big.Int, error)

+ func (_AVSDirectory *AVSDirectorySession) PauserRegistry() (common.Address, error)

+ func (_AVSDirectory *AVSDirectorySession) RegisterOperatorToAVS(operator common.Address, ...) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectorySession) RenounceOwnership() (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectorySession) SetPauserRegistry(newPauserRegistry common.Address) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectorySession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectorySession) Unpause(newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectorySession) UpdateAVSMetadataURI(metadataURI string) (*types.Transaction, error)

+ type AVSDirectoryTransactor struct

+ func NewAVSDirectoryTransactor(address common.Address, transactor bind.ContractTransactor) (*AVSDirectoryTransactor, error)

+ func (_AVSDirectory *AVSDirectoryTransactor) CancelSalt(opts *bind.TransactOpts, salt [32]byte) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectoryTransactor) DeregisterOperatorFromAVS(opts *bind.TransactOpts, operator common.Address) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectoryTransactor) Initialize(opts *bind.TransactOpts, initialOwner common.Address, ...) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectoryTransactor) Pause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectoryTransactor) PauseAll(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectoryTransactor) RegisterOperatorToAVS(opts *bind.TransactOpts, operator common.Address, ...) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectoryTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectoryTransactor) SetPauserRegistry(opts *bind.TransactOpts, newPauserRegistry common.Address) (*types.Transaction, error)

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

+ func (_AVSDirectory *AVSDirectoryTransactor) Unpause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectoryTransactor) UpdateAVSMetadataURI(opts *bind.TransactOpts, metadataURI string) (*types.Transaction, error)

+ type AVSDirectoryTransactorRaw struct

+ Contract *AVSDirectoryTransactor

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

+ func (_AVSDirectory *AVSDirectoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AVSDirectoryTransactorSession struct

+ Contract *AVSDirectoryTransactor

+ TransactOpts bind.TransactOpts

+ func (_AVSDirectory *AVSDirectoryTransactorSession) CancelSalt(salt [32]byte) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectoryTransactorSession) DeregisterOperatorFromAVS(operator common.Address) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectoryTransactorSession) Initialize(initialOwner common.Address, _pauserRegistry common.Address, ...) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectoryTransactorSession) Pause(newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectoryTransactorSession) PauseAll() (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectoryTransactorSession) RegisterOperatorToAVS(operator common.Address, ...) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectoryTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectoryTransactorSession) SetPauserRegistry(newPauserRegistry common.Address) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectoryTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectoryTransactorSession) Unpause(newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_AVSDirectory *AVSDirectoryTransactorSession) UpdateAVSMetadataURI(metadataURI string) (*types.Transaction, error)

+ type AVSDirectoryUnpaused struct

+ Account common.Address

+ NewPausedStatus *big.Int

+ Raw types.Log

+ type AVSDirectoryUnpausedIterator struct

+ Event *AVSDirectoryUnpaused

+ func (it *AVSDirectoryUnpausedIterator) Close() error

+ func (it *AVSDirectoryUnpausedIterator) Error() error

+ func (it *AVSDirectoryUnpausedIterator) Next() bool

+ type Admin struct

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

+ func NewAdmin(address common.Address, backend bind.ContractBackend) (*Admin, error)

+ type AdminCaller struct

+ func NewAdminCaller(address common.Address, caller bind.ContractCaller) (*AdminCaller, error)

+ func (_Admin *AdminCaller) ISSCRIPT(opts *bind.CallOpts) (bool, error)

+ type AdminCallerRaw struct

+ Contract *AdminCaller

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

+ type AdminCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *AdminCaller

+ func (_Admin *AdminCallerSession) ISSCRIPT() (bool, error)

+ type AdminFilterer struct

+ func NewAdminFilterer(address common.Address, filterer bind.ContractFilterer) (*AdminFilterer, error)

+ type AdminRaw struct

+ Contract *Admin

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

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

+ func (_Admin *AdminRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AdminSession struct

+ CallOpts bind.CallOpts

+ Contract *Admin

+ TransactOpts bind.TransactOpts

+ func (_Admin *AdminSession) ISSCRIPT() (bool, error)

+ func (_Admin *AdminSession) PauseBridge(admin common.Address, bridge common.Address, action [32]byte) (*types.Transaction, error)

+ func (_Admin *AdminSession) PausePortal(admin common.Address, portal common.Address) (*types.Transaction, error)

+ func (_Admin *AdminSession) PauseXCall(admin common.Address, portal common.Address) (*types.Transaction, error)

+ func (_Admin *AdminSession) PauseXCallTo(admin common.Address, portal common.Address, to uint64) (*types.Transaction, error)

+ func (_Admin *AdminSession) PauseXSubmit(admin common.Address, portal common.Address) (*types.Transaction, error)

+ func (_Admin *AdminSession) PauseXSubmitFrom(admin common.Address, portal common.Address, from uint64) (*types.Transaction, error)

+ func (_Admin *AdminSession) UnpauseBridge(admin common.Address, bridge common.Address, action [32]byte) (*types.Transaction, error)

+ func (_Admin *AdminSession) UnpausePortal(admin common.Address, portal common.Address) (*types.Transaction, error)

+ func (_Admin *AdminSession) UnpauseXCall(admin common.Address, portal common.Address) (*types.Transaction, error)

+ func (_Admin *AdminSession) UnpauseXCallTo(admin common.Address, portal common.Address, to uint64) (*types.Transaction, error)

+ func (_Admin *AdminSession) UnpauseXSubmit(admin common.Address, portal common.Address) (*types.Transaction, error)

+ func (_Admin *AdminSession) UnpauseXSubmitFrom(admin common.Address, portal common.Address, from uint64) (*types.Transaction, error)

+ func (_Admin *AdminSession) UpgradeBridgeL1(admin common.Address, deployer common.Address, proxy common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminSession) UpgradeBridgeNative(admin common.Address, deployer common.Address, data []byte) (*types.Transaction, error)

+ func (_Admin *AdminSession) UpgradeFeeOracleV1(admin common.Address, deployer common.Address, proxy common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminSession) UpgradeGasPump(admin common.Address, deployer common.Address, proxy common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminSession) UpgradeGasStation(admin common.Address, deployer common.Address, proxy common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminSession) UpgradePortal(admin common.Address, deployer common.Address, portal common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminSession) UpgradePortalRegistry(admin common.Address, deployer common.Address, data []byte) (*types.Transaction, error)

+ func (_Admin *AdminSession) UpgradeSlashing(admin common.Address, deployer common.Address, data []byte) (*types.Transaction, error)

+ func (_Admin *AdminSession) UpgradeStaking(admin common.Address, deployer common.Address, data []byte) (*types.Transaction, error)

+ type AdminTransactor struct

+ func NewAdminTransactor(address common.Address, transactor bind.ContractTransactor) (*AdminTransactor, error)

+ func (_Admin *AdminTransactor) PauseBridge(opts *bind.TransactOpts, admin common.Address, bridge common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminTransactor) PausePortal(opts *bind.TransactOpts, admin common.Address, portal common.Address) (*types.Transaction, error)

+ func (_Admin *AdminTransactor) PauseXCall(opts *bind.TransactOpts, admin common.Address, portal common.Address) (*types.Transaction, error)

+ func (_Admin *AdminTransactor) PauseXCallTo(opts *bind.TransactOpts, admin common.Address, portal common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminTransactor) PauseXSubmit(opts *bind.TransactOpts, admin common.Address, portal common.Address) (*types.Transaction, error)

+ func (_Admin *AdminTransactor) PauseXSubmitFrom(opts *bind.TransactOpts, admin common.Address, portal common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminTransactor) UnpauseBridge(opts *bind.TransactOpts, admin common.Address, bridge common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminTransactor) UnpausePortal(opts *bind.TransactOpts, admin common.Address, portal common.Address) (*types.Transaction, error)

+ func (_Admin *AdminTransactor) UnpauseXCall(opts *bind.TransactOpts, admin common.Address, portal common.Address) (*types.Transaction, error)

+ func (_Admin *AdminTransactor) UnpauseXCallTo(opts *bind.TransactOpts, admin common.Address, portal common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminTransactor) UnpauseXSubmit(opts *bind.TransactOpts, admin common.Address, portal common.Address) (*types.Transaction, error)

+ func (_Admin *AdminTransactor) UnpauseXSubmitFrom(opts *bind.TransactOpts, admin common.Address, portal common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminTransactor) UpgradeBridgeL1(opts *bind.TransactOpts, admin common.Address, deployer common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminTransactor) UpgradeBridgeNative(opts *bind.TransactOpts, admin common.Address, deployer common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminTransactor) UpgradeFeeOracleV1(opts *bind.TransactOpts, admin common.Address, deployer common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminTransactor) UpgradeGasPump(opts *bind.TransactOpts, admin common.Address, deployer common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminTransactor) UpgradeGasStation(opts *bind.TransactOpts, admin common.Address, deployer common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminTransactor) UpgradePortal(opts *bind.TransactOpts, admin common.Address, deployer common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminTransactor) UpgradePortalRegistry(opts *bind.TransactOpts, admin common.Address, deployer common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminTransactor) UpgradeSlashing(opts *bind.TransactOpts, admin common.Address, deployer common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminTransactor) UpgradeStaking(opts *bind.TransactOpts, admin common.Address, deployer common.Address, ...) (*types.Transaction, error)

+ type AdminTransactorRaw struct

+ Contract *AdminTransactor

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

+ func (_Admin *AdminTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AdminTransactorSession struct

+ Contract *AdminTransactor

+ TransactOpts bind.TransactOpts

+ func (_Admin *AdminTransactorSession) PauseBridge(admin common.Address, bridge common.Address, action [32]byte) (*types.Transaction, error)

+ func (_Admin *AdminTransactorSession) PausePortal(admin common.Address, portal common.Address) (*types.Transaction, error)

+ func (_Admin *AdminTransactorSession) PauseXCall(admin common.Address, portal common.Address) (*types.Transaction, error)

+ func (_Admin *AdminTransactorSession) PauseXCallTo(admin common.Address, portal common.Address, to uint64) (*types.Transaction, error)

+ func (_Admin *AdminTransactorSession) PauseXSubmit(admin common.Address, portal common.Address) (*types.Transaction, error)

+ func (_Admin *AdminTransactorSession) PauseXSubmitFrom(admin common.Address, portal common.Address, from uint64) (*types.Transaction, error)

+ func (_Admin *AdminTransactorSession) UnpauseBridge(admin common.Address, bridge common.Address, action [32]byte) (*types.Transaction, error)

+ func (_Admin *AdminTransactorSession) UnpausePortal(admin common.Address, portal common.Address) (*types.Transaction, error)

+ func (_Admin *AdminTransactorSession) UnpauseXCall(admin common.Address, portal common.Address) (*types.Transaction, error)

+ func (_Admin *AdminTransactorSession) UnpauseXCallTo(admin common.Address, portal common.Address, to uint64) (*types.Transaction, error)

+ func (_Admin *AdminTransactorSession) UnpauseXSubmit(admin common.Address, portal common.Address) (*types.Transaction, error)

+ func (_Admin *AdminTransactorSession) UnpauseXSubmitFrom(admin common.Address, portal common.Address, from uint64) (*types.Transaction, error)

+ func (_Admin *AdminTransactorSession) UpgradeBridgeL1(admin common.Address, deployer common.Address, proxy common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminTransactorSession) UpgradeBridgeNative(admin common.Address, deployer common.Address, data []byte) (*types.Transaction, error)

+ func (_Admin *AdminTransactorSession) UpgradeFeeOracleV1(admin common.Address, deployer common.Address, proxy common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminTransactorSession) UpgradeGasPump(admin common.Address, deployer common.Address, proxy common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminTransactorSession) UpgradeGasStation(admin common.Address, deployer common.Address, proxy common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminTransactorSession) UpgradePortal(admin common.Address, deployer common.Address, portal common.Address, ...) (*types.Transaction, error)

+ func (_Admin *AdminTransactorSession) UpgradePortalRegistry(admin common.Address, deployer common.Address, data []byte) (*types.Transaction, error)

+ func (_Admin *AdminTransactorSession) UpgradeSlashing(admin common.Address, deployer common.Address, data []byte) (*types.Transaction, error)

+ func (_Admin *AdminTransactorSession) UpgradeStaking(admin common.Address, deployer common.Address, data []byte) (*types.Transaction, error)

+ type AllocPredeploys struct

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

+ func NewAllocPredeploys(address common.Address, backend bind.ContractBackend) (*AllocPredeploys, error)

+ type AllocPredeploysCaller struct

+ func NewAllocPredeploysCaller(address common.Address, caller bind.ContractCaller) (*AllocPredeploysCaller, error)

+ func (_AllocPredeploys *AllocPredeploysCaller) ISSCRIPT(opts *bind.CallOpts) (bool, error)

+ type AllocPredeploysCallerRaw struct

+ Contract *AllocPredeploysCaller

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

+ type AllocPredeploysCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *AllocPredeploysCaller

+ func (_AllocPredeploys *AllocPredeploysCallerSession) ISSCRIPT() (bool, error)

+ type AllocPredeploysConfig struct

+ Admin common.Address

+ ChainId *big.Int

+ EnableStakingAllowlist bool

+ Output string

+ type AllocPredeploysFilterer struct

+ func NewAllocPredeploysFilterer(address common.Address, filterer bind.ContractFilterer) (*AllocPredeploysFilterer, error)

+ type AllocPredeploysRaw struct

+ Contract *AllocPredeploys

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

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

+ func (_AllocPredeploys *AllocPredeploysRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AllocPredeploysSession struct

+ CallOpts bind.CallOpts

+ Contract *AllocPredeploys

+ TransactOpts bind.TransactOpts

+ func (_AllocPredeploys *AllocPredeploysSession) ISSCRIPT() (bool, error)

+ func (_AllocPredeploys *AllocPredeploysSession) Run(config AllocPredeploysConfig) (*types.Transaction, error)

+ func (_AllocPredeploys *AllocPredeploysSession) RunNoStateDump(config AllocPredeploysConfig) (*types.Transaction, error)

+ type AllocPredeploysTransactor struct

+ func NewAllocPredeploysTransactor(address common.Address, transactor bind.ContractTransactor) (*AllocPredeploysTransactor, error)

+ func (_AllocPredeploys *AllocPredeploysTransactor) Run(opts *bind.TransactOpts, config AllocPredeploysConfig) (*types.Transaction, error)

+ func (_AllocPredeploys *AllocPredeploysTransactor) RunNoStateDump(opts *bind.TransactOpts, config AllocPredeploysConfig) (*types.Transaction, error)

+ type AllocPredeploysTransactorRaw struct

+ Contract *AllocPredeploysTransactor

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

+ func (_AllocPredeploys *AllocPredeploysTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AllocPredeploysTransactorSession struct

+ Contract *AllocPredeploysTransactor

+ TransactOpts bind.TransactOpts

+ func (_AllocPredeploys *AllocPredeploysTransactorSession) Run(config AllocPredeploysConfig) (*types.Transaction, error)

+ func (_AllocPredeploys *AllocPredeploysTransactorSession) RunNoStateDump(config AllocPredeploysConfig) (*types.Transaction, error)

+ type Create3 struct

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

+ func NewCreate3(address common.Address, backend bind.ContractBackend) (*Create3, error)

+ type Create3Caller struct

+ func NewCreate3Caller(address common.Address, caller bind.ContractCaller) (*Create3Caller, error)

+ func (_Create3 *Create3Caller) GetDeployed(opts *bind.CallOpts, deployer common.Address, salt [32]byte) (common.Address, error)

+ type Create3CallerRaw struct

+ Contract *Create3Caller

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

+ type Create3CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *Create3Caller

+ func (_Create3 *Create3CallerSession) GetDeployed(deployer common.Address, salt [32]byte) (common.Address, error)

+ type Create3Filterer struct

+ func NewCreate3Filterer(address common.Address, filterer bind.ContractFilterer) (*Create3Filterer, error)

+ type Create3Raw struct

+ Contract *Create3

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

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

+ func (_Create3 *Create3Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type Create3Session struct

+ CallOpts bind.CallOpts

+ Contract *Create3

+ TransactOpts bind.TransactOpts

+ func (_Create3 *Create3Session) Deploy(salt [32]byte, creationCode []byte) (*types.Transaction, error)

+ func (_Create3 *Create3Session) GetDeployed(deployer common.Address, salt [32]byte) (common.Address, error)

+ type Create3Transactor struct

+ func NewCreate3Transactor(address common.Address, transactor bind.ContractTransactor) (*Create3Transactor, error)

+ func (_Create3 *Create3Transactor) Deploy(opts *bind.TransactOpts, salt [32]byte, creationCode []byte) (*types.Transaction, error)

+ type Create3TransactorRaw struct

+ Contract *Create3Transactor

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

+ func (_Create3 *Create3TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type Create3TransactorSession struct

+ Contract *Create3Transactor

+ TransactOpts bind.TransactOpts

+ func (_Create3 *Create3TransactorSession) Deploy(salt [32]byte, creationCode []byte) (*types.Transaction, error)

+ type DelegationManager struct

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

+ func NewDelegationManager(address common.Address, backend bind.ContractBackend) (*DelegationManager, error)

+ type DelegationManagerCaller struct

+ func NewDelegationManagerCaller(address common.Address, caller bind.ContractCaller) (*DelegationManagerCaller, error)

+ func (_DelegationManager *DelegationManagerCaller) BeaconChainETHStrategy(opts *bind.CallOpts) (common.Address, error)

+ func (_DelegationManager *DelegationManagerCaller) CalculateCurrentStakerDelegationDigestHash(opts *bind.CallOpts, staker common.Address, operator common.Address, ...) ([32]byte, error)

+ func (_DelegationManager *DelegationManagerCaller) CalculateDelegationApprovalDigestHash(opts *bind.CallOpts, staker common.Address, operator common.Address, ...) ([32]byte, error)

+ func (_DelegationManager *DelegationManagerCaller) CalculateStakerDelegationDigestHash(opts *bind.CallOpts, staker common.Address, _stakerNonce *big.Int, ...) ([32]byte, error)

+ func (_DelegationManager *DelegationManagerCaller) CalculateWithdrawalRoot(opts *bind.CallOpts, withdrawal IDelegationManagerWithdrawal) ([32]byte, error)

+ func (_DelegationManager *DelegationManagerCaller) CumulativeWithdrawalsQueued(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_DelegationManager *DelegationManagerCaller) DELEGATIONAPPROVALTYPEHASH(opts *bind.CallOpts) ([32]byte, error)

+ func (_DelegationManager *DelegationManagerCaller) DOMAINTYPEHASH(opts *bind.CallOpts) ([32]byte, error)

+ func (_DelegationManager *DelegationManagerCaller) DelegatedTo(opts *bind.CallOpts, arg0 common.Address) (common.Address, error)

+ func (_DelegationManager *DelegationManagerCaller) DelegationApprover(opts *bind.CallOpts, operator common.Address) (common.Address, error)

+ func (_DelegationManager *DelegationManagerCaller) DelegationApproverSaltIsSpent(opts *bind.CallOpts, arg0 common.Address, arg1 [32]byte) (bool, error)

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

+ func (_DelegationManager *DelegationManagerCaller) EarningsReceiver(opts *bind.CallOpts, operator common.Address) (common.Address, error)

+ func (_DelegationManager *DelegationManagerCaller) EigenPodManager(opts *bind.CallOpts) (common.Address, error)

+ func (_DelegationManager *DelegationManagerCaller) GetDelegatableShares(opts *bind.CallOpts, staker common.Address) ([]common.Address, []*big.Int, error)

+ func (_DelegationManager *DelegationManagerCaller) GetOperatorShares(opts *bind.CallOpts, operator common.Address, strategies []common.Address) ([]*big.Int, error)

+ func (_DelegationManager *DelegationManagerCaller) GetWithdrawalDelay(opts *bind.CallOpts, strategies []common.Address) (*big.Int, error)

+ func (_DelegationManager *DelegationManagerCaller) IsDelegated(opts *bind.CallOpts, staker common.Address) (bool, error)

+ func (_DelegationManager *DelegationManagerCaller) IsOperator(opts *bind.CallOpts, operator common.Address) (bool, error)

+ func (_DelegationManager *DelegationManagerCaller) MAXSTAKEROPTOUTWINDOWBLOCKS(opts *bind.CallOpts) (*big.Int, error)

+ func (_DelegationManager *DelegationManagerCaller) MAXWITHDRAWALDELAYBLOCKS(opts *bind.CallOpts) (*big.Int, error)

+ func (_DelegationManager *DelegationManagerCaller) MinWithdrawalDelayBlocks(opts *bind.CallOpts) (*big.Int, error)

+ func (_DelegationManager *DelegationManagerCaller) OperatorDetails(opts *bind.CallOpts, operator common.Address) (IDelegationManagerOperatorDetails, error)

+ func (_DelegationManager *DelegationManagerCaller) OperatorShares(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_DelegationManager *DelegationManagerCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_DelegationManager *DelegationManagerCaller) Paused(opts *bind.CallOpts, index uint8) (bool, error)

+ func (_DelegationManager *DelegationManagerCaller) Paused0(opts *bind.CallOpts) (*big.Int, error)

+ func (_DelegationManager *DelegationManagerCaller) PauserRegistry(opts *bind.CallOpts) (common.Address, error)

+ func (_DelegationManager *DelegationManagerCaller) PendingWithdrawals(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ func (_DelegationManager *DelegationManagerCaller) STAKERDELEGATIONTYPEHASH(opts *bind.CallOpts) ([32]byte, error)

+ func (_DelegationManager *DelegationManagerCaller) Slasher(opts *bind.CallOpts) (common.Address, error)

+ func (_DelegationManager *DelegationManagerCaller) StakerNonce(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_DelegationManager *DelegationManagerCaller) StakerOptOutWindowBlocks(opts *bind.CallOpts, operator common.Address) (*big.Int, error)

+ func (_DelegationManager *DelegationManagerCaller) StrategyManager(opts *bind.CallOpts) (common.Address, error)

+ func (_DelegationManager *DelegationManagerCaller) StrategyWithdrawalDelayBlocks(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ type DelegationManagerCallerRaw struct

+ Contract *DelegationManagerCaller

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

+ type DelegationManagerCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *DelegationManagerCaller

+ func (_DelegationManager *DelegationManagerCallerSession) BeaconChainETHStrategy() (common.Address, error)

+ func (_DelegationManager *DelegationManagerCallerSession) CalculateCurrentStakerDelegationDigestHash(staker common.Address, operator common.Address, expiry *big.Int) ([32]byte, error)

+ func (_DelegationManager *DelegationManagerCallerSession) CalculateDelegationApprovalDigestHash(staker common.Address, operator common.Address, ...) ([32]byte, error)

+ func (_DelegationManager *DelegationManagerCallerSession) CalculateStakerDelegationDigestHash(staker common.Address, _stakerNonce *big.Int, operator common.Address, ...) ([32]byte, error)

+ func (_DelegationManager *DelegationManagerCallerSession) CalculateWithdrawalRoot(withdrawal IDelegationManagerWithdrawal) ([32]byte, error)

+ func (_DelegationManager *DelegationManagerCallerSession) CumulativeWithdrawalsQueued(arg0 common.Address) (*big.Int, error)

+ func (_DelegationManager *DelegationManagerCallerSession) DELEGATIONAPPROVALTYPEHASH() ([32]byte, error)

+ func (_DelegationManager *DelegationManagerCallerSession) DOMAINTYPEHASH() ([32]byte, error)

+ func (_DelegationManager *DelegationManagerCallerSession) DelegatedTo(arg0 common.Address) (common.Address, error)

+ func (_DelegationManager *DelegationManagerCallerSession) DelegationApprover(operator common.Address) (common.Address, error)

+ func (_DelegationManager *DelegationManagerCallerSession) DelegationApproverSaltIsSpent(arg0 common.Address, arg1 [32]byte) (bool, error)

+ func (_DelegationManager *DelegationManagerCallerSession) DomainSeparator() ([32]byte, error)

+ func (_DelegationManager *DelegationManagerCallerSession) EarningsReceiver(operator common.Address) (common.Address, error)

+ func (_DelegationManager *DelegationManagerCallerSession) EigenPodManager() (common.Address, error)

+ func (_DelegationManager *DelegationManagerCallerSession) GetDelegatableShares(staker common.Address) ([]common.Address, []*big.Int, error)

+ func (_DelegationManager *DelegationManagerCallerSession) GetOperatorShares(operator common.Address, strategies []common.Address) ([]*big.Int, error)

+ func (_DelegationManager *DelegationManagerCallerSession) GetWithdrawalDelay(strategies []common.Address) (*big.Int, error)

+ func (_DelegationManager *DelegationManagerCallerSession) IsDelegated(staker common.Address) (bool, error)

+ func (_DelegationManager *DelegationManagerCallerSession) IsOperator(operator common.Address) (bool, error)

+ func (_DelegationManager *DelegationManagerCallerSession) MAXSTAKEROPTOUTWINDOWBLOCKS() (*big.Int, error)

+ func (_DelegationManager *DelegationManagerCallerSession) MAXWITHDRAWALDELAYBLOCKS() (*big.Int, error)

+ func (_DelegationManager *DelegationManagerCallerSession) MinWithdrawalDelayBlocks() (*big.Int, error)

+ func (_DelegationManager *DelegationManagerCallerSession) OperatorDetails(operator common.Address) (IDelegationManagerOperatorDetails, error)

+ func (_DelegationManager *DelegationManagerCallerSession) OperatorShares(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_DelegationManager *DelegationManagerCallerSession) Owner() (common.Address, error)

+ func (_DelegationManager *DelegationManagerCallerSession) Paused(index uint8) (bool, error)

+ func (_DelegationManager *DelegationManagerCallerSession) Paused0() (*big.Int, error)

+ func (_DelegationManager *DelegationManagerCallerSession) PauserRegistry() (common.Address, error)

+ func (_DelegationManager *DelegationManagerCallerSession) PendingWithdrawals(arg0 [32]byte) (bool, error)

+ func (_DelegationManager *DelegationManagerCallerSession) STAKERDELEGATIONTYPEHASH() ([32]byte, error)

+ func (_DelegationManager *DelegationManagerCallerSession) Slasher() (common.Address, error)

+ func (_DelegationManager *DelegationManagerCallerSession) StakerNonce(arg0 common.Address) (*big.Int, error)

+ func (_DelegationManager *DelegationManagerCallerSession) StakerOptOutWindowBlocks(operator common.Address) (*big.Int, error)

+ func (_DelegationManager *DelegationManagerCallerSession) StrategyManager() (common.Address, error)

+ func (_DelegationManager *DelegationManagerCallerSession) StrategyWithdrawalDelayBlocks(arg0 common.Address) (*big.Int, error)

+ type DelegationManagerFilterer struct

+ func NewDelegationManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*DelegationManagerFilterer, error)

+ func (_DelegationManager *DelegationManagerFilterer) FilterInitialized(opts *bind.FilterOpts) (*DelegationManagerInitializedIterator, error)

+ func (_DelegationManager *DelegationManagerFilterer) FilterMinWithdrawalDelayBlocksSet(opts *bind.FilterOpts) (*DelegationManagerMinWithdrawalDelayBlocksSetIterator, error)

+ func (_DelegationManager *DelegationManagerFilterer) FilterOperatorDetailsModified(opts *bind.FilterOpts, operator []common.Address) (*DelegationManagerOperatorDetailsModifiedIterator, error)

+ func (_DelegationManager *DelegationManagerFilterer) FilterOperatorMetadataURIUpdated(opts *bind.FilterOpts, operator []common.Address) (*DelegationManagerOperatorMetadataURIUpdatedIterator, error)

+ func (_DelegationManager *DelegationManagerFilterer) FilterOperatorRegistered(opts *bind.FilterOpts, operator []common.Address) (*DelegationManagerOperatorRegisteredIterator, error)

+ func (_DelegationManager *DelegationManagerFilterer) FilterOperatorSharesDecreased(opts *bind.FilterOpts, operator []common.Address) (*DelegationManagerOperatorSharesDecreasedIterator, error)

+ func (_DelegationManager *DelegationManagerFilterer) FilterOperatorSharesIncreased(opts *bind.FilterOpts, operator []common.Address) (*DelegationManagerOperatorSharesIncreasedIterator, error)

+ func (_DelegationManager *DelegationManagerFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*DelegationManagerOwnershipTransferredIterator, error)

+ func (_DelegationManager *DelegationManagerFilterer) FilterPaused(opts *bind.FilterOpts, account []common.Address) (*DelegationManagerPausedIterator, error)

+ func (_DelegationManager *DelegationManagerFilterer) FilterPauserRegistrySet(opts *bind.FilterOpts) (*DelegationManagerPauserRegistrySetIterator, error)

+ func (_DelegationManager *DelegationManagerFilterer) FilterStakerDelegated(opts *bind.FilterOpts, staker []common.Address, operator []common.Address) (*DelegationManagerStakerDelegatedIterator, error)

+ func (_DelegationManager *DelegationManagerFilterer) FilterStakerForceUndelegated(opts *bind.FilterOpts, staker []common.Address, operator []common.Address) (*DelegationManagerStakerForceUndelegatedIterator, error)

+ func (_DelegationManager *DelegationManagerFilterer) FilterStakerUndelegated(opts *bind.FilterOpts, staker []common.Address, operator []common.Address) (*DelegationManagerStakerUndelegatedIterator, error)

+ func (_DelegationManager *DelegationManagerFilterer) FilterStrategyWithdrawalDelayBlocksSet(opts *bind.FilterOpts) (*DelegationManagerStrategyWithdrawalDelayBlocksSetIterator, error)

+ func (_DelegationManager *DelegationManagerFilterer) FilterUnpaused(opts *bind.FilterOpts, account []common.Address) (*DelegationManagerUnpausedIterator, error)

+ func (_DelegationManager *DelegationManagerFilterer) FilterWithdrawalCompleted(opts *bind.FilterOpts) (*DelegationManagerWithdrawalCompletedIterator, error)

+ func (_DelegationManager *DelegationManagerFilterer) FilterWithdrawalMigrated(opts *bind.FilterOpts) (*DelegationManagerWithdrawalMigratedIterator, error)

+ func (_DelegationManager *DelegationManagerFilterer) FilterWithdrawalQueued(opts *bind.FilterOpts) (*DelegationManagerWithdrawalQueuedIterator, error)

+ func (_DelegationManager *DelegationManagerFilterer) ParseInitialized(log types.Log) (*DelegationManagerInitialized, error)

+ func (_DelegationManager *DelegationManagerFilterer) ParseMinWithdrawalDelayBlocksSet(log types.Log) (*DelegationManagerMinWithdrawalDelayBlocksSet, error)

+ func (_DelegationManager *DelegationManagerFilterer) ParseOperatorDetailsModified(log types.Log) (*DelegationManagerOperatorDetailsModified, error)

+ func (_DelegationManager *DelegationManagerFilterer) ParseOperatorMetadataURIUpdated(log types.Log) (*DelegationManagerOperatorMetadataURIUpdated, error)

+ func (_DelegationManager *DelegationManagerFilterer) ParseOperatorRegistered(log types.Log) (*DelegationManagerOperatorRegistered, error)

+ func (_DelegationManager *DelegationManagerFilterer) ParseOperatorSharesDecreased(log types.Log) (*DelegationManagerOperatorSharesDecreased, error)

+ func (_DelegationManager *DelegationManagerFilterer) ParseOperatorSharesIncreased(log types.Log) (*DelegationManagerOperatorSharesIncreased, error)

+ func (_DelegationManager *DelegationManagerFilterer) ParseOwnershipTransferred(log types.Log) (*DelegationManagerOwnershipTransferred, error)

+ func (_DelegationManager *DelegationManagerFilterer) ParsePaused(log types.Log) (*DelegationManagerPaused, error)

+ func (_DelegationManager *DelegationManagerFilterer) ParsePauserRegistrySet(log types.Log) (*DelegationManagerPauserRegistrySet, error)

+ func (_DelegationManager *DelegationManagerFilterer) ParseStakerDelegated(log types.Log) (*DelegationManagerStakerDelegated, error)

+ func (_DelegationManager *DelegationManagerFilterer) ParseStakerForceUndelegated(log types.Log) (*DelegationManagerStakerForceUndelegated, error)

+ func (_DelegationManager *DelegationManagerFilterer) ParseStakerUndelegated(log types.Log) (*DelegationManagerStakerUndelegated, error)

+ func (_DelegationManager *DelegationManagerFilterer) ParseStrategyWithdrawalDelayBlocksSet(log types.Log) (*DelegationManagerStrategyWithdrawalDelayBlocksSet, error)

+ func (_DelegationManager *DelegationManagerFilterer) ParseUnpaused(log types.Log) (*DelegationManagerUnpaused, error)

+ func (_DelegationManager *DelegationManagerFilterer) ParseWithdrawalCompleted(log types.Log) (*DelegationManagerWithdrawalCompleted, error)

+ func (_DelegationManager *DelegationManagerFilterer) ParseWithdrawalMigrated(log types.Log) (*DelegationManagerWithdrawalMigrated, error)

+ func (_DelegationManager *DelegationManagerFilterer) ParseWithdrawalQueued(log types.Log) (*DelegationManagerWithdrawalQueued, error)

+ func (_DelegationManager *DelegationManagerFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *DelegationManagerInitialized) (event.Subscription, error)

+ func (_DelegationManager *DelegationManagerFilterer) WatchMinWithdrawalDelayBlocksSet(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ func (_DelegationManager *DelegationManagerFilterer) WatchOperatorDetailsModified(opts *bind.WatchOpts, sink chan<- *DelegationManagerOperatorDetailsModified, ...) (event.Subscription, error)

+ func (_DelegationManager *DelegationManagerFilterer) WatchOperatorMetadataURIUpdated(opts *bind.WatchOpts, sink chan<- *DelegationManagerOperatorMetadataURIUpdated, ...) (event.Subscription, error)

+ func (_DelegationManager *DelegationManagerFilterer) WatchOperatorRegistered(opts *bind.WatchOpts, sink chan<- *DelegationManagerOperatorRegistered, ...) (event.Subscription, error)

+ func (_DelegationManager *DelegationManagerFilterer) WatchOperatorSharesDecreased(opts *bind.WatchOpts, sink chan<- *DelegationManagerOperatorSharesDecreased, ...) (event.Subscription, error)

+ func (_DelegationManager *DelegationManagerFilterer) WatchOperatorSharesIncreased(opts *bind.WatchOpts, sink chan<- *DelegationManagerOperatorSharesIncreased, ...) (event.Subscription, error)

+ func (_DelegationManager *DelegationManagerFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *DelegationManagerOwnershipTransferred, ...) (event.Subscription, error)

+ func (_DelegationManager *DelegationManagerFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *DelegationManagerPaused, ...) (event.Subscription, error)

+ func (_DelegationManager *DelegationManagerFilterer) WatchPauserRegistrySet(opts *bind.WatchOpts, sink chan<- *DelegationManagerPauserRegistrySet) (event.Subscription, error)

+ func (_DelegationManager *DelegationManagerFilterer) WatchStakerDelegated(opts *bind.WatchOpts, sink chan<- *DelegationManagerStakerDelegated, ...) (event.Subscription, error)

+ func (_DelegationManager *DelegationManagerFilterer) WatchStakerForceUndelegated(opts *bind.WatchOpts, sink chan<- *DelegationManagerStakerForceUndelegated, ...) (event.Subscription, error)

+ func (_DelegationManager *DelegationManagerFilterer) WatchStakerUndelegated(opts *bind.WatchOpts, sink chan<- *DelegationManagerStakerUndelegated, ...) (event.Subscription, error)

+ func (_DelegationManager *DelegationManagerFilterer) WatchStrategyWithdrawalDelayBlocksSet(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ func (_DelegationManager *DelegationManagerFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *DelegationManagerUnpaused, ...) (event.Subscription, error)

+ func (_DelegationManager *DelegationManagerFilterer) WatchWithdrawalCompleted(opts *bind.WatchOpts, sink chan<- *DelegationManagerWithdrawalCompleted) (event.Subscription, error)

+ func (_DelegationManager *DelegationManagerFilterer) WatchWithdrawalMigrated(opts *bind.WatchOpts, sink chan<- *DelegationManagerWithdrawalMigrated) (event.Subscription, error)

+ func (_DelegationManager *DelegationManagerFilterer) WatchWithdrawalQueued(opts *bind.WatchOpts, sink chan<- *DelegationManagerWithdrawalQueued) (event.Subscription, error)

+ type DelegationManagerInitialized struct

+ Raw types.Log

+ Version uint8

+ type DelegationManagerInitializedIterator struct

+ Event *DelegationManagerInitialized

+ func (it *DelegationManagerInitializedIterator) Close() error

+ func (it *DelegationManagerInitializedIterator) Error() error

+ func (it *DelegationManagerInitializedIterator) Next() bool

+ type DelegationManagerMinWithdrawalDelayBlocksSet struct

+ NewValue *big.Int

+ PreviousValue *big.Int

+ Raw types.Log

+ type DelegationManagerMinWithdrawalDelayBlocksSetIterator struct

+ Event *DelegationManagerMinWithdrawalDelayBlocksSet

+ func (it *DelegationManagerMinWithdrawalDelayBlocksSetIterator) Close() error

+ func (it *DelegationManagerMinWithdrawalDelayBlocksSetIterator) Error() error

+ func (it *DelegationManagerMinWithdrawalDelayBlocksSetIterator) Next() bool

+ type DelegationManagerOperatorDetailsModified struct

+ NewOperatorDetails IDelegationManagerOperatorDetails

+ Operator common.Address

+ Raw types.Log

+ type DelegationManagerOperatorDetailsModifiedIterator struct

+ Event *DelegationManagerOperatorDetailsModified

+ func (it *DelegationManagerOperatorDetailsModifiedIterator) Close() error

+ func (it *DelegationManagerOperatorDetailsModifiedIterator) Error() error

+ func (it *DelegationManagerOperatorDetailsModifiedIterator) Next() bool

+ type DelegationManagerOperatorMetadataURIUpdated struct

+ MetadataURI string

+ Operator common.Address

+ Raw types.Log

+ type DelegationManagerOperatorMetadataURIUpdatedIterator struct

+ Event *DelegationManagerOperatorMetadataURIUpdated

+ func (it *DelegationManagerOperatorMetadataURIUpdatedIterator) Close() error

+ func (it *DelegationManagerOperatorMetadataURIUpdatedIterator) Error() error

+ func (it *DelegationManagerOperatorMetadataURIUpdatedIterator) Next() bool

+ type DelegationManagerOperatorRegistered struct

+ Operator common.Address

+ OperatorDetails IDelegationManagerOperatorDetails

+ Raw types.Log

+ type DelegationManagerOperatorRegisteredIterator struct

+ Event *DelegationManagerOperatorRegistered

+ func (it *DelegationManagerOperatorRegisteredIterator) Close() error

+ func (it *DelegationManagerOperatorRegisteredIterator) Error() error

+ func (it *DelegationManagerOperatorRegisteredIterator) Next() bool

+ type DelegationManagerOperatorSharesDecreased struct

+ Operator common.Address

+ Raw types.Log

+ Shares *big.Int

+ Staker common.Address

+ Strategy common.Address

+ type DelegationManagerOperatorSharesDecreasedIterator struct

+ Event *DelegationManagerOperatorSharesDecreased

+ func (it *DelegationManagerOperatorSharesDecreasedIterator) Close() error

+ func (it *DelegationManagerOperatorSharesDecreasedIterator) Error() error

+ func (it *DelegationManagerOperatorSharesDecreasedIterator) Next() bool

+ type DelegationManagerOperatorSharesIncreased struct

+ Operator common.Address

+ Raw types.Log

+ Shares *big.Int

+ Staker common.Address

+ Strategy common.Address

+ type DelegationManagerOperatorSharesIncreasedIterator struct

+ Event *DelegationManagerOperatorSharesIncreased

+ func (it *DelegationManagerOperatorSharesIncreasedIterator) Close() error

+ func (it *DelegationManagerOperatorSharesIncreasedIterator) Error() error

+ func (it *DelegationManagerOperatorSharesIncreasedIterator) Next() bool

+ type DelegationManagerOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type DelegationManagerOwnershipTransferredIterator struct

+ Event *DelegationManagerOwnershipTransferred

+ func (it *DelegationManagerOwnershipTransferredIterator) Close() error

+ func (it *DelegationManagerOwnershipTransferredIterator) Error() error

+ func (it *DelegationManagerOwnershipTransferredIterator) Next() bool

+ type DelegationManagerPaused struct

+ Account common.Address

+ NewPausedStatus *big.Int

+ Raw types.Log

+ type DelegationManagerPausedIterator struct

+ Event *DelegationManagerPaused

+ func (it *DelegationManagerPausedIterator) Close() error

+ func (it *DelegationManagerPausedIterator) Error() error

+ func (it *DelegationManagerPausedIterator) Next() bool

+ type DelegationManagerPauserRegistrySet struct

+ NewPauserRegistry common.Address

+ PauserRegistry common.Address

+ Raw types.Log

+ type DelegationManagerPauserRegistrySetIterator struct

+ Event *DelegationManagerPauserRegistrySet

+ func (it *DelegationManagerPauserRegistrySetIterator) Close() error

+ func (it *DelegationManagerPauserRegistrySetIterator) Error() error

+ func (it *DelegationManagerPauserRegistrySetIterator) Next() bool

+ type DelegationManagerRaw struct

+ Contract *DelegationManager

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

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

+ func (_DelegationManager *DelegationManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DelegationManagerSession struct

+ CallOpts bind.CallOpts

+ Contract *DelegationManager

+ TransactOpts bind.TransactOpts

+ func (_DelegationManager *DelegationManagerSession) BeaconChainETHStrategy() (common.Address, error)

+ func (_DelegationManager *DelegationManagerSession) CalculateCurrentStakerDelegationDigestHash(staker common.Address, operator common.Address, expiry *big.Int) ([32]byte, error)

+ func (_DelegationManager *DelegationManagerSession) CalculateDelegationApprovalDigestHash(staker common.Address, operator common.Address, ...) ([32]byte, error)

+ func (_DelegationManager *DelegationManagerSession) CalculateStakerDelegationDigestHash(staker common.Address, _stakerNonce *big.Int, operator common.Address, ...) ([32]byte, error)

+ func (_DelegationManager *DelegationManagerSession) CalculateWithdrawalRoot(withdrawal IDelegationManagerWithdrawal) ([32]byte, error)

+ func (_DelegationManager *DelegationManagerSession) CompleteQueuedWithdrawal(withdrawal IDelegationManagerWithdrawal, tokens []common.Address, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerSession) CompleteQueuedWithdrawals(withdrawals []IDelegationManagerWithdrawal, tokens [][]common.Address, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerSession) CumulativeWithdrawalsQueued(arg0 common.Address) (*big.Int, error)

+ func (_DelegationManager *DelegationManagerSession) DELEGATIONAPPROVALTYPEHASH() ([32]byte, error)

+ func (_DelegationManager *DelegationManagerSession) DOMAINTYPEHASH() ([32]byte, error)

+ func (_DelegationManager *DelegationManagerSession) DecreaseDelegatedShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerSession) DelegateTo(operator common.Address, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerSession) DelegateToBySignature(staker common.Address, operator common.Address, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerSession) DelegatedTo(arg0 common.Address) (common.Address, error)

+ func (_DelegationManager *DelegationManagerSession) DelegationApprover(operator common.Address) (common.Address, error)

+ func (_DelegationManager *DelegationManagerSession) DelegationApproverSaltIsSpent(arg0 common.Address, arg1 [32]byte) (bool, error)

+ func (_DelegationManager *DelegationManagerSession) DomainSeparator() ([32]byte, error)

+ func (_DelegationManager *DelegationManagerSession) EarningsReceiver(operator common.Address) (common.Address, error)

+ func (_DelegationManager *DelegationManagerSession) EigenPodManager() (common.Address, error)

+ func (_DelegationManager *DelegationManagerSession) GetDelegatableShares(staker common.Address) ([]common.Address, []*big.Int, error)

+ func (_DelegationManager *DelegationManagerSession) GetOperatorShares(operator common.Address, strategies []common.Address) ([]*big.Int, error)

+ func (_DelegationManager *DelegationManagerSession) GetWithdrawalDelay(strategies []common.Address) (*big.Int, error)

+ func (_DelegationManager *DelegationManagerSession) IncreaseDelegatedShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerSession) Initialize(initialOwner common.Address, _pauserRegistry common.Address, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerSession) IsDelegated(staker common.Address) (bool, error)

+ func (_DelegationManager *DelegationManagerSession) IsOperator(operator common.Address) (bool, error)

+ func (_DelegationManager *DelegationManagerSession) MAXSTAKEROPTOUTWINDOWBLOCKS() (*big.Int, error)

+ func (_DelegationManager *DelegationManagerSession) MAXWITHDRAWALDELAYBLOCKS() (*big.Int, error)

+ func (_DelegationManager *DelegationManagerSession) MigrateQueuedWithdrawals(withdrawalsToMigrate []IStrategyManagerDeprecatedStructQueuedWithdrawal) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerSession) MinWithdrawalDelayBlocks() (*big.Int, error)

+ func (_DelegationManager *DelegationManagerSession) ModifyOperatorDetails(newOperatorDetails IDelegationManagerOperatorDetails) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerSession) OperatorDetails(operator common.Address) (IDelegationManagerOperatorDetails, error)

+ func (_DelegationManager *DelegationManagerSession) OperatorShares(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_DelegationManager *DelegationManagerSession) Owner() (common.Address, error)

+ func (_DelegationManager *DelegationManagerSession) Pause(newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerSession) PauseAll() (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerSession) Paused(index uint8) (bool, error)

+ func (_DelegationManager *DelegationManagerSession) Paused0() (*big.Int, error)

+ func (_DelegationManager *DelegationManagerSession) PauserRegistry() (common.Address, error)

+ func (_DelegationManager *DelegationManagerSession) PendingWithdrawals(arg0 [32]byte) (bool, error)

+ func (_DelegationManager *DelegationManagerSession) QueueWithdrawals(queuedWithdrawalParams []IDelegationManagerQueuedWithdrawalParams) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerSession) RegisterAsOperator(registeringOperatorDetails IDelegationManagerOperatorDetails, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerSession) RenounceOwnership() (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerSession) STAKERDELEGATIONTYPEHASH() ([32]byte, error)

+ func (_DelegationManager *DelegationManagerSession) SetMinWithdrawalDelayBlocks(newMinWithdrawalDelayBlocks *big.Int) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerSession) SetPauserRegistry(newPauserRegistry common.Address) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerSession) SetStrategyWithdrawalDelayBlocks(strategies []common.Address, withdrawalDelayBlocks []*big.Int) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerSession) Slasher() (common.Address, error)

+ func (_DelegationManager *DelegationManagerSession) StakerNonce(arg0 common.Address) (*big.Int, error)

+ func (_DelegationManager *DelegationManagerSession) StakerOptOutWindowBlocks(operator common.Address) (*big.Int, error)

+ func (_DelegationManager *DelegationManagerSession) StrategyManager() (common.Address, error)

+ func (_DelegationManager *DelegationManagerSession) StrategyWithdrawalDelayBlocks(arg0 common.Address) (*big.Int, error)

+ func (_DelegationManager *DelegationManagerSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerSession) Undelegate(staker common.Address) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerSession) Unpause(newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerSession) UpdateOperatorMetadataURI(metadataURI string) (*types.Transaction, error)

+ type DelegationManagerStakerDelegated struct

+ Operator common.Address

+ Raw types.Log

+ Staker common.Address

+ type DelegationManagerStakerDelegatedIterator struct

+ Event *DelegationManagerStakerDelegated

+ func (it *DelegationManagerStakerDelegatedIterator) Close() error

+ func (it *DelegationManagerStakerDelegatedIterator) Error() error

+ func (it *DelegationManagerStakerDelegatedIterator) Next() bool

+ type DelegationManagerStakerForceUndelegated struct

+ Operator common.Address

+ Raw types.Log

+ Staker common.Address

+ type DelegationManagerStakerForceUndelegatedIterator struct

+ Event *DelegationManagerStakerForceUndelegated

+ func (it *DelegationManagerStakerForceUndelegatedIterator) Close() error

+ func (it *DelegationManagerStakerForceUndelegatedIterator) Error() error

+ func (it *DelegationManagerStakerForceUndelegatedIterator) Next() bool

+ type DelegationManagerStakerUndelegated struct

+ Operator common.Address

+ Raw types.Log

+ Staker common.Address

+ type DelegationManagerStakerUndelegatedIterator struct

+ Event *DelegationManagerStakerUndelegated

+ func (it *DelegationManagerStakerUndelegatedIterator) Close() error

+ func (it *DelegationManagerStakerUndelegatedIterator) Error() error

+ func (it *DelegationManagerStakerUndelegatedIterator) Next() bool

+ type DelegationManagerStrategyWithdrawalDelayBlocksSet struct

+ NewValue *big.Int

+ PreviousValue *big.Int

+ Raw types.Log

+ Strategy common.Address

+ type DelegationManagerStrategyWithdrawalDelayBlocksSetIterator struct

+ Event *DelegationManagerStrategyWithdrawalDelayBlocksSet

+ func (it *DelegationManagerStrategyWithdrawalDelayBlocksSetIterator) Close() error

+ func (it *DelegationManagerStrategyWithdrawalDelayBlocksSetIterator) Error() error

+ func (it *DelegationManagerStrategyWithdrawalDelayBlocksSetIterator) Next() bool

+ type DelegationManagerTransactor struct

+ func NewDelegationManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*DelegationManagerTransactor, error)

+ func (_DelegationManager *DelegationManagerTransactor) CompleteQueuedWithdrawal(opts *bind.TransactOpts, withdrawal IDelegationManagerWithdrawal, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactor) CompleteQueuedWithdrawals(opts *bind.TransactOpts, withdrawals []IDelegationManagerWithdrawal, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactor) DecreaseDelegatedShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactor) DelegateTo(opts *bind.TransactOpts, operator common.Address, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactor) DelegateToBySignature(opts *bind.TransactOpts, staker common.Address, operator common.Address, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactor) IncreaseDelegatedShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactor) Initialize(opts *bind.TransactOpts, initialOwner common.Address, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactor) MigrateQueuedWithdrawals(opts *bind.TransactOpts, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactor) ModifyOperatorDetails(opts *bind.TransactOpts, newOperatorDetails IDelegationManagerOperatorDetails) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactor) Pause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactor) PauseAll(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactor) QueueWithdrawals(opts *bind.TransactOpts, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactor) RegisterAsOperator(opts *bind.TransactOpts, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactor) SetMinWithdrawalDelayBlocks(opts *bind.TransactOpts, newMinWithdrawalDelayBlocks *big.Int) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactor) SetPauserRegistry(opts *bind.TransactOpts, newPauserRegistry common.Address) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactor) SetStrategyWithdrawalDelayBlocks(opts *bind.TransactOpts, strategies []common.Address, ...) (*types.Transaction, error)

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

+ func (_DelegationManager *DelegationManagerTransactor) Undelegate(opts *bind.TransactOpts, staker common.Address) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactor) Unpause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactor) UpdateOperatorMetadataURI(opts *bind.TransactOpts, metadataURI string) (*types.Transaction, error)

+ type DelegationManagerTransactorRaw struct

+ Contract *DelegationManagerTransactor

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

+ func (_DelegationManager *DelegationManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DelegationManagerTransactorSession struct

+ Contract *DelegationManagerTransactor

+ TransactOpts bind.TransactOpts

+ func (_DelegationManager *DelegationManagerTransactorSession) CompleteQueuedWithdrawal(withdrawal IDelegationManagerWithdrawal, tokens []common.Address, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactorSession) CompleteQueuedWithdrawals(withdrawals []IDelegationManagerWithdrawal, tokens [][]common.Address, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactorSession) DecreaseDelegatedShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactorSession) DelegateTo(operator common.Address, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactorSession) DelegateToBySignature(staker common.Address, operator common.Address, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactorSession) IncreaseDelegatedShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactorSession) Initialize(initialOwner common.Address, _pauserRegistry common.Address, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactorSession) MigrateQueuedWithdrawals(withdrawalsToMigrate []IStrategyManagerDeprecatedStructQueuedWithdrawal) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactorSession) ModifyOperatorDetails(newOperatorDetails IDelegationManagerOperatorDetails) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactorSession) Pause(newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactorSession) PauseAll() (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactorSession) QueueWithdrawals(queuedWithdrawalParams []IDelegationManagerQueuedWithdrawalParams) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactorSession) RegisterAsOperator(registeringOperatorDetails IDelegationManagerOperatorDetails, ...) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactorSession) SetMinWithdrawalDelayBlocks(newMinWithdrawalDelayBlocks *big.Int) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactorSession) SetPauserRegistry(newPauserRegistry common.Address) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactorSession) SetStrategyWithdrawalDelayBlocks(strategies []common.Address, withdrawalDelayBlocks []*big.Int) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactorSession) Undelegate(staker common.Address) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactorSession) Unpause(newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_DelegationManager *DelegationManagerTransactorSession) UpdateOperatorMetadataURI(metadataURI string) (*types.Transaction, error)

+ type DelegationManagerUnpaused struct

+ Account common.Address

+ NewPausedStatus *big.Int

+ Raw types.Log

+ type DelegationManagerUnpausedIterator struct

+ Event *DelegationManagerUnpaused

+ func (it *DelegationManagerUnpausedIterator) Close() error

+ func (it *DelegationManagerUnpausedIterator) Error() error

+ func (it *DelegationManagerUnpausedIterator) Next() bool

+ type DelegationManagerWithdrawalCompleted struct

+ Raw types.Log

+ WithdrawalRoot [32]byte

+ type DelegationManagerWithdrawalCompletedIterator struct

+ Event *DelegationManagerWithdrawalCompleted

+ func (it *DelegationManagerWithdrawalCompletedIterator) Close() error

+ func (it *DelegationManagerWithdrawalCompletedIterator) Error() error

+ func (it *DelegationManagerWithdrawalCompletedIterator) Next() bool

+ type DelegationManagerWithdrawalMigrated struct

+ NewWithdrawalRoot [32]byte

+ OldWithdrawalRoot [32]byte

+ Raw types.Log

+ type DelegationManagerWithdrawalMigratedIterator struct

+ Event *DelegationManagerWithdrawalMigrated

+ func (it *DelegationManagerWithdrawalMigratedIterator) Close() error

+ func (it *DelegationManagerWithdrawalMigratedIterator) Error() error

+ func (it *DelegationManagerWithdrawalMigratedIterator) Next() bool

+ type DelegationManagerWithdrawalQueued struct

+ Raw types.Log

+ Withdrawal IDelegationManagerWithdrawal

+ WithdrawalRoot [32]byte

+ type DelegationManagerWithdrawalQueuedIterator struct

+ Event *DelegationManagerWithdrawalQueued

+ func (it *DelegationManagerWithdrawalQueuedIterator) Close() error

+ func (it *DelegationManagerWithdrawalQueuedIterator) Error() error

+ func (it *DelegationManagerWithdrawalQueuedIterator) Next() bool

+ type FeeOracleV1 struct

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

+ func NewFeeOracleV1(address common.Address, backend bind.ContractBackend) (*FeeOracleV1, error)

+ type FeeOracleV1BaseGasLimitSet struct

+ BaseGasLimit uint64

+ Raw types.Log

+ type FeeOracleV1BaseGasLimitSetIterator struct

+ Event *FeeOracleV1BaseGasLimitSet

+ func (it *FeeOracleV1BaseGasLimitSetIterator) Close() error

+ func (it *FeeOracleV1BaseGasLimitSetIterator) Error() error

+ func (it *FeeOracleV1BaseGasLimitSetIterator) Next() bool

+ type FeeOracleV1Caller struct

+ func NewFeeOracleV1Caller(address common.Address, caller bind.ContractCaller) (*FeeOracleV1Caller, error)

+ func (_FeeOracleV1 *FeeOracleV1Caller) BaseGasLimit(opts *bind.CallOpts) (uint64, error)

+ func (_FeeOracleV1 *FeeOracleV1Caller) CONVERSIONRATEDENOM(opts *bind.CallOpts) (*big.Int, error)

+ func (_FeeOracleV1 *FeeOracleV1Caller) FeeFor(opts *bind.CallOpts, destChainId uint64, data []byte, gasLimit uint64) (*big.Int, error)

+ func (_FeeOracleV1 *FeeOracleV1Caller) FeeParams(opts *bind.CallOpts, chainId uint64) (IFeeOracleV1ChainFeeParams, error)

+ func (_FeeOracleV1 *FeeOracleV1Caller) GasPriceOn(opts *bind.CallOpts, chainId uint64) (*big.Int, error)

+ func (_FeeOracleV1 *FeeOracleV1Caller) Manager(opts *bind.CallOpts) (common.Address, error)

+ func (_FeeOracleV1 *FeeOracleV1Caller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_FeeOracleV1 *FeeOracleV1Caller) PostsTo(opts *bind.CallOpts, chainId uint64) (uint64, error)

+ func (_FeeOracleV1 *FeeOracleV1Caller) ProtocolFee(opts *bind.CallOpts) (*big.Int, error)

+ func (_FeeOracleV1 *FeeOracleV1Caller) ToNativeRate(opts *bind.CallOpts, chainId uint64) (*big.Int, error)

+ func (_FeeOracleV1 *FeeOracleV1Caller) Version(opts *bind.CallOpts) (uint64, error)

+ type FeeOracleV1CallerRaw struct

+ Contract *FeeOracleV1Caller

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

+ type FeeOracleV1CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *FeeOracleV1Caller

+ func (_FeeOracleV1 *FeeOracleV1CallerSession) BaseGasLimit() (uint64, error)

+ func (_FeeOracleV1 *FeeOracleV1CallerSession) CONVERSIONRATEDENOM() (*big.Int, error)

+ func (_FeeOracleV1 *FeeOracleV1CallerSession) FeeFor(destChainId uint64, data []byte, gasLimit uint64) (*big.Int, error)

+ func (_FeeOracleV1 *FeeOracleV1CallerSession) FeeParams(chainId uint64) (IFeeOracleV1ChainFeeParams, error)

+ func (_FeeOracleV1 *FeeOracleV1CallerSession) GasPriceOn(chainId uint64) (*big.Int, error)

+ func (_FeeOracleV1 *FeeOracleV1CallerSession) Manager() (common.Address, error)

+ func (_FeeOracleV1 *FeeOracleV1CallerSession) Owner() (common.Address, error)

+ func (_FeeOracleV1 *FeeOracleV1CallerSession) PostsTo(chainId uint64) (uint64, error)

+ func (_FeeOracleV1 *FeeOracleV1CallerSession) ProtocolFee() (*big.Int, error)

+ func (_FeeOracleV1 *FeeOracleV1CallerSession) ToNativeRate(chainId uint64) (*big.Int, error)

+ func (_FeeOracleV1 *FeeOracleV1CallerSession) Version() (uint64, error)

+ type FeeOracleV1FeeParamsSet struct

+ ChainId uint64

+ GasPrice *big.Int

+ PostsTo uint64

+ Raw types.Log

+ ToNativeRate *big.Int

+ type FeeOracleV1FeeParamsSetIterator struct

+ Event *FeeOracleV1FeeParamsSet

+ func (it *FeeOracleV1FeeParamsSetIterator) Close() error

+ func (it *FeeOracleV1FeeParamsSetIterator) Error() error

+ func (it *FeeOracleV1FeeParamsSetIterator) Next() bool

+ type FeeOracleV1Filterer struct

+ func NewFeeOracleV1Filterer(address common.Address, filterer bind.ContractFilterer) (*FeeOracleV1Filterer, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) FilterBaseGasLimitSet(opts *bind.FilterOpts) (*FeeOracleV1BaseGasLimitSetIterator, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) FilterFeeParamsSet(opts *bind.FilterOpts) (*FeeOracleV1FeeParamsSetIterator, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) FilterGasPriceSet(opts *bind.FilterOpts) (*FeeOracleV1GasPriceSetIterator, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) FilterInitialized(opts *bind.FilterOpts) (*FeeOracleV1InitializedIterator, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) FilterManagerSet(opts *bind.FilterOpts) (*FeeOracleV1ManagerSetIterator, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*FeeOracleV1OwnershipTransferredIterator, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) FilterProtocolFeeSet(opts *bind.FilterOpts) (*FeeOracleV1ProtocolFeeSetIterator, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) FilterToNativeRateSet(opts *bind.FilterOpts) (*FeeOracleV1ToNativeRateSetIterator, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) ParseBaseGasLimitSet(log types.Log) (*FeeOracleV1BaseGasLimitSet, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) ParseFeeParamsSet(log types.Log) (*FeeOracleV1FeeParamsSet, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) ParseGasPriceSet(log types.Log) (*FeeOracleV1GasPriceSet, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) ParseInitialized(log types.Log) (*FeeOracleV1Initialized, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) ParseManagerSet(log types.Log) (*FeeOracleV1ManagerSet, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) ParseOwnershipTransferred(log types.Log) (*FeeOracleV1OwnershipTransferred, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) ParseProtocolFeeSet(log types.Log) (*FeeOracleV1ProtocolFeeSet, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) ParseToNativeRateSet(log types.Log) (*FeeOracleV1ToNativeRateSet, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) WatchBaseGasLimitSet(opts *bind.WatchOpts, sink chan<- *FeeOracleV1BaseGasLimitSet) (event.Subscription, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) WatchFeeParamsSet(opts *bind.WatchOpts, sink chan<- *FeeOracleV1FeeParamsSet) (event.Subscription, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) WatchGasPriceSet(opts *bind.WatchOpts, sink chan<- *FeeOracleV1GasPriceSet) (event.Subscription, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *FeeOracleV1Initialized) (event.Subscription, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) WatchManagerSet(opts *bind.WatchOpts, sink chan<- *FeeOracleV1ManagerSet) (event.Subscription, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *FeeOracleV1OwnershipTransferred, ...) (event.Subscription, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) WatchProtocolFeeSet(opts *bind.WatchOpts, sink chan<- *FeeOracleV1ProtocolFeeSet) (event.Subscription, error)

+ func (_FeeOracleV1 *FeeOracleV1Filterer) WatchToNativeRateSet(opts *bind.WatchOpts, sink chan<- *FeeOracleV1ToNativeRateSet) (event.Subscription, error)

+ type FeeOracleV1GasPriceSet struct

+ ChainId uint64

+ GasPrice *big.Int

+ Raw types.Log

+ type FeeOracleV1GasPriceSetIterator struct

+ Event *FeeOracleV1GasPriceSet

+ func (it *FeeOracleV1GasPriceSetIterator) Close() error

+ func (it *FeeOracleV1GasPriceSetIterator) Error() error

+ func (it *FeeOracleV1GasPriceSetIterator) Next() bool

+ type FeeOracleV1Initialized struct

+ Raw types.Log

+ Version uint64

+ type FeeOracleV1InitializedIterator struct

+ Event *FeeOracleV1Initialized

+ func (it *FeeOracleV1InitializedIterator) Close() error

+ func (it *FeeOracleV1InitializedIterator) Error() error

+ func (it *FeeOracleV1InitializedIterator) Next() bool

+ type FeeOracleV1ManagerSet struct

+ Manager common.Address

+ Raw types.Log

+ type FeeOracleV1ManagerSetIterator struct

+ Event *FeeOracleV1ManagerSet

+ func (it *FeeOracleV1ManagerSetIterator) Close() error

+ func (it *FeeOracleV1ManagerSetIterator) Error() error

+ func (it *FeeOracleV1ManagerSetIterator) Next() bool

+ type FeeOracleV1OwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type FeeOracleV1OwnershipTransferredIterator struct

+ Event *FeeOracleV1OwnershipTransferred

+ func (it *FeeOracleV1OwnershipTransferredIterator) Close() error

+ func (it *FeeOracleV1OwnershipTransferredIterator) Error() error

+ func (it *FeeOracleV1OwnershipTransferredIterator) Next() bool

+ type FeeOracleV1ProtocolFeeSet struct

+ ProtocolFee *big.Int

+ Raw types.Log

+ type FeeOracleV1ProtocolFeeSetIterator struct

+ Event *FeeOracleV1ProtocolFeeSet

+ func (it *FeeOracleV1ProtocolFeeSetIterator) Close() error

+ func (it *FeeOracleV1ProtocolFeeSetIterator) Error() error

+ func (it *FeeOracleV1ProtocolFeeSetIterator) Next() bool

+ type FeeOracleV1Raw struct

+ Contract *FeeOracleV1

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

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

+ func (_FeeOracleV1 *FeeOracleV1Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type FeeOracleV1Session struct

+ CallOpts bind.CallOpts

+ Contract *FeeOracleV1

+ TransactOpts bind.TransactOpts

+ func (_FeeOracleV1 *FeeOracleV1Session) BaseGasLimit() (uint64, error)

+ func (_FeeOracleV1 *FeeOracleV1Session) BulkSetFeeParams(params []IFeeOracleV1ChainFeeParams) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1Session) CONVERSIONRATEDENOM() (*big.Int, error)

+ func (_FeeOracleV1 *FeeOracleV1Session) FeeFor(destChainId uint64, data []byte, gasLimit uint64) (*big.Int, error)

+ func (_FeeOracleV1 *FeeOracleV1Session) FeeParams(chainId uint64) (IFeeOracleV1ChainFeeParams, error)

+ func (_FeeOracleV1 *FeeOracleV1Session) GasPriceOn(chainId uint64) (*big.Int, error)

+ func (_FeeOracleV1 *FeeOracleV1Session) Initialize(owner_ common.Address, manager_ common.Address, baseGasLimit_ uint64, ...) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1Session) Manager() (common.Address, error)

+ func (_FeeOracleV1 *FeeOracleV1Session) Owner() (common.Address, error)

+ func (_FeeOracleV1 *FeeOracleV1Session) PostsTo(chainId uint64) (uint64, error)

+ func (_FeeOracleV1 *FeeOracleV1Session) ProtocolFee() (*big.Int, error)

+ func (_FeeOracleV1 *FeeOracleV1Session) RenounceOwnership() (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1Session) SetBaseGasLimit(gasLimit uint64) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1Session) SetGasPrice(chainId uint64, gasPrice *big.Int) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1Session) SetManager(manager_ common.Address) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1Session) SetProtocolFee(fee *big.Int) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1Session) SetToNativeRate(chainId uint64, rate *big.Int) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1Session) ToNativeRate(chainId uint64) (*big.Int, error)

+ func (_FeeOracleV1 *FeeOracleV1Session) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1Session) Version() (uint64, error)

+ type FeeOracleV1ToNativeRateSet struct

+ ChainId uint64

+ Raw types.Log

+ ToNativeRate *big.Int

+ type FeeOracleV1ToNativeRateSetIterator struct

+ Event *FeeOracleV1ToNativeRateSet

+ func (it *FeeOracleV1ToNativeRateSetIterator) Close() error

+ func (it *FeeOracleV1ToNativeRateSetIterator) Error() error

+ func (it *FeeOracleV1ToNativeRateSetIterator) Next() bool

+ type FeeOracleV1Transactor struct

+ func NewFeeOracleV1Transactor(address common.Address, transactor bind.ContractTransactor) (*FeeOracleV1Transactor, error)

+ func (_FeeOracleV1 *FeeOracleV1Transactor) BulkSetFeeParams(opts *bind.TransactOpts, params []IFeeOracleV1ChainFeeParams) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1Transactor) Initialize(opts *bind.TransactOpts, owner_ common.Address, manager_ common.Address, ...) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1Transactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1Transactor) SetBaseGasLimit(opts *bind.TransactOpts, gasLimit uint64) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1Transactor) SetGasPrice(opts *bind.TransactOpts, chainId uint64, gasPrice *big.Int) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1Transactor) SetManager(opts *bind.TransactOpts, manager_ common.Address) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1Transactor) SetProtocolFee(opts *bind.TransactOpts, fee *big.Int) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1Transactor) SetToNativeRate(opts *bind.TransactOpts, chainId uint64, rate *big.Int) (*types.Transaction, error)

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

+ type FeeOracleV1TransactorRaw struct

+ Contract *FeeOracleV1Transactor

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

+ func (_FeeOracleV1 *FeeOracleV1TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type FeeOracleV1TransactorSession struct

+ Contract *FeeOracleV1Transactor

+ TransactOpts bind.TransactOpts

+ func (_FeeOracleV1 *FeeOracleV1TransactorSession) BulkSetFeeParams(params []IFeeOracleV1ChainFeeParams) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1TransactorSession) Initialize(owner_ common.Address, manager_ common.Address, baseGasLimit_ uint64, ...) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1TransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1TransactorSession) SetBaseGasLimit(gasLimit uint64) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1TransactorSession) SetGasPrice(chainId uint64, gasPrice *big.Int) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1TransactorSession) SetManager(manager_ common.Address) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1TransactorSession) SetProtocolFee(fee *big.Int) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1TransactorSession) SetToNativeRate(chainId uint64, rate *big.Int) (*types.Transaction, error)

+ func (_FeeOracleV1 *FeeOracleV1TransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type IDelegationManagerOperatorDetails struct

+ DelegationApprover common.Address

+ EarningsReceiver common.Address

+ StakerOptOutWindowBlocks uint32

+ type IDelegationManagerQueuedWithdrawalParams struct

+ Shares []*big.Int

+ Strategies []common.Address

+ Withdrawer common.Address

+ type IDelegationManagerWithdrawal struct

+ DelegatedTo common.Address

+ Nonce *big.Int

+ Shares []*big.Int

+ Staker common.Address

+ StartBlock uint32

+ Strategies []common.Address

+ Withdrawer common.Address

+ type IFeeOracleV1ChainFeeParams struct

+ ChainId uint64

+ GasPrice *big.Int

+ PostsTo uint64

+ ToNativeRate *big.Int

+ type IOmniAVSOperator struct

+ Addr common.Address

+ Delegated *big.Int

+ Pubkey []byte

+ Staked *big.Int

+ type IOmniAVSStrategyParam struct

+ Multiplier *big.Int

+ Strategy common.Address

+ type ISignatureUtilsSignatureWithExpiry struct

+ Expiry *big.Int

+ Signature []byte

+ type ISignatureUtilsSignatureWithSaltAndExpiry struct

+ Expiry *big.Int

+ Salt [32]byte

+ Signature []byte

+ type IStrategyManagerDeprecatedStructQueuedWithdrawal struct

+ DelegatedAddress common.Address

+ Shares []*big.Int

+ Staker common.Address

+ Strategies []common.Address

+ WithdrawalStartBlock uint32

+ WithdrawerAndNonce IStrategyManagerDeprecatedStructWithdrawerAndNonce

+ type IStrategyManagerDeprecatedStructWithdrawerAndNonce struct

+ Nonce *big.Int

+ Withdrawer common.Address

+ type MockERC20 struct

+ func DeployMockERC20(auth *bind.TransactOpts, backend bind.ContractBackend, name string, ...) (common.Address, *types.Transaction, *MockERC20, error)

+ func NewMockERC20(address common.Address, backend bind.ContractBackend) (*MockERC20, error)

+ type MockERC20Approval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type MockERC20ApprovalIterator struct

+ Event *MockERC20Approval

+ func (it *MockERC20ApprovalIterator) Close() error

+ func (it *MockERC20ApprovalIterator) Error() error

+ func (it *MockERC20ApprovalIterator) Next() bool

+ type MockERC20Caller struct

+ func NewMockERC20Caller(address common.Address, caller bind.ContractCaller) (*MockERC20Caller, error)

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

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

+ func (_MockERC20 *MockERC20Caller) Decimals(opts *bind.CallOpts) (uint8, error)

+ func (_MockERC20 *MockERC20Caller) Name(opts *bind.CallOpts) (string, error)

+ func (_MockERC20 *MockERC20Caller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_MockERC20 *MockERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type MockERC20CallerRaw struct

+ Contract *MockERC20Caller

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

+ type MockERC20CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *MockERC20Caller

+ func (_MockERC20 *MockERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_MockERC20 *MockERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_MockERC20 *MockERC20CallerSession) Decimals() (uint8, error)

+ func (_MockERC20 *MockERC20CallerSession) Name() (string, error)

+ func (_MockERC20 *MockERC20CallerSession) Symbol() (string, error)

+ func (_MockERC20 *MockERC20CallerSession) TotalSupply() (*big.Int, error)

+ type MockERC20Filterer struct

+ func NewMockERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*MockERC20Filterer, error)

+ func (_MockERC20 *MockERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*MockERC20ApprovalIterator, error)

+ func (_MockERC20 *MockERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*MockERC20TransferIterator, error)

+ func (_MockERC20 *MockERC20Filterer) ParseApproval(log types.Log) (*MockERC20Approval, error)

+ func (_MockERC20 *MockERC20Filterer) ParseTransfer(log types.Log) (*MockERC20Transfer, error)

+ func (_MockERC20 *MockERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *MockERC20Approval, owner []common.Address, ...) (event.Subscription, error)

+ func (_MockERC20 *MockERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *MockERC20Transfer, from []common.Address, ...) (event.Subscription, error)

+ type MockERC20Raw struct

+ Contract *MockERC20

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

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

+ func (_MockERC20 *MockERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MockERC20Session struct

+ CallOpts bind.CallOpts

+ Contract *MockERC20

+ TransactOpts bind.TransactOpts

+ func (_MockERC20 *MockERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

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

+ func (_MockERC20 *MockERC20Session) BalanceOf(account common.Address) (*big.Int, error)

+ func (_MockERC20 *MockERC20Session) Decimals() (uint8, error)

+ func (_MockERC20 *MockERC20Session) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_MockERC20 *MockERC20Session) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_MockERC20 *MockERC20Session) Mint(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_MockERC20 *MockERC20Session) Name() (string, error)

+ func (_MockERC20 *MockERC20Session) Symbol() (string, error)

+ func (_MockERC20 *MockERC20Session) TotalSupply() (*big.Int, error)

+ func (_MockERC20 *MockERC20Session) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_MockERC20 *MockERC20Session) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error)

+ type MockERC20Transactor struct

+ func NewMockERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*MockERC20Transactor, error)

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

+ func (_MockERC20 *MockERC20Transactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_MockERC20 *MockERC20Transactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_MockERC20 *MockERC20Transactor) Mint(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_MockERC20 *MockERC20Transactor) Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_MockERC20 *MockERC20Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ type MockERC20TransactorRaw struct

+ Contract *MockERC20Transactor

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

+ func (_MockERC20 *MockERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MockERC20TransactorSession struct

+ Contract *MockERC20Transactor

+ TransactOpts bind.TransactOpts

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

+ func (_MockERC20 *MockERC20TransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_MockERC20 *MockERC20TransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_MockERC20 *MockERC20TransactorSession) Mint(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_MockERC20 *MockERC20TransactorSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_MockERC20 *MockERC20TransactorSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error)

+ type MockERC20Transfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type MockERC20TransferIterator struct

+ Event *MockERC20Transfer

+ func (it *MockERC20TransferIterator) Close() error

+ func (it *MockERC20TransferIterator) Error() error

+ func (it *MockERC20TransferIterator) Next() bool

+ type Omni struct

+ func DeployOmni(auth *bind.TransactOpts, backend bind.ContractBackend, initialSupply *big.Int, ...) (common.Address, *types.Transaction, *Omni, error)

+ func NewOmni(address common.Address, backend bind.ContractBackend) (*Omni, error)

+ type OmniAVS struct

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

+ func NewOmniAVS(address common.Address, backend bind.ContractBackend) (*OmniAVS, error)

+ type OmniAVSAllowlistDisabled struct

+ Raw types.Log

+ type OmniAVSAllowlistDisabledIterator struct

+ Event *OmniAVSAllowlistDisabled

+ func (it *OmniAVSAllowlistDisabledIterator) Close() error

+ func (it *OmniAVSAllowlistDisabledIterator) Error() error

+ func (it *OmniAVSAllowlistDisabledIterator) Next() bool

+ type OmniAVSAllowlistEnabled struct

+ Raw types.Log

+ type OmniAVSAllowlistEnabledIterator struct

+ Event *OmniAVSAllowlistEnabled

+ func (it *OmniAVSAllowlistEnabledIterator) Close() error

+ func (it *OmniAVSAllowlistEnabledIterator) Error() error

+ func (it *OmniAVSAllowlistEnabledIterator) Next() bool

+ type OmniAVSCaller struct

+ func NewOmniAVSCaller(address common.Address, caller bind.ContractCaller) (*OmniAVSCaller, error)

+ func (_OmniAVS *OmniAVSCaller) AllowlistEnabled(opts *bind.CallOpts) (bool, error)

+ func (_OmniAVS *OmniAVSCaller) AvsDirectory(opts *bind.CallOpts) (common.Address, error)

+ func (_OmniAVS *OmniAVSCaller) CanRegister(opts *bind.CallOpts, operator common.Address) (bool, string, error)

+ func (_OmniAVS *OmniAVSCaller) EthStakeInbox(opts *bind.CallOpts) (common.Address, error)

+ func (_OmniAVS *OmniAVSCaller) FeeForSync(opts *bind.CallOpts) (*big.Int, error)

+ func (_OmniAVS *OmniAVSCaller) GetOperatorRestakedStrategies(opts *bind.CallOpts, operator common.Address) ([]common.Address, error)

+ func (_OmniAVS *OmniAVSCaller) GetRestakeableStrategies(opts *bind.CallOpts) ([]common.Address, error)

+ func (_OmniAVS *OmniAVSCaller) IsInAllowlist(opts *bind.CallOpts, operator common.Address) (bool, error)

+ func (_OmniAVS *OmniAVSCaller) MaxOperatorCount(opts *bind.CallOpts) (uint32, error)

+ func (_OmniAVS *OmniAVSCaller) MinOperatorStake(opts *bind.CallOpts) (*big.Int, error)

+ func (_OmniAVS *OmniAVSCaller) Omni(opts *bind.CallOpts) (common.Address, error)

+ func (_OmniAVS *OmniAVSCaller) OmniChainId(opts *bind.CallOpts) (uint64, error)

+ func (_OmniAVS *OmniAVSCaller) Operators(opts *bind.CallOpts) ([]IOmniAVSOperator, error)

+ func (_OmniAVS *OmniAVSCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_OmniAVS *OmniAVSCaller) Paused(opts *bind.CallOpts) (bool, error)

+ func (_OmniAVS *OmniAVSCaller) StrategyParams(opts *bind.CallOpts) ([]IOmniAVSStrategyParam, error)

+ func (_OmniAVS *OmniAVSCaller) XcallBaseGasLimit(opts *bind.CallOpts) (uint64, error)

+ func (_OmniAVS *OmniAVSCaller) XcallGasLimitPerOperator(opts *bind.CallOpts) (uint64, error)

+ type OmniAVSCallerRaw struct

+ Contract *OmniAVSCaller

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

+ type OmniAVSCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OmniAVSCaller

+ func (_OmniAVS *OmniAVSCallerSession) AllowlistEnabled() (bool, error)

+ func (_OmniAVS *OmniAVSCallerSession) AvsDirectory() (common.Address, error)

+ func (_OmniAVS *OmniAVSCallerSession) CanRegister(operator common.Address) (bool, string, error)

+ func (_OmniAVS *OmniAVSCallerSession) EthStakeInbox() (common.Address, error)

+ func (_OmniAVS *OmniAVSCallerSession) FeeForSync() (*big.Int, error)

+ func (_OmniAVS *OmniAVSCallerSession) GetOperatorRestakedStrategies(operator common.Address) ([]common.Address, error)

+ func (_OmniAVS *OmniAVSCallerSession) GetRestakeableStrategies() ([]common.Address, error)

+ func (_OmniAVS *OmniAVSCallerSession) IsInAllowlist(operator common.Address) (bool, error)

+ func (_OmniAVS *OmniAVSCallerSession) MaxOperatorCount() (uint32, error)

+ func (_OmniAVS *OmniAVSCallerSession) MinOperatorStake() (*big.Int, error)

+ func (_OmniAVS *OmniAVSCallerSession) Omni() (common.Address, error)

+ func (_OmniAVS *OmniAVSCallerSession) OmniChainId() (uint64, error)

+ func (_OmniAVS *OmniAVSCallerSession) Operators() ([]IOmniAVSOperator, error)

+ func (_OmniAVS *OmniAVSCallerSession) Owner() (common.Address, error)

+ func (_OmniAVS *OmniAVSCallerSession) Paused() (bool, error)

+ func (_OmniAVS *OmniAVSCallerSession) StrategyParams() ([]IOmniAVSStrategyParam, error)

+ func (_OmniAVS *OmniAVSCallerSession) XcallBaseGasLimit() (uint64, error)

+ func (_OmniAVS *OmniAVSCallerSession) XcallGasLimitPerOperator() (uint64, error)

+ type OmniAVSEthStakeInboxSet struct

+ Inbox common.Address

+ Raw types.Log

+ type OmniAVSEthStakeInboxSetIterator struct

+ Event *OmniAVSEthStakeInboxSet

+ func (it *OmniAVSEthStakeInboxSetIterator) Close() error

+ func (it *OmniAVSEthStakeInboxSetIterator) Error() error

+ func (it *OmniAVSEthStakeInboxSetIterator) Next() bool

+ type OmniAVSFilterer struct

+ func NewOmniAVSFilterer(address common.Address, filterer bind.ContractFilterer) (*OmniAVSFilterer, error)

+ func (_OmniAVS *OmniAVSFilterer) FilterAllowlistDisabled(opts *bind.FilterOpts) (*OmniAVSAllowlistDisabledIterator, error)

+ func (_OmniAVS *OmniAVSFilterer) FilterAllowlistEnabled(opts *bind.FilterOpts) (*OmniAVSAllowlistEnabledIterator, error)

+ func (_OmniAVS *OmniAVSFilterer) FilterEthStakeInboxSet(opts *bind.FilterOpts, inbox []common.Address) (*OmniAVSEthStakeInboxSetIterator, error)

+ func (_OmniAVS *OmniAVSFilterer) FilterInitialized(opts *bind.FilterOpts) (*OmniAVSInitializedIterator, error)

+ func (_OmniAVS *OmniAVSFilterer) FilterMaxOperatorCountSet(opts *bind.FilterOpts) (*OmniAVSMaxOperatorCountSetIterator, error)

+ func (_OmniAVS *OmniAVSFilterer) FilterMinOperatorStakeSet(opts *bind.FilterOpts) (*OmniAVSMinOperatorStakeSetIterator, error)

+ func (_OmniAVS *OmniAVSFilterer) FilterOmniChainIdSet(opts *bind.FilterOpts, chainID []uint64) (*OmniAVSOmniChainIdSetIterator, error)

+ func (_OmniAVS *OmniAVSFilterer) FilterOmniPortalSet(opts *bind.FilterOpts, portal []common.Address) (*OmniAVSOmniPortalSetIterator, error)

+ func (_OmniAVS *OmniAVSFilterer) FilterOperatorAdded(opts *bind.FilterOpts, operator []common.Address) (*OmniAVSOperatorAddedIterator, error)

+ func (_OmniAVS *OmniAVSFilterer) FilterOperatorAllowed(opts *bind.FilterOpts, operator []common.Address) (*OmniAVSOperatorAllowedIterator, error)

+ func (_OmniAVS *OmniAVSFilterer) FilterOperatorDisallowed(opts *bind.FilterOpts, operator []common.Address) (*OmniAVSOperatorDisallowedIterator, error)

+ func (_OmniAVS *OmniAVSFilterer) FilterOperatorRemoved(opts *bind.FilterOpts, operator []common.Address) (*OmniAVSOperatorRemovedIterator, error)

+ func (_OmniAVS *OmniAVSFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*OmniAVSOwnershipTransferredIterator, error)

+ func (_OmniAVS *OmniAVSFilterer) FilterPaused(opts *bind.FilterOpts) (*OmniAVSPausedIterator, error)

+ func (_OmniAVS *OmniAVSFilterer) FilterStrategyParamsSet(opts *bind.FilterOpts) (*OmniAVSStrategyParamsSetIterator, error)

+ func (_OmniAVS *OmniAVSFilterer) FilterUnpaused(opts *bind.FilterOpts) (*OmniAVSUnpausedIterator, error)

+ func (_OmniAVS *OmniAVSFilterer) FilterXCallGasLimitsSet(opts *bind.FilterOpts) (*OmniAVSXCallGasLimitsSetIterator, error)

+ func (_OmniAVS *OmniAVSFilterer) ParseAllowlistDisabled(log types.Log) (*OmniAVSAllowlistDisabled, error)

+ func (_OmniAVS *OmniAVSFilterer) ParseAllowlistEnabled(log types.Log) (*OmniAVSAllowlistEnabled, error)

+ func (_OmniAVS *OmniAVSFilterer) ParseEthStakeInboxSet(log types.Log) (*OmniAVSEthStakeInboxSet, error)

+ func (_OmniAVS *OmniAVSFilterer) ParseInitialized(log types.Log) (*OmniAVSInitialized, error)

+ func (_OmniAVS *OmniAVSFilterer) ParseMaxOperatorCountSet(log types.Log) (*OmniAVSMaxOperatorCountSet, error)

+ func (_OmniAVS *OmniAVSFilterer) ParseMinOperatorStakeSet(log types.Log) (*OmniAVSMinOperatorStakeSet, error)

+ func (_OmniAVS *OmniAVSFilterer) ParseOmniChainIdSet(log types.Log) (*OmniAVSOmniChainIdSet, error)

+ func (_OmniAVS *OmniAVSFilterer) ParseOmniPortalSet(log types.Log) (*OmniAVSOmniPortalSet, error)

+ func (_OmniAVS *OmniAVSFilterer) ParseOperatorAdded(log types.Log) (*OmniAVSOperatorAdded, error)

+ func (_OmniAVS *OmniAVSFilterer) ParseOperatorAllowed(log types.Log) (*OmniAVSOperatorAllowed, error)

+ func (_OmniAVS *OmniAVSFilterer) ParseOperatorDisallowed(log types.Log) (*OmniAVSOperatorDisallowed, error)

+ func (_OmniAVS *OmniAVSFilterer) ParseOperatorRemoved(log types.Log) (*OmniAVSOperatorRemoved, error)

+ func (_OmniAVS *OmniAVSFilterer) ParseOwnershipTransferred(log types.Log) (*OmniAVSOwnershipTransferred, error)

+ func (_OmniAVS *OmniAVSFilterer) ParsePaused(log types.Log) (*OmniAVSPaused, error)

+ func (_OmniAVS *OmniAVSFilterer) ParseStrategyParamsSet(log types.Log) (*OmniAVSStrategyParamsSet, error)

+ func (_OmniAVS *OmniAVSFilterer) ParseUnpaused(log types.Log) (*OmniAVSUnpaused, error)

+ func (_OmniAVS *OmniAVSFilterer) ParseXCallGasLimitsSet(log types.Log) (*OmniAVSXCallGasLimitsSet, error)

+ func (_OmniAVS *OmniAVSFilterer) WatchAllowlistDisabled(opts *bind.WatchOpts, sink chan<- *OmniAVSAllowlistDisabled) (event.Subscription, error)

+ func (_OmniAVS *OmniAVSFilterer) WatchAllowlistEnabled(opts *bind.WatchOpts, sink chan<- *OmniAVSAllowlistEnabled) (event.Subscription, error)

+ func (_OmniAVS *OmniAVSFilterer) WatchEthStakeInboxSet(opts *bind.WatchOpts, sink chan<- *OmniAVSEthStakeInboxSet, ...) (event.Subscription, error)

+ func (_OmniAVS *OmniAVSFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *OmniAVSInitialized) (event.Subscription, error)

+ func (_OmniAVS *OmniAVSFilterer) WatchMaxOperatorCountSet(opts *bind.WatchOpts, sink chan<- *OmniAVSMaxOperatorCountSet) (event.Subscription, error)

+ func (_OmniAVS *OmniAVSFilterer) WatchMinOperatorStakeSet(opts *bind.WatchOpts, sink chan<- *OmniAVSMinOperatorStakeSet) (event.Subscription, error)

+ func (_OmniAVS *OmniAVSFilterer) WatchOmniChainIdSet(opts *bind.WatchOpts, sink chan<- *OmniAVSOmniChainIdSet, chainID []uint64) (event.Subscription, error)

+ func (_OmniAVS *OmniAVSFilterer) WatchOmniPortalSet(opts *bind.WatchOpts, sink chan<- *OmniAVSOmniPortalSet, ...) (event.Subscription, error)

+ func (_OmniAVS *OmniAVSFilterer) WatchOperatorAdded(opts *bind.WatchOpts, sink chan<- *OmniAVSOperatorAdded, ...) (event.Subscription, error)

+ func (_OmniAVS *OmniAVSFilterer) WatchOperatorAllowed(opts *bind.WatchOpts, sink chan<- *OmniAVSOperatorAllowed, ...) (event.Subscription, error)

+ func (_OmniAVS *OmniAVSFilterer) WatchOperatorDisallowed(opts *bind.WatchOpts, sink chan<- *OmniAVSOperatorDisallowed, ...) (event.Subscription, error)

+ func (_OmniAVS *OmniAVSFilterer) WatchOperatorRemoved(opts *bind.WatchOpts, sink chan<- *OmniAVSOperatorRemoved, ...) (event.Subscription, error)

+ func (_OmniAVS *OmniAVSFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OmniAVSOwnershipTransferred, ...) (event.Subscription, error)

+ func (_OmniAVS *OmniAVSFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *OmniAVSPaused) (event.Subscription, error)

+ func (_OmniAVS *OmniAVSFilterer) WatchStrategyParamsSet(opts *bind.WatchOpts, sink chan<- *OmniAVSStrategyParamsSet) (event.Subscription, error)

+ func (_OmniAVS *OmniAVSFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *OmniAVSUnpaused) (event.Subscription, error)

+ func (_OmniAVS *OmniAVSFilterer) WatchXCallGasLimitsSet(opts *bind.WatchOpts, sink chan<- *OmniAVSXCallGasLimitsSet) (event.Subscription, error)

+ type OmniAVSInitialized struct

+ Raw types.Log

+ Version uint8

+ type OmniAVSInitializedIterator struct

+ Event *OmniAVSInitialized

+ func (it *OmniAVSInitializedIterator) Close() error

+ func (it *OmniAVSInitializedIterator) Error() error

+ func (it *OmniAVSInitializedIterator) Next() bool

+ type OmniAVSMaxOperatorCountSet struct

+ MaxOperatorCount uint32

+ Raw types.Log

+ type OmniAVSMaxOperatorCountSetIterator struct

+ Event *OmniAVSMaxOperatorCountSet

+ func (it *OmniAVSMaxOperatorCountSetIterator) Close() error

+ func (it *OmniAVSMaxOperatorCountSetIterator) Error() error

+ func (it *OmniAVSMaxOperatorCountSetIterator) Next() bool

+ type OmniAVSMinOperatorStakeSet struct

+ MinOperatorStake *big.Int

+ Raw types.Log

+ type OmniAVSMinOperatorStakeSetIterator struct

+ Event *OmniAVSMinOperatorStakeSet

+ func (it *OmniAVSMinOperatorStakeSetIterator) Close() error

+ func (it *OmniAVSMinOperatorStakeSetIterator) Error() error

+ func (it *OmniAVSMinOperatorStakeSetIterator) Next() bool

+ type OmniAVSOmniChainIdSet struct

+ ChainID uint64

+ Raw types.Log

+ type OmniAVSOmniChainIdSetIterator struct

+ Event *OmniAVSOmniChainIdSet

+ func (it *OmniAVSOmniChainIdSetIterator) Close() error

+ func (it *OmniAVSOmniChainIdSetIterator) Error() error

+ func (it *OmniAVSOmniChainIdSetIterator) Next() bool

+ type OmniAVSOmniPortalSet struct

+ Portal common.Address

+ Raw types.Log

+ type OmniAVSOmniPortalSetIterator struct

+ Event *OmniAVSOmniPortalSet

+ func (it *OmniAVSOmniPortalSetIterator) Close() error

+ func (it *OmniAVSOmniPortalSetIterator) Error() error

+ func (it *OmniAVSOmniPortalSetIterator) Next() bool

+ type OmniAVSOperatorAdded struct

+ Operator common.Address

+ Raw types.Log

+ type OmniAVSOperatorAddedIterator struct

+ Event *OmniAVSOperatorAdded

+ func (it *OmniAVSOperatorAddedIterator) Close() error

+ func (it *OmniAVSOperatorAddedIterator) Error() error

+ func (it *OmniAVSOperatorAddedIterator) Next() bool

+ type OmniAVSOperatorAllowed struct

+ Operator common.Address

+ Raw types.Log

+ type OmniAVSOperatorAllowedIterator struct

+ Event *OmniAVSOperatorAllowed

+ func (it *OmniAVSOperatorAllowedIterator) Close() error

+ func (it *OmniAVSOperatorAllowedIterator) Error() error

+ func (it *OmniAVSOperatorAllowedIterator) Next() bool

+ type OmniAVSOperatorDisallowed struct

+ Operator common.Address

+ Raw types.Log

+ type OmniAVSOperatorDisallowedIterator struct

+ Event *OmniAVSOperatorDisallowed

+ func (it *OmniAVSOperatorDisallowedIterator) Close() error

+ func (it *OmniAVSOperatorDisallowedIterator) Error() error

+ func (it *OmniAVSOperatorDisallowedIterator) Next() bool

+ type OmniAVSOperatorRemoved struct

+ Operator common.Address

+ Raw types.Log

+ type OmniAVSOperatorRemovedIterator struct

+ Event *OmniAVSOperatorRemoved

+ func (it *OmniAVSOperatorRemovedIterator) Close() error

+ func (it *OmniAVSOperatorRemovedIterator) Error() error

+ func (it *OmniAVSOperatorRemovedIterator) Next() bool

+ type OmniAVSOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type OmniAVSOwnershipTransferredIterator struct

+ Event *OmniAVSOwnershipTransferred

+ func (it *OmniAVSOwnershipTransferredIterator) Close() error

+ func (it *OmniAVSOwnershipTransferredIterator) Error() error

+ func (it *OmniAVSOwnershipTransferredIterator) Next() bool

+ type OmniAVSPaused struct

+ Account common.Address

+ Raw types.Log

+ type OmniAVSPausedIterator struct

+ Event *OmniAVSPaused

+ func (it *OmniAVSPausedIterator) Close() error

+ func (it *OmniAVSPausedIterator) Error() error

+ func (it *OmniAVSPausedIterator) Next() bool

+ type OmniAVSRaw struct

+ Contract *OmniAVS

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

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

+ func (_OmniAVS *OmniAVSRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OmniAVSSession struct

+ CallOpts bind.CallOpts

+ Contract *OmniAVS

+ TransactOpts bind.TransactOpts

+ func (_OmniAVS *OmniAVSSession) AddToAllowlist(operator common.Address) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSSession) AllowlistEnabled() (bool, error)

+ func (_OmniAVS *OmniAVSSession) AvsDirectory() (common.Address, error)

+ func (_OmniAVS *OmniAVSSession) CanRegister(operator common.Address) (bool, string, error)

+ func (_OmniAVS *OmniAVSSession) DisableAllowlist() (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSSession) EjectOperator(operator common.Address) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSSession) EnableAllowlist() (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSSession) EthStakeInbox() (common.Address, error)

+ func (_OmniAVS *OmniAVSSession) FeeForSync() (*big.Int, error)

+ func (_OmniAVS *OmniAVSSession) GetOperatorRestakedStrategies(operator common.Address) ([]common.Address, error)

+ func (_OmniAVS *OmniAVSSession) GetRestakeableStrategies() ([]common.Address, error)

+ func (_OmniAVS *OmniAVSSession) Initialize(owner_ common.Address, omni_ common.Address, omniChainId_ uint64, ...) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSSession) IsInAllowlist(operator common.Address) (bool, error)

+ func (_OmniAVS *OmniAVSSession) MaxOperatorCount() (uint32, error)

+ func (_OmniAVS *OmniAVSSession) MinOperatorStake() (*big.Int, error)

+ func (_OmniAVS *OmniAVSSession) Omni() (common.Address, error)

+ func (_OmniAVS *OmniAVSSession) OmniChainId() (uint64, error)

+ func (_OmniAVS *OmniAVSSession) Operators() ([]IOmniAVSOperator, error)

+ func (_OmniAVS *OmniAVSSession) Owner() (common.Address, error)

+ func (_OmniAVS *OmniAVSSession) Pause() (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSSession) Paused() (bool, error)

+ func (_OmniAVS *OmniAVSSession) RegisterOperator(pubkey []byte, operatorSignature ISignatureUtilsSignatureWithSaltAndExpiry) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSSession) RemoveFromAllowlist(operator common.Address) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSSession) RenounceOwnership() (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSSession) SetEthStakeInbox(inbox common.Address) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSSession) SetMaxOperatorCount(count uint32) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSSession) SetMetadataURI(metadataURI string) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSSession) SetMinOperatorStake(stake *big.Int) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSSession) SetOmniChainId(chainId uint64) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSSession) SetOmniPortal(portal common.Address) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSSession) SetStrategyParams(params []IOmniAVSStrategyParam) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSSession) SetXCallGasLimits(base uint64, perOperator uint64) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSSession) StrategyParams() ([]IOmniAVSStrategyParam, error)

+ func (_OmniAVS *OmniAVSSession) SyncWithOmni() (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSSession) Unpause() (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSSession) XcallBaseGasLimit() (uint64, error)

+ func (_OmniAVS *OmniAVSSession) XcallGasLimitPerOperator() (uint64, error)

+ type OmniAVSStrategyParamsSet struct

+ Params []IOmniAVSStrategyParam

+ Raw types.Log

+ type OmniAVSStrategyParamsSetIterator struct

+ Event *OmniAVSStrategyParamsSet

+ func (it *OmniAVSStrategyParamsSetIterator) Close() error

+ func (it *OmniAVSStrategyParamsSetIterator) Error() error

+ func (it *OmniAVSStrategyParamsSetIterator) Next() bool

+ type OmniAVSTransactor struct

+ func NewOmniAVSTransactor(address common.Address, transactor bind.ContractTransactor) (*OmniAVSTransactor, error)

+ func (_OmniAVS *OmniAVSTransactor) AddToAllowlist(opts *bind.TransactOpts, operator common.Address) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactor) DisableAllowlist(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactor) EjectOperator(opts *bind.TransactOpts, operator common.Address) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactor) EnableAllowlist(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactor) Initialize(opts *bind.TransactOpts, owner_ common.Address, omni_ common.Address, ...) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactor) RegisterOperator(opts *bind.TransactOpts, pubkey []byte, ...) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactor) RemoveFromAllowlist(opts *bind.TransactOpts, operator common.Address) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactor) SetEthStakeInbox(opts *bind.TransactOpts, inbox common.Address) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactor) SetMaxOperatorCount(opts *bind.TransactOpts, count uint32) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactor) SetMetadataURI(opts *bind.TransactOpts, metadataURI string) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactor) SetMinOperatorStake(opts *bind.TransactOpts, stake *big.Int) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactor) SetOmniChainId(opts *bind.TransactOpts, chainId uint64) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactor) SetOmniPortal(opts *bind.TransactOpts, portal common.Address) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactor) SetStrategyParams(opts *bind.TransactOpts, params []IOmniAVSStrategyParam) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactor) SetXCallGasLimits(opts *bind.TransactOpts, base uint64, perOperator uint64) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactor) SyncWithOmni(opts *bind.TransactOpts) (*types.Transaction, error)

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

+ func (_OmniAVS *OmniAVSTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OmniAVSTransactorRaw struct

+ Contract *OmniAVSTransactor

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

+ func (_OmniAVS *OmniAVSTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OmniAVSTransactorSession struct

+ Contract *OmniAVSTransactor

+ TransactOpts bind.TransactOpts

+ func (_OmniAVS *OmniAVSTransactorSession) AddToAllowlist(operator common.Address) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactorSession) DisableAllowlist() (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactorSession) EjectOperator(operator common.Address) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactorSession) EnableAllowlist() (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactorSession) Initialize(owner_ common.Address, omni_ common.Address, omniChainId_ uint64, ...) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactorSession) Pause() (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactorSession) RegisterOperator(pubkey []byte, operatorSignature ISignatureUtilsSignatureWithSaltAndExpiry) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactorSession) RemoveFromAllowlist(operator common.Address) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactorSession) SetEthStakeInbox(inbox common.Address) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactorSession) SetMaxOperatorCount(count uint32) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactorSession) SetMetadataURI(metadataURI string) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactorSession) SetMinOperatorStake(stake *big.Int) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactorSession) SetOmniChainId(chainId uint64) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactorSession) SetOmniPortal(portal common.Address) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactorSession) SetStrategyParams(params []IOmniAVSStrategyParam) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactorSession) SetXCallGasLimits(base uint64, perOperator uint64) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactorSession) SyncWithOmni() (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_OmniAVS *OmniAVSTransactorSession) Unpause() (*types.Transaction, error)

+ type OmniAVSUnpaused struct

+ Account common.Address

+ Raw types.Log

+ type OmniAVSUnpausedIterator struct

+ Event *OmniAVSUnpaused

+ func (it *OmniAVSUnpausedIterator) Close() error

+ func (it *OmniAVSUnpausedIterator) Error() error

+ func (it *OmniAVSUnpausedIterator) Next() bool

+ type OmniAVSXCallGasLimitsSet struct

+ Base uint64

+ PerValidator uint64

+ Raw types.Log

+ type OmniAVSXCallGasLimitsSetIterator struct

+ Event *OmniAVSXCallGasLimitsSet

+ func (it *OmniAVSXCallGasLimitsSetIterator) Close() error

+ func (it *OmniAVSXCallGasLimitsSetIterator) Error() error

+ func (it *OmniAVSXCallGasLimitsSetIterator) Next() bool

+ type OmniApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type OmniApprovalIterator struct

+ Event *OmniApproval

+ func (it *OmniApprovalIterator) Close() error

+ func (it *OmniApprovalIterator) Error() error

+ func (it *OmniApprovalIterator) Next() bool

+ type OmniBridgeL1 struct

+ func DeployOmniBridgeL1(auth *bind.TransactOpts, backend bind.ContractBackend, token_ common.Address) (common.Address, *types.Transaction, *OmniBridgeL1, error)

+ func NewOmniBridgeL1(address common.Address, backend bind.ContractBackend) (*OmniBridgeL1, error)

+ type OmniBridgeL1Bridge struct

+ Amount *big.Int

+ Payor common.Address

+ Raw types.Log

+ To common.Address

+ type OmniBridgeL1BridgeIterator struct

+ Event *OmniBridgeL1Bridge

+ func (it *OmniBridgeL1BridgeIterator) Close() error

+ func (it *OmniBridgeL1BridgeIterator) Error() error

+ func (it *OmniBridgeL1BridgeIterator) Next() bool

+ type OmniBridgeL1Caller struct

+ func NewOmniBridgeL1Caller(address common.Address, caller bind.ContractCaller) (*OmniBridgeL1Caller, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Caller) ACTIONBRIDGE(opts *bind.CallOpts) ([32]byte, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Caller) ACTIONWITHDRAW(opts *bind.CallOpts) ([32]byte, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Caller) BridgeFee(opts *bind.CallOpts, payor common.Address, to common.Address, amount *big.Int) (*big.Int, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Caller) IsPaused(opts *bind.CallOpts, action [32]byte) (bool, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Caller) KeyPauseAll(opts *bind.CallOpts) ([32]byte, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Caller) Omni(opts *bind.CallOpts) (common.Address, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Caller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Caller) Token(opts *bind.CallOpts) (common.Address, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Caller) XCALLWITHDRAWGASLIMIT(opts *bind.CallOpts) (uint64, error)

+ type OmniBridgeL1CallerRaw struct

+ Contract *OmniBridgeL1Caller

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

+ type OmniBridgeL1CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OmniBridgeL1Caller

+ func (_OmniBridgeL1 *OmniBridgeL1CallerSession) ACTIONBRIDGE() ([32]byte, error)

+ func (_OmniBridgeL1 *OmniBridgeL1CallerSession) ACTIONWITHDRAW() ([32]byte, error)

+ func (_OmniBridgeL1 *OmniBridgeL1CallerSession) BridgeFee(payor common.Address, to common.Address, amount *big.Int) (*big.Int, error)

+ func (_OmniBridgeL1 *OmniBridgeL1CallerSession) IsPaused(action [32]byte) (bool, error)

+ func (_OmniBridgeL1 *OmniBridgeL1CallerSession) KeyPauseAll() ([32]byte, error)

+ func (_OmniBridgeL1 *OmniBridgeL1CallerSession) Omni() (common.Address, error)

+ func (_OmniBridgeL1 *OmniBridgeL1CallerSession) Owner() (common.Address, error)

+ func (_OmniBridgeL1 *OmniBridgeL1CallerSession) Token() (common.Address, error)

+ func (_OmniBridgeL1 *OmniBridgeL1CallerSession) XCALLWITHDRAWGASLIMIT() (uint64, error)

+ type OmniBridgeL1Filterer struct

+ func NewOmniBridgeL1Filterer(address common.Address, filterer bind.ContractFilterer) (*OmniBridgeL1Filterer, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Filterer) FilterBridge(opts *bind.FilterOpts, payor []common.Address, to []common.Address) (*OmniBridgeL1BridgeIterator, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Filterer) FilterInitialized(opts *bind.FilterOpts) (*OmniBridgeL1InitializedIterator, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Filterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*OmniBridgeL1OwnershipTransferredIterator, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Filterer) FilterPaused(opts *bind.FilterOpts, key [][32]byte) (*OmniBridgeL1PausedIterator, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Filterer) FilterUnpaused(opts *bind.FilterOpts, key [][32]byte) (*OmniBridgeL1UnpausedIterator, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Filterer) FilterWithdraw(opts *bind.FilterOpts, to []common.Address) (*OmniBridgeL1WithdrawIterator, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Filterer) ParseBridge(log types.Log) (*OmniBridgeL1Bridge, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Filterer) ParseInitialized(log types.Log) (*OmniBridgeL1Initialized, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Filterer) ParseOwnershipTransferred(log types.Log) (*OmniBridgeL1OwnershipTransferred, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Filterer) ParsePaused(log types.Log) (*OmniBridgeL1Paused, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Filterer) ParseUnpaused(log types.Log) (*OmniBridgeL1Unpaused, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Filterer) ParseWithdraw(log types.Log) (*OmniBridgeL1Withdraw, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Filterer) WatchBridge(opts *bind.WatchOpts, sink chan<- *OmniBridgeL1Bridge, payor []common.Address, ...) (event.Subscription, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Filterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *OmniBridgeL1Initialized) (event.Subscription, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Filterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OmniBridgeL1OwnershipTransferred, ...) (event.Subscription, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Filterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *OmniBridgeL1Paused, key [][32]byte) (event.Subscription, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Filterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *OmniBridgeL1Unpaused, key [][32]byte) (event.Subscription, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Filterer) WatchWithdraw(opts *bind.WatchOpts, sink chan<- *OmniBridgeL1Withdraw, to []common.Address) (event.Subscription, error)

+ type OmniBridgeL1Initialized struct

+ Raw types.Log

+ Version uint64

+ type OmniBridgeL1InitializedIterator struct

+ Event *OmniBridgeL1Initialized

+ func (it *OmniBridgeL1InitializedIterator) Close() error

+ func (it *OmniBridgeL1InitializedIterator) Error() error

+ func (it *OmniBridgeL1InitializedIterator) Next() bool

+ type OmniBridgeL1OwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type OmniBridgeL1OwnershipTransferredIterator struct

+ Event *OmniBridgeL1OwnershipTransferred

+ func (it *OmniBridgeL1OwnershipTransferredIterator) Close() error

+ func (it *OmniBridgeL1OwnershipTransferredIterator) Error() error

+ func (it *OmniBridgeL1OwnershipTransferredIterator) Next() bool

+ type OmniBridgeL1Paused struct

+ Key [32]byte

+ Raw types.Log

+ type OmniBridgeL1PausedIterator struct

+ Event *OmniBridgeL1Paused

+ func (it *OmniBridgeL1PausedIterator) Close() error

+ func (it *OmniBridgeL1PausedIterator) Error() error

+ func (it *OmniBridgeL1PausedIterator) Next() bool

+ type OmniBridgeL1Raw struct

+ Contract *OmniBridgeL1

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

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

+ func (_OmniBridgeL1 *OmniBridgeL1Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OmniBridgeL1Session struct

+ CallOpts bind.CallOpts

+ Contract *OmniBridgeL1

+ TransactOpts bind.TransactOpts

+ func (_OmniBridgeL1 *OmniBridgeL1Session) ACTIONBRIDGE() ([32]byte, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Session) ACTIONWITHDRAW() ([32]byte, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Session) Bridge(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Session) BridgeFee(payor common.Address, to common.Address, amount *big.Int) (*big.Int, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Session) Initialize(owner_ common.Address, omni_ common.Address) (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Session) IsPaused(action [32]byte) (bool, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Session) KeyPauseAll() ([32]byte, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Session) Omni() (common.Address, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Session) Owner() (common.Address, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Session) Pause() (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Session) Pause0(action [32]byte) (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Session) RenounceOwnership() (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Session) Token() (common.Address, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Session) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Session) Unpause(action [32]byte) (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Session) Unpause0() (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Session) Withdraw(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Session) XCALLWITHDRAWGASLIMIT() (uint64, error)

+ type OmniBridgeL1Transactor struct

+ func NewOmniBridgeL1Transactor(address common.Address, transactor bind.ContractTransactor) (*OmniBridgeL1Transactor, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Transactor) Bridge(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Transactor) Initialize(opts *bind.TransactOpts, owner_ common.Address, omni_ common.Address) (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Transactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Transactor) Pause0(opts *bind.TransactOpts, action [32]byte) (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Transactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

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

+ func (_OmniBridgeL1 *OmniBridgeL1Transactor) Unpause(opts *bind.TransactOpts, action [32]byte) (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Transactor) Unpause0(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1Transactor) Withdraw(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error)

+ type OmniBridgeL1TransactorRaw struct

+ Contract *OmniBridgeL1Transactor

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

+ func (_OmniBridgeL1 *OmniBridgeL1TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OmniBridgeL1TransactorSession struct

+ Contract *OmniBridgeL1Transactor

+ TransactOpts bind.TransactOpts

+ func (_OmniBridgeL1 *OmniBridgeL1TransactorSession) Bridge(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1TransactorSession) Initialize(owner_ common.Address, omni_ common.Address) (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1TransactorSession) Pause() (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1TransactorSession) Pause0(action [32]byte) (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1TransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1TransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1TransactorSession) Unpause(action [32]byte) (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1TransactorSession) Unpause0() (*types.Transaction, error)

+ func (_OmniBridgeL1 *OmniBridgeL1TransactorSession) Withdraw(to common.Address, amount *big.Int) (*types.Transaction, error)

+ type OmniBridgeL1Unpaused struct

+ Key [32]byte

+ Raw types.Log

+ type OmniBridgeL1UnpausedIterator struct

+ Event *OmniBridgeL1Unpaused

+ func (it *OmniBridgeL1UnpausedIterator) Close() error

+ func (it *OmniBridgeL1UnpausedIterator) Error() error

+ func (it *OmniBridgeL1UnpausedIterator) Next() bool

+ type OmniBridgeL1Withdraw struct

+ Amount *big.Int

+ Raw types.Log

+ To common.Address

+ type OmniBridgeL1WithdrawIterator struct

+ Event *OmniBridgeL1Withdraw

+ func (it *OmniBridgeL1WithdrawIterator) Close() error

+ func (it *OmniBridgeL1WithdrawIterator) Error() error

+ func (it *OmniBridgeL1WithdrawIterator) Next() bool

+ type OmniBridgeNative struct

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

+ func NewOmniBridgeNative(address common.Address, backend bind.ContractBackend) (*OmniBridgeNative, error)

+ type OmniBridgeNativeBridge struct

+ Amount *big.Int

+ Payor common.Address

+ Raw types.Log

+ To common.Address

+ type OmniBridgeNativeBridgeIterator struct

+ Event *OmniBridgeNativeBridge

+ func (it *OmniBridgeNativeBridgeIterator) Close() error

+ func (it *OmniBridgeNativeBridgeIterator) Error() error

+ func (it *OmniBridgeNativeBridgeIterator) Next() bool

+ type OmniBridgeNativeCaller struct

+ func NewOmniBridgeNativeCaller(address common.Address, caller bind.ContractCaller) (*OmniBridgeNativeCaller, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCaller) ACTIONBRIDGE(opts *bind.CallOpts) ([32]byte, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCaller) ACTIONWITHDRAW(opts *bind.CallOpts) ([32]byte, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCaller) BridgeFee(opts *bind.CallOpts, to common.Address, amount *big.Int) (*big.Int, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCaller) Claimable(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCaller) IsPaused(opts *bind.CallOpts, action [32]byte) (bool, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCaller) KeyPauseAll(opts *bind.CallOpts) ([32]byte, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCaller) L1Bridge(opts *bind.CallOpts) (common.Address, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCaller) L1BridgeBalance(opts *bind.CallOpts) (*big.Int, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCaller) L1ChainId(opts *bind.CallOpts) (uint64, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCaller) Omni(opts *bind.CallOpts) (common.Address, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCaller) XCALLWITHDRAWGASLIMIT(opts *bind.CallOpts) (uint64, error)

+ type OmniBridgeNativeCallerRaw struct

+ Contract *OmniBridgeNativeCaller

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

+ type OmniBridgeNativeCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OmniBridgeNativeCaller

+ func (_OmniBridgeNative *OmniBridgeNativeCallerSession) ACTIONBRIDGE() ([32]byte, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCallerSession) ACTIONWITHDRAW() ([32]byte, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCallerSession) BridgeFee(to common.Address, amount *big.Int) (*big.Int, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCallerSession) Claimable(arg0 common.Address) (*big.Int, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCallerSession) IsPaused(action [32]byte) (bool, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCallerSession) KeyPauseAll() ([32]byte, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCallerSession) L1Bridge() (common.Address, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCallerSession) L1BridgeBalance() (*big.Int, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCallerSession) L1ChainId() (uint64, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCallerSession) Omni() (common.Address, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCallerSession) Owner() (common.Address, error)

+ func (_OmniBridgeNative *OmniBridgeNativeCallerSession) XCALLWITHDRAWGASLIMIT() (uint64, error)

+ type OmniBridgeNativeClaimed struct

+ Amount *big.Int

+ Claimant common.Address

+ Raw types.Log

+ To common.Address

+ type OmniBridgeNativeClaimedIterator struct

+ Event *OmniBridgeNativeClaimed

+ func (it *OmniBridgeNativeClaimedIterator) Close() error

+ func (it *OmniBridgeNativeClaimedIterator) Error() error

+ func (it *OmniBridgeNativeClaimedIterator) Next() bool

+ type OmniBridgeNativeFilterer struct

+ func NewOmniBridgeNativeFilterer(address common.Address, filterer bind.ContractFilterer) (*OmniBridgeNativeFilterer, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) FilterBridge(opts *bind.FilterOpts, payor []common.Address, to []common.Address) (*OmniBridgeNativeBridgeIterator, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) FilterClaimed(opts *bind.FilterOpts, claimant []common.Address, to []common.Address) (*OmniBridgeNativeClaimedIterator, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) FilterInitialized(opts *bind.FilterOpts) (*OmniBridgeNativeInitializedIterator, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*OmniBridgeNativeOwnershipTransferredIterator, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) FilterPaused(opts *bind.FilterOpts, key [][32]byte) (*OmniBridgeNativePausedIterator, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) FilterSetup(opts *bind.FilterOpts) (*OmniBridgeNativeSetupIterator, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) FilterUnpaused(opts *bind.FilterOpts, key [][32]byte) (*OmniBridgeNativeUnpausedIterator, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) FilterWithdraw(opts *bind.FilterOpts, payor []common.Address, to []common.Address) (*OmniBridgeNativeWithdrawIterator, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) ParseBridge(log types.Log) (*OmniBridgeNativeBridge, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) ParseClaimed(log types.Log) (*OmniBridgeNativeClaimed, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) ParseInitialized(log types.Log) (*OmniBridgeNativeInitialized, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) ParseOwnershipTransferred(log types.Log) (*OmniBridgeNativeOwnershipTransferred, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) ParsePaused(log types.Log) (*OmniBridgeNativePaused, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) ParseSetup(log types.Log) (*OmniBridgeNativeSetup, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) ParseUnpaused(log types.Log) (*OmniBridgeNativeUnpaused, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) ParseWithdraw(log types.Log) (*OmniBridgeNativeWithdraw, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) WatchBridge(opts *bind.WatchOpts, sink chan<- *OmniBridgeNativeBridge, ...) (event.Subscription, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) WatchClaimed(opts *bind.WatchOpts, sink chan<- *OmniBridgeNativeClaimed, ...) (event.Subscription, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *OmniBridgeNativeInitialized) (event.Subscription, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OmniBridgeNativeOwnershipTransferred, ...) (event.Subscription, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *OmniBridgeNativePaused, key [][32]byte) (event.Subscription, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) WatchSetup(opts *bind.WatchOpts, sink chan<- *OmniBridgeNativeSetup) (event.Subscription, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *OmniBridgeNativeUnpaused, key [][32]byte) (event.Subscription, error)

+ func (_OmniBridgeNative *OmniBridgeNativeFilterer) WatchWithdraw(opts *bind.WatchOpts, sink chan<- *OmniBridgeNativeWithdraw, ...) (event.Subscription, error)

+ type OmniBridgeNativeInitialized struct

+ Raw types.Log

+ Version uint64

+ type OmniBridgeNativeInitializedIterator struct

+ Event *OmniBridgeNativeInitialized

+ func (it *OmniBridgeNativeInitializedIterator) Close() error

+ func (it *OmniBridgeNativeInitializedIterator) Error() error

+ func (it *OmniBridgeNativeInitializedIterator) Next() bool

+ type OmniBridgeNativeOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type OmniBridgeNativeOwnershipTransferredIterator struct

+ Event *OmniBridgeNativeOwnershipTransferred

+ func (it *OmniBridgeNativeOwnershipTransferredIterator) Close() error

+ func (it *OmniBridgeNativeOwnershipTransferredIterator) Error() error

+ func (it *OmniBridgeNativeOwnershipTransferredIterator) Next() bool

+ type OmniBridgeNativePaused struct

+ Key [32]byte

+ Raw types.Log

+ type OmniBridgeNativePausedIterator struct

+ Event *OmniBridgeNativePaused

+ func (it *OmniBridgeNativePausedIterator) Close() error

+ func (it *OmniBridgeNativePausedIterator) Error() error

+ func (it *OmniBridgeNativePausedIterator) Next() bool

+ type OmniBridgeNativeRaw struct

+ Contract *OmniBridgeNative

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

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

+ func (_OmniBridgeNative *OmniBridgeNativeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OmniBridgeNativeSession struct

+ CallOpts bind.CallOpts

+ Contract *OmniBridgeNative

+ TransactOpts bind.TransactOpts

+ func (_OmniBridgeNative *OmniBridgeNativeSession) ACTIONBRIDGE() ([32]byte, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) ACTIONWITHDRAW() ([32]byte, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) Bridge(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) BridgeFee(to common.Address, amount *big.Int) (*big.Int, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) Claim(to common.Address) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) Claimable(arg0 common.Address) (*big.Int, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) Initialize(owner_ common.Address) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) IsPaused(action [32]byte) (bool, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) KeyPauseAll() ([32]byte, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) L1Bridge() (common.Address, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) L1BridgeBalance() (*big.Int, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) L1ChainId() (uint64, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) Omni() (common.Address, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) Owner() (common.Address, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) Pause() (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) Pause0(action [32]byte) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) RenounceOwnership() (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) Setup(l1ChainId_ uint64, omni_ common.Address, l1Bridge_ common.Address) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) Unpause(action [32]byte) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) Unpause0() (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) Withdraw(payor common.Address, to common.Address, amount *big.Int, l1Balance *big.Int) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeSession) XCALLWITHDRAWGASLIMIT() (uint64, error)

+ type OmniBridgeNativeSetup struct

+ L1Bridge common.Address

+ L1ChainId uint64

+ Omni common.Address

+ Raw types.Log

+ type OmniBridgeNativeSetupIterator struct

+ Event *OmniBridgeNativeSetup

+ func (it *OmniBridgeNativeSetupIterator) Close() error

+ func (it *OmniBridgeNativeSetupIterator) Error() error

+ func (it *OmniBridgeNativeSetupIterator) Next() bool

+ type OmniBridgeNativeTransactor struct

+ func NewOmniBridgeNativeTransactor(address common.Address, transactor bind.ContractTransactor) (*OmniBridgeNativeTransactor, error)

+ func (_OmniBridgeNative *OmniBridgeNativeTransactor) Bridge(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeTransactor) Claim(opts *bind.TransactOpts, to common.Address) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeTransactor) Initialize(opts *bind.TransactOpts, owner_ common.Address) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeTransactor) Pause0(opts *bind.TransactOpts, action [32]byte) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeTransactor) Setup(opts *bind.TransactOpts, l1ChainId_ uint64, omni_ common.Address, ...) (*types.Transaction, error)

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

+ func (_OmniBridgeNative *OmniBridgeNativeTransactor) Unpause(opts *bind.TransactOpts, action [32]byte) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeTransactor) Unpause0(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeTransactor) Withdraw(opts *bind.TransactOpts, payor common.Address, to common.Address, ...) (*types.Transaction, error)

+ type OmniBridgeNativeTransactorRaw struct

+ Contract *OmniBridgeNativeTransactor

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

+ func (_OmniBridgeNative *OmniBridgeNativeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OmniBridgeNativeTransactorSession struct

+ Contract *OmniBridgeNativeTransactor

+ TransactOpts bind.TransactOpts

+ func (_OmniBridgeNative *OmniBridgeNativeTransactorSession) Bridge(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeTransactorSession) Claim(to common.Address) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeTransactorSession) Initialize(owner_ common.Address) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeTransactorSession) Pause() (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeTransactorSession) Pause0(action [32]byte) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeTransactorSession) Setup(l1ChainId_ uint64, omni_ common.Address, l1Bridge_ common.Address) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeTransactorSession) Unpause(action [32]byte) (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeTransactorSession) Unpause0() (*types.Transaction, error)

+ func (_OmniBridgeNative *OmniBridgeNativeTransactorSession) Withdraw(payor common.Address, to common.Address, amount *big.Int, l1Balance *big.Int) (*types.Transaction, error)

+ type OmniBridgeNativeUnpaused struct

+ Key [32]byte

+ Raw types.Log

+ type OmniBridgeNativeUnpausedIterator struct

+ Event *OmniBridgeNativeUnpaused

+ func (it *OmniBridgeNativeUnpausedIterator) Close() error

+ func (it *OmniBridgeNativeUnpausedIterator) Error() error

+ func (it *OmniBridgeNativeUnpausedIterator) Next() bool

+ type OmniBridgeNativeWithdraw struct

+ Amount *big.Int

+ Payor common.Address

+ Raw types.Log

+ Success bool

+ To common.Address

+ type OmniBridgeNativeWithdrawIterator struct

+ Event *OmniBridgeNativeWithdraw

+ func (it *OmniBridgeNativeWithdrawIterator) Close() error

+ func (it *OmniBridgeNativeWithdrawIterator) Error() error

+ func (it *OmniBridgeNativeWithdrawIterator) Next() bool

+ type OmniCaller struct

+ func NewOmniCaller(address common.Address, caller bind.ContractCaller) (*OmniCaller, error)

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

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

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

+ func (_Omni *OmniCaller) Decimals(opts *bind.CallOpts) (uint8, error)

+ func (_Omni *OmniCaller) Eip712Domain(opts *bind.CallOpts) (struct{ ... }, error)

+ func (_Omni *OmniCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_Omni *OmniCaller) Nonces(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_Omni *OmniCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_Omni *OmniCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type OmniCallerRaw struct

+ Contract *OmniCaller

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

+ type OmniCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OmniCaller

+ func (_Omni *OmniCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_Omni *OmniCallerSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_Omni *OmniCallerSession) DOMAINSEPARATOR() ([32]byte, error)

+ func (_Omni *OmniCallerSession) Decimals() (uint8, error)

+ func (_Omni *OmniCallerSession) Eip712Domain() (struct{ ... }, error)

+ func (_Omni *OmniCallerSession) Name() (string, error)

+ func (_Omni *OmniCallerSession) Nonces(owner common.Address) (*big.Int, error)

+ func (_Omni *OmniCallerSession) Symbol() (string, error)

+ func (_Omni *OmniCallerSession) TotalSupply() (*big.Int, error)

+ type OmniEIP712DomainChanged struct

+ Raw types.Log

+ type OmniEIP712DomainChangedIterator struct

+ Event *OmniEIP712DomainChanged

+ func (it *OmniEIP712DomainChangedIterator) Close() error

+ func (it *OmniEIP712DomainChangedIterator) Error() error

+ func (it *OmniEIP712DomainChangedIterator) Next() bool

+ type OmniFilterer struct

+ func NewOmniFilterer(address common.Address, filterer bind.ContractFilterer) (*OmniFilterer, error)

+ func (_Omni *OmniFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*OmniApprovalIterator, error)

+ func (_Omni *OmniFilterer) FilterEIP712DomainChanged(opts *bind.FilterOpts) (*OmniEIP712DomainChangedIterator, error)

+ func (_Omni *OmniFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*OmniTransferIterator, error)

+ func (_Omni *OmniFilterer) ParseApproval(log types.Log) (*OmniApproval, error)

+ func (_Omni *OmniFilterer) ParseEIP712DomainChanged(log types.Log) (*OmniEIP712DomainChanged, error)

+ func (_Omni *OmniFilterer) ParseTransfer(log types.Log) (*OmniTransfer, error)

+ func (_Omni *OmniFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *OmniApproval, owner []common.Address, ...) (event.Subscription, error)

+ func (_Omni *OmniFilterer) WatchEIP712DomainChanged(opts *bind.WatchOpts, sink chan<- *OmniEIP712DomainChanged) (event.Subscription, error)

+ func (_Omni *OmniFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *OmniTransfer, from []common.Address, ...) (event.Subscription, error)

+ type OmniGasPump struct

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

+ func NewOmniGasPump(address common.Address, backend bind.ContractBackend) (*OmniGasPump, error)

+ type OmniGasPumpCaller struct

+ func NewOmniGasPumpCaller(address common.Address, caller bind.ContractCaller) (*OmniGasPumpCaller, error)

+ func (_OmniGasPump *OmniGasPumpCaller) DefaultConfLevel(opts *bind.CallOpts) (uint8, error)

+ func (_OmniGasPump *OmniGasPumpCaller) DryFillUp(opts *bind.CallOpts, amtETH *big.Int) (*big.Int, bool, string, error)

+ func (_OmniGasPump *OmniGasPumpCaller) GasStation(opts *bind.CallOpts) (common.Address, error)

+ func (_OmniGasPump *OmniGasPumpCaller) MaxSwap(opts *bind.CallOpts) (*big.Int, error)

+ func (_OmniGasPump *OmniGasPumpCaller) Omni(opts *bind.CallOpts) (common.Address, error)

+ func (_OmniGasPump *OmniGasPumpCaller) Oracle(opts *bind.CallOpts) (common.Address, error)

+ func (_OmniGasPump *OmniGasPumpCaller) Owed(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_OmniGasPump *OmniGasPumpCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_OmniGasPump *OmniGasPumpCaller) Paused(opts *bind.CallOpts) (bool, error)

+ func (_OmniGasPump *OmniGasPumpCaller) Quote(opts *bind.CallOpts, amtOMNI *big.Int) (*big.Int, error)

+ func (_OmniGasPump *OmniGasPumpCaller) SETTLEGAS(opts *bind.CallOpts) (uint64, error)

+ func (_OmniGasPump *OmniGasPumpCaller) TOLLDENOM(opts *bind.CallOpts) (*big.Int, error)

+ func (_OmniGasPump *OmniGasPumpCaller) Toll(opts *bind.CallOpts) (*big.Int, error)

+ func (_OmniGasPump *OmniGasPumpCaller) Xfee(opts *bind.CallOpts) (*big.Int, error)

+ type OmniGasPumpCallerRaw struct

+ Contract *OmniGasPumpCaller

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

+ type OmniGasPumpCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OmniGasPumpCaller

+ func (_OmniGasPump *OmniGasPumpCallerSession) DefaultConfLevel() (uint8, error)

+ func (_OmniGasPump *OmniGasPumpCallerSession) DryFillUp(amtETH *big.Int) (*big.Int, bool, string, error)

+ func (_OmniGasPump *OmniGasPumpCallerSession) GasStation() (common.Address, error)

+ func (_OmniGasPump *OmniGasPumpCallerSession) MaxSwap() (*big.Int, error)

+ func (_OmniGasPump *OmniGasPumpCallerSession) Omni() (common.Address, error)

+ func (_OmniGasPump *OmniGasPumpCallerSession) Oracle() (common.Address, error)

+ func (_OmniGasPump *OmniGasPumpCallerSession) Owed(arg0 common.Address) (*big.Int, error)

+ func (_OmniGasPump *OmniGasPumpCallerSession) Owner() (common.Address, error)

+ func (_OmniGasPump *OmniGasPumpCallerSession) Paused() (bool, error)

+ func (_OmniGasPump *OmniGasPumpCallerSession) Quote(amtOMNI *big.Int) (*big.Int, error)

+ func (_OmniGasPump *OmniGasPumpCallerSession) SETTLEGAS() (uint64, error)

+ func (_OmniGasPump *OmniGasPumpCallerSession) TOLLDENOM() (*big.Int, error)

+ func (_OmniGasPump *OmniGasPumpCallerSession) Toll() (*big.Int, error)

+ func (_OmniGasPump *OmniGasPumpCallerSession) Xfee() (*big.Int, error)

+ type OmniGasPumpDefaultConfLevelSet struct

+ Conf uint8

+ Raw types.Log

+ type OmniGasPumpDefaultConfLevelSetIterator struct

+ Event *OmniGasPumpDefaultConfLevelSet

+ func (it *OmniGasPumpDefaultConfLevelSetIterator) Close() error

+ func (it *OmniGasPumpDefaultConfLevelSetIterator) Error() error

+ func (it *OmniGasPumpDefaultConfLevelSetIterator) Next() bool

+ type OmniGasPumpFilledUp struct

+ AmtETH *big.Int

+ AmtOMNI *big.Int

+ Fee *big.Int

+ Owed *big.Int

+ Raw types.Log

+ Recipient common.Address

+ Toll *big.Int

+ type OmniGasPumpFilledUpIterator struct

+ Event *OmniGasPumpFilledUp

+ func (it *OmniGasPumpFilledUpIterator) Close() error

+ func (it *OmniGasPumpFilledUpIterator) Error() error

+ func (it *OmniGasPumpFilledUpIterator) Next() bool

+ type OmniGasPumpFilterer struct

+ func NewOmniGasPumpFilterer(address common.Address, filterer bind.ContractFilterer) (*OmniGasPumpFilterer, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) FilterDefaultConfLevelSet(opts *bind.FilterOpts) (*OmniGasPumpDefaultConfLevelSetIterator, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) FilterFilledUp(opts *bind.FilterOpts, recipient []common.Address) (*OmniGasPumpFilledUpIterator, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) FilterGasStationSet(opts *bind.FilterOpts) (*OmniGasPumpGasStationSetIterator, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) FilterInitialized(opts *bind.FilterOpts) (*OmniGasPumpInitializedIterator, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) FilterMaxSwapSet(opts *bind.FilterOpts) (*OmniGasPumpMaxSwapSetIterator, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) FilterOmniPortalSet(opts *bind.FilterOpts) (*OmniGasPumpOmniPortalSetIterator, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) FilterOracleSet(opts *bind.FilterOpts) (*OmniGasPumpOracleSetIterator, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*OmniGasPumpOwnershipTransferredIterator, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) FilterPaused(opts *bind.FilterOpts) (*OmniGasPumpPausedIterator, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) FilterTollSet(opts *bind.FilterOpts) (*OmniGasPumpTollSetIterator, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) FilterUnpaused(opts *bind.FilterOpts) (*OmniGasPumpUnpausedIterator, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) ParseDefaultConfLevelSet(log types.Log) (*OmniGasPumpDefaultConfLevelSet, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) ParseFilledUp(log types.Log) (*OmniGasPumpFilledUp, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) ParseGasStationSet(log types.Log) (*OmniGasPumpGasStationSet, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) ParseInitialized(log types.Log) (*OmniGasPumpInitialized, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) ParseMaxSwapSet(log types.Log) (*OmniGasPumpMaxSwapSet, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) ParseOmniPortalSet(log types.Log) (*OmniGasPumpOmniPortalSet, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) ParseOracleSet(log types.Log) (*OmniGasPumpOracleSet, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) ParseOwnershipTransferred(log types.Log) (*OmniGasPumpOwnershipTransferred, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) ParsePaused(log types.Log) (*OmniGasPumpPaused, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) ParseTollSet(log types.Log) (*OmniGasPumpTollSet, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) ParseUnpaused(log types.Log) (*OmniGasPumpUnpaused, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) WatchDefaultConfLevelSet(opts *bind.WatchOpts, sink chan<- *OmniGasPumpDefaultConfLevelSet) (event.Subscription, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) WatchFilledUp(opts *bind.WatchOpts, sink chan<- *OmniGasPumpFilledUp, ...) (event.Subscription, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) WatchGasStationSet(opts *bind.WatchOpts, sink chan<- *OmniGasPumpGasStationSet) (event.Subscription, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *OmniGasPumpInitialized) (event.Subscription, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) WatchMaxSwapSet(opts *bind.WatchOpts, sink chan<- *OmniGasPumpMaxSwapSet) (event.Subscription, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) WatchOmniPortalSet(opts *bind.WatchOpts, sink chan<- *OmniGasPumpOmniPortalSet) (event.Subscription, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) WatchOracleSet(opts *bind.WatchOpts, sink chan<- *OmniGasPumpOracleSet) (event.Subscription, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OmniGasPumpOwnershipTransferred, ...) (event.Subscription, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *OmniGasPumpPaused) (event.Subscription, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) WatchTollSet(opts *bind.WatchOpts, sink chan<- *OmniGasPumpTollSet) (event.Subscription, error)

+ func (_OmniGasPump *OmniGasPumpFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *OmniGasPumpUnpaused) (event.Subscription, error)

+ type OmniGasPumpGasStationSet struct

+ Raw types.Log

+ Station common.Address

+ type OmniGasPumpGasStationSetIterator struct

+ Event *OmniGasPumpGasStationSet

+ func (it *OmniGasPumpGasStationSetIterator) Close() error

+ func (it *OmniGasPumpGasStationSetIterator) Error() error

+ func (it *OmniGasPumpGasStationSetIterator) Next() bool

+ type OmniGasPumpInitParams struct

+ GasStation common.Address

+ MaxSwap *big.Int

+ Oracle common.Address

+ Owner common.Address

+ Portal common.Address

+ Toll *big.Int

+ type OmniGasPumpInitialized struct

+ Raw types.Log

+ Version uint64

+ type OmniGasPumpInitializedIterator struct

+ Event *OmniGasPumpInitialized

+ func (it *OmniGasPumpInitializedIterator) Close() error

+ func (it *OmniGasPumpInitializedIterator) Error() error

+ func (it *OmniGasPumpInitializedIterator) Next() bool

+ type OmniGasPumpMaxSwapSet struct

+ Max *big.Int

+ Raw types.Log

+ type OmniGasPumpMaxSwapSetIterator struct

+ Event *OmniGasPumpMaxSwapSet

+ func (it *OmniGasPumpMaxSwapSetIterator) Close() error

+ func (it *OmniGasPumpMaxSwapSetIterator) Error() error

+ func (it *OmniGasPumpMaxSwapSetIterator) Next() bool

+ type OmniGasPumpOmniPortalSet struct

+ Omni common.Address

+ Raw types.Log

+ type OmniGasPumpOmniPortalSetIterator struct

+ Event *OmniGasPumpOmniPortalSet

+ func (it *OmniGasPumpOmniPortalSetIterator) Close() error

+ func (it *OmniGasPumpOmniPortalSetIterator) Error() error

+ func (it *OmniGasPumpOmniPortalSetIterator) Next() bool

+ type OmniGasPumpOracleSet struct

+ Oracle common.Address

+ Raw types.Log

+ type OmniGasPumpOracleSetIterator struct

+ Event *OmniGasPumpOracleSet

+ func (it *OmniGasPumpOracleSetIterator) Close() error

+ func (it *OmniGasPumpOracleSetIterator) Error() error

+ func (it *OmniGasPumpOracleSetIterator) Next() bool

+ type OmniGasPumpOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type OmniGasPumpOwnershipTransferredIterator struct

+ Event *OmniGasPumpOwnershipTransferred

+ func (it *OmniGasPumpOwnershipTransferredIterator) Close() error

+ func (it *OmniGasPumpOwnershipTransferredIterator) Error() error

+ func (it *OmniGasPumpOwnershipTransferredIterator) Next() bool

+ type OmniGasPumpPaused struct

+ Account common.Address

+ Raw types.Log

+ type OmniGasPumpPausedIterator struct

+ Event *OmniGasPumpPaused

+ func (it *OmniGasPumpPausedIterator) Close() error

+ func (it *OmniGasPumpPausedIterator) Error() error

+ func (it *OmniGasPumpPausedIterator) Next() bool

+ type OmniGasPumpRaw struct

+ Contract *OmniGasPump

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

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

+ func (_OmniGasPump *OmniGasPumpRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OmniGasPumpSession struct

+ CallOpts bind.CallOpts

+ Contract *OmniGasPump

+ TransactOpts bind.TransactOpts

+ func (_OmniGasPump *OmniGasPumpSession) DefaultConfLevel() (uint8, error)

+ func (_OmniGasPump *OmniGasPumpSession) DryFillUp(amtETH *big.Int) (*big.Int, bool, string, error)

+ func (_OmniGasPump *OmniGasPumpSession) FillUp(recipient common.Address) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpSession) GasStation() (common.Address, error)

+ func (_OmniGasPump *OmniGasPumpSession) Initialize(p OmniGasPumpInitParams) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpSession) MaxSwap() (*big.Int, error)

+ func (_OmniGasPump *OmniGasPumpSession) Omni() (common.Address, error)

+ func (_OmniGasPump *OmniGasPumpSession) Oracle() (common.Address, error)

+ func (_OmniGasPump *OmniGasPumpSession) Owed(arg0 common.Address) (*big.Int, error)

+ func (_OmniGasPump *OmniGasPumpSession) Owner() (common.Address, error)

+ func (_OmniGasPump *OmniGasPumpSession) Pause() (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpSession) Paused() (bool, error)

+ func (_OmniGasPump *OmniGasPumpSession) Quote(amtOMNI *big.Int) (*big.Int, error)

+ func (_OmniGasPump *OmniGasPumpSession) RenounceOwnership() (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpSession) SETTLEGAS() (uint64, error)

+ func (_OmniGasPump *OmniGasPumpSession) SetGasStation(station common.Address) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpSession) SetMaxSwap(max *big.Int) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpSession) SetOracle(oracle_ common.Address) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpSession) SetToll(pct *big.Int) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpSession) TOLLDENOM() (*big.Int, error)

+ func (_OmniGasPump *OmniGasPumpSession) Toll() (*big.Int, error)

+ func (_OmniGasPump *OmniGasPumpSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpSession) Unpause() (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpSession) Withdraw(to common.Address) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpSession) Xfee() (*big.Int, error)

+ type OmniGasPumpTollSet struct

+ Pct *big.Int

+ Raw types.Log

+ type OmniGasPumpTollSetIterator struct

+ Event *OmniGasPumpTollSet

+ func (it *OmniGasPumpTollSetIterator) Close() error

+ func (it *OmniGasPumpTollSetIterator) Error() error

+ func (it *OmniGasPumpTollSetIterator) Next() bool

+ type OmniGasPumpTransactor struct

+ func NewOmniGasPumpTransactor(address common.Address, transactor bind.ContractTransactor) (*OmniGasPumpTransactor, error)

+ func (_OmniGasPump *OmniGasPumpTransactor) FillUp(opts *bind.TransactOpts, recipient common.Address) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpTransactor) Initialize(opts *bind.TransactOpts, p OmniGasPumpInitParams) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpTransactor) SetGasStation(opts *bind.TransactOpts, station common.Address) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpTransactor) SetMaxSwap(opts *bind.TransactOpts, max *big.Int) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpTransactor) SetOracle(opts *bind.TransactOpts, oracle_ common.Address) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpTransactor) SetToll(opts *bind.TransactOpts, pct *big.Int) (*types.Transaction, error)

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

+ func (_OmniGasPump *OmniGasPumpTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpTransactor) Withdraw(opts *bind.TransactOpts, to common.Address) (*types.Transaction, error)

+ type OmniGasPumpTransactorRaw struct

+ Contract *OmniGasPumpTransactor

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

+ func (_OmniGasPump *OmniGasPumpTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OmniGasPumpTransactorSession struct

+ Contract *OmniGasPumpTransactor

+ TransactOpts bind.TransactOpts

+ func (_OmniGasPump *OmniGasPumpTransactorSession) FillUp(recipient common.Address) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpTransactorSession) Initialize(p OmniGasPumpInitParams) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpTransactorSession) Pause() (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpTransactorSession) SetGasStation(station common.Address) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpTransactorSession) SetMaxSwap(max *big.Int) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpTransactorSession) SetOracle(oracle_ common.Address) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpTransactorSession) SetToll(pct *big.Int) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpTransactorSession) Unpause() (*types.Transaction, error)

+ func (_OmniGasPump *OmniGasPumpTransactorSession) Withdraw(to common.Address) (*types.Transaction, error)

+ type OmniGasPumpUnpaused struct

+ Account common.Address

+ Raw types.Log

+ type OmniGasPumpUnpausedIterator struct

+ Event *OmniGasPumpUnpaused

+ func (it *OmniGasPumpUnpausedIterator) Close() error

+ func (it *OmniGasPumpUnpausedIterator) Error() error

+ func (it *OmniGasPumpUnpausedIterator) Next() bool

+ type OmniGasStation struct

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

+ func NewOmniGasStation(address common.Address, backend bind.ContractBackend) (*OmniGasStation, error)

+ type OmniGasStationCaller struct

+ func NewOmniGasStationCaller(address common.Address, caller bind.ContractCaller) (*OmniGasStationCaller, error)

+ func (_OmniGasStation *OmniGasStationCaller) DefaultConfLevel(opts *bind.CallOpts) (uint8, error)

+ func (_OmniGasStation *OmniGasStationCaller) Fueled(opts *bind.CallOpts, arg0 common.Address, arg1 uint64) (*big.Int, error)

+ func (_OmniGasStation *OmniGasStationCaller) IsPump(opts *bind.CallOpts, chainID uint64, addr common.Address) (bool, error)

+ func (_OmniGasStation *OmniGasStationCaller) Omni(opts *bind.CallOpts) (common.Address, error)

+ func (_OmniGasStation *OmniGasStationCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_OmniGasStation *OmniGasStationCaller) Paused(opts *bind.CallOpts) (bool, error)

+ func (_OmniGasStation *OmniGasStationCaller) Pumps(opts *bind.CallOpts, arg0 uint64) (common.Address, error)

+ type OmniGasStationCallerRaw struct

+ Contract *OmniGasStationCaller

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

+ type OmniGasStationCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OmniGasStationCaller

+ func (_OmniGasStation *OmniGasStationCallerSession) DefaultConfLevel() (uint8, error)

+ func (_OmniGasStation *OmniGasStationCallerSession) Fueled(arg0 common.Address, arg1 uint64) (*big.Int, error)

+ func (_OmniGasStation *OmniGasStationCallerSession) IsPump(chainID uint64, addr common.Address) (bool, error)

+ func (_OmniGasStation *OmniGasStationCallerSession) Omni() (common.Address, error)

+ func (_OmniGasStation *OmniGasStationCallerSession) Owner() (common.Address, error)

+ func (_OmniGasStation *OmniGasStationCallerSession) Paused() (bool, error)

+ func (_OmniGasStation *OmniGasStationCallerSession) Pumps(arg0 uint64) (common.Address, error)

+ type OmniGasStationDefaultConfLevelSet struct

+ Conf uint8

+ Raw types.Log

+ type OmniGasStationDefaultConfLevelSetIterator struct

+ Event *OmniGasStationDefaultConfLevelSet

+ func (it *OmniGasStationDefaultConfLevelSetIterator) Close() error

+ func (it *OmniGasStationDefaultConfLevelSetIterator) Error() error

+ func (it *OmniGasStationDefaultConfLevelSetIterator) Next() bool

+ type OmniGasStationFilterer struct

+ func NewOmniGasStationFilterer(address common.Address, filterer bind.ContractFilterer) (*OmniGasStationFilterer, error)

+ func (_OmniGasStation *OmniGasStationFilterer) FilterDefaultConfLevelSet(opts *bind.FilterOpts) (*OmniGasStationDefaultConfLevelSetIterator, error)

+ func (_OmniGasStation *OmniGasStationFilterer) FilterGasPumpAdded(opts *bind.FilterOpts, chainID []uint64) (*OmniGasStationGasPumpAddedIterator, error)

+ func (_OmniGasStation *OmniGasStationFilterer) FilterInitialized(opts *bind.FilterOpts) (*OmniGasStationInitializedIterator, error)

+ func (_OmniGasStation *OmniGasStationFilterer) FilterOmniPortalSet(opts *bind.FilterOpts) (*OmniGasStationOmniPortalSetIterator, error)

+ func (_OmniGasStation *OmniGasStationFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*OmniGasStationOwnershipTransferredIterator, error)

+ func (_OmniGasStation *OmniGasStationFilterer) FilterPaused(opts *bind.FilterOpts) (*OmniGasStationPausedIterator, error)

+ func (_OmniGasStation *OmniGasStationFilterer) FilterSettledUp(opts *bind.FilterOpts, recipient []common.Address, chainID []uint64) (*OmniGasStationSettledUpIterator, error)

+ func (_OmniGasStation *OmniGasStationFilterer) FilterUnpaused(opts *bind.FilterOpts) (*OmniGasStationUnpausedIterator, error)

+ func (_OmniGasStation *OmniGasStationFilterer) ParseDefaultConfLevelSet(log types.Log) (*OmniGasStationDefaultConfLevelSet, error)

+ func (_OmniGasStation *OmniGasStationFilterer) ParseGasPumpAdded(log types.Log) (*OmniGasStationGasPumpAdded, error)

+ func (_OmniGasStation *OmniGasStationFilterer) ParseInitialized(log types.Log) (*OmniGasStationInitialized, error)

+ func (_OmniGasStation *OmniGasStationFilterer) ParseOmniPortalSet(log types.Log) (*OmniGasStationOmniPortalSet, error)

+ func (_OmniGasStation *OmniGasStationFilterer) ParseOwnershipTransferred(log types.Log) (*OmniGasStationOwnershipTransferred, error)

+ func (_OmniGasStation *OmniGasStationFilterer) ParsePaused(log types.Log) (*OmniGasStationPaused, error)

+ func (_OmniGasStation *OmniGasStationFilterer) ParseSettledUp(log types.Log) (*OmniGasStationSettledUp, error)

+ func (_OmniGasStation *OmniGasStationFilterer) ParseUnpaused(log types.Log) (*OmniGasStationUnpaused, error)

+ func (_OmniGasStation *OmniGasStationFilterer) WatchDefaultConfLevelSet(opts *bind.WatchOpts, sink chan<- *OmniGasStationDefaultConfLevelSet) (event.Subscription, error)

+ func (_OmniGasStation *OmniGasStationFilterer) WatchGasPumpAdded(opts *bind.WatchOpts, sink chan<- *OmniGasStationGasPumpAdded, ...) (event.Subscription, error)

+ func (_OmniGasStation *OmniGasStationFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *OmniGasStationInitialized) (event.Subscription, error)

+ func (_OmniGasStation *OmniGasStationFilterer) WatchOmniPortalSet(opts *bind.WatchOpts, sink chan<- *OmniGasStationOmniPortalSet) (event.Subscription, error)

+ func (_OmniGasStation *OmniGasStationFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OmniGasStationOwnershipTransferred, ...) (event.Subscription, error)

+ func (_OmniGasStation *OmniGasStationFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *OmniGasStationPaused) (event.Subscription, error)

+ func (_OmniGasStation *OmniGasStationFilterer) WatchSettledUp(opts *bind.WatchOpts, sink chan<- *OmniGasStationSettledUp, ...) (event.Subscription, error)

+ func (_OmniGasStation *OmniGasStationFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *OmniGasStationUnpaused) (event.Subscription, error)

+ type OmniGasStationGasPump struct

+ Addr common.Address

+ ChainID uint64

+ type OmniGasStationGasPumpAdded struct

+ Addr common.Address

+ ChainID uint64

+ Raw types.Log

+ type OmniGasStationGasPumpAddedIterator struct

+ Event *OmniGasStationGasPumpAdded

+ func (it *OmniGasStationGasPumpAddedIterator) Close() error

+ func (it *OmniGasStationGasPumpAddedIterator) Error() error

+ func (it *OmniGasStationGasPumpAddedIterator) Next() bool

+ type OmniGasStationInitialized struct

+ Raw types.Log

+ Version uint64

+ type OmniGasStationInitializedIterator struct

+ Event *OmniGasStationInitialized

+ func (it *OmniGasStationInitializedIterator) Close() error

+ func (it *OmniGasStationInitializedIterator) Error() error

+ func (it *OmniGasStationInitializedIterator) Next() bool

+ type OmniGasStationOmniPortalSet struct

+ Omni common.Address

+ Raw types.Log

+ type OmniGasStationOmniPortalSetIterator struct

+ Event *OmniGasStationOmniPortalSet

+ func (it *OmniGasStationOmniPortalSetIterator) Close() error

+ func (it *OmniGasStationOmniPortalSetIterator) Error() error

+ func (it *OmniGasStationOmniPortalSetIterator) Next() bool

+ type OmniGasStationOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type OmniGasStationOwnershipTransferredIterator struct

+ Event *OmniGasStationOwnershipTransferred

+ func (it *OmniGasStationOwnershipTransferredIterator) Close() error

+ func (it *OmniGasStationOwnershipTransferredIterator) Error() error

+ func (it *OmniGasStationOwnershipTransferredIterator) Next() bool

+ type OmniGasStationPaused struct

+ Account common.Address

+ Raw types.Log

+ type OmniGasStationPausedIterator struct

+ Event *OmniGasStationPaused

+ func (it *OmniGasStationPausedIterator) Close() error

+ func (it *OmniGasStationPausedIterator) Error() error

+ func (it *OmniGasStationPausedIterator) Next() bool

+ type OmniGasStationRaw struct

+ Contract *OmniGasStation

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

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

+ func (_OmniGasStation *OmniGasStationRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OmniGasStationSession struct

+ CallOpts bind.CallOpts

+ Contract *OmniGasStation

+ TransactOpts bind.TransactOpts

+ func (_OmniGasStation *OmniGasStationSession) DefaultConfLevel() (uint8, error)

+ func (_OmniGasStation *OmniGasStationSession) Fueled(arg0 common.Address, arg1 uint64) (*big.Int, error)

+ func (_OmniGasStation *OmniGasStationSession) Initialize(portal common.Address, owner common.Address, pumps_ []OmniGasStationGasPump) (*types.Transaction, error)

+ func (_OmniGasStation *OmniGasStationSession) IsPump(chainID uint64, addr common.Address) (bool, error)

+ func (_OmniGasStation *OmniGasStationSession) Omni() (common.Address, error)

+ func (_OmniGasStation *OmniGasStationSession) Owner() (common.Address, error)

+ func (_OmniGasStation *OmniGasStationSession) Pause() (*types.Transaction, error)

+ func (_OmniGasStation *OmniGasStationSession) Paused() (bool, error)

+ func (_OmniGasStation *OmniGasStationSession) Pumps(arg0 uint64) (common.Address, error)

+ func (_OmniGasStation *OmniGasStationSession) Receive() (*types.Transaction, error)

+ func (_OmniGasStation *OmniGasStationSession) RenounceOwnership() (*types.Transaction, error)

+ func (_OmniGasStation *OmniGasStationSession) SetPump(chainId uint64, addr common.Address) (*types.Transaction, error)

+ func (_OmniGasStation *OmniGasStationSession) SettleUp(recipient common.Address, owed *big.Int) (*types.Transaction, error)

+ func (_OmniGasStation *OmniGasStationSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_OmniGasStation *OmniGasStationSession) Unpause() (*types.Transaction, error)

+ type OmniGasStationSettledUp struct

+ ChainID uint64

+ Fueled *big.Int

+ Owed *big.Int

+ Raw types.Log

+ Recipient common.Address

+ Success bool

+ type OmniGasStationSettledUpIterator struct

+ Event *OmniGasStationSettledUp

+ func (it *OmniGasStationSettledUpIterator) Close() error

+ func (it *OmniGasStationSettledUpIterator) Error() error

+ func (it *OmniGasStationSettledUpIterator) Next() bool

+ type OmniGasStationTransactor struct

+ func NewOmniGasStationTransactor(address common.Address, transactor bind.ContractTransactor) (*OmniGasStationTransactor, error)

+ func (_OmniGasStation *OmniGasStationTransactor) Initialize(opts *bind.TransactOpts, portal common.Address, owner common.Address, ...) (*types.Transaction, error)

+ func (_OmniGasStation *OmniGasStationTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniGasStation *OmniGasStationTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniGasStation *OmniGasStationTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniGasStation *OmniGasStationTransactor) SetPump(opts *bind.TransactOpts, chainId uint64, addr common.Address) (*types.Transaction, error)

+ func (_OmniGasStation *OmniGasStationTransactor) SettleUp(opts *bind.TransactOpts, recipient common.Address, owed *big.Int) (*types.Transaction, error)

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

+ func (_OmniGasStation *OmniGasStationTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OmniGasStationTransactorRaw struct

+ Contract *OmniGasStationTransactor

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

+ func (_OmniGasStation *OmniGasStationTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OmniGasStationTransactorSession struct

+ Contract *OmniGasStationTransactor

+ TransactOpts bind.TransactOpts

+ func (_OmniGasStation *OmniGasStationTransactorSession) Initialize(portal common.Address, owner common.Address, pumps_ []OmniGasStationGasPump) (*types.Transaction, error)

+ func (_OmniGasStation *OmniGasStationTransactorSession) Pause() (*types.Transaction, error)

+ func (_OmniGasStation *OmniGasStationTransactorSession) Receive() (*types.Transaction, error)

+ func (_OmniGasStation *OmniGasStationTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_OmniGasStation *OmniGasStationTransactorSession) SetPump(chainId uint64, addr common.Address) (*types.Transaction, error)

+ func (_OmniGasStation *OmniGasStationTransactorSession) SettleUp(recipient common.Address, owed *big.Int) (*types.Transaction, error)

+ func (_OmniGasStation *OmniGasStationTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_OmniGasStation *OmniGasStationTransactorSession) Unpause() (*types.Transaction, error)

+ type OmniGasStationUnpaused struct

+ Account common.Address

+ Raw types.Log

+ type OmniGasStationUnpausedIterator struct

+ Event *OmniGasStationUnpaused

+ func (it *OmniGasStationUnpausedIterator) Close() error

+ func (it *OmniGasStationUnpausedIterator) Error() error

+ func (it *OmniGasStationUnpausedIterator) Next() bool

+ type OmniPortal struct

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

+ func NewOmniPortal(address common.Address, backend bind.ContractBackend) (*OmniPortal, error)

+ type OmniPortalCaller struct

+ func NewOmniPortalCaller(address common.Address, caller bind.ContractCaller) (*OmniPortalCaller, error)

+ func (_OmniPortal *OmniPortalCaller) ActionXCall(opts *bind.CallOpts) ([32]byte, error)

+ func (_OmniPortal *OmniPortalCaller) ActionXSubmit(opts *bind.CallOpts) ([32]byte, error)

+ func (_OmniPortal *OmniPortalCaller) ChainId(opts *bind.CallOpts) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) FeeFor(opts *bind.CallOpts, destChainId uint64, data []byte, gasLimit uint64) (*big.Int, error)

+ func (_OmniPortal *OmniPortalCaller) FeeOracle(opts *bind.CallOpts) (common.Address, error)

+ func (_OmniPortal *OmniPortalCaller) InXBlockOffset(opts *bind.CallOpts, arg0 uint64, arg1 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) InXMsgOffset(opts *bind.CallOpts, arg0 uint64, arg1 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) IsPaused(opts *bind.CallOpts, actionId [32]byte) (bool, error)

+ func (_OmniPortal *OmniPortalCaller) IsPaused0(opts *bind.CallOpts, actionId [32]byte, chainId_ uint64) (bool, error)

+ func (_OmniPortal *OmniPortalCaller) IsPaused1(opts *bind.CallOpts) (bool, error)

+ func (_OmniPortal *OmniPortalCaller) IsSupportedDest(opts *bind.CallOpts, arg0 uint64) (bool, error)

+ func (_OmniPortal *OmniPortalCaller) IsSupportedShard(opts *bind.CallOpts, arg0 uint64) (bool, error)

+ func (_OmniPortal *OmniPortalCaller) IsXCall(opts *bind.CallOpts) (bool, error)

+ func (_OmniPortal *OmniPortalCaller) KeyPauseAll(opts *bind.CallOpts) ([32]byte, error)

+ func (_OmniPortal *OmniPortalCaller) LatestValSetId(opts *bind.CallOpts) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) Network(opts *bind.CallOpts, arg0 *big.Int) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) OmniCChainId(opts *bind.CallOpts) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) OmniChainId(opts *bind.CallOpts) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) OutXMsgOffset(opts *bind.CallOpts, arg0 uint64, arg1 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_OmniPortal *OmniPortalCaller) ValSet(opts *bind.CallOpts, arg0 uint64, arg1 common.Address) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) ValSetTotalPower(opts *bind.CallOpts, arg0 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) XSubQuorumDenominator(opts *bind.CallOpts) (uint8, error)

+ func (_OmniPortal *OmniPortalCaller) XSubQuorumNumerator(opts *bind.CallOpts) (uint8, error)

+ func (_OmniPortal *OmniPortalCaller) Xmsg(opts *bind.CallOpts) (XTypesMsgContext, error)

+ func (_OmniPortal *OmniPortalCaller) XmsgMaxDataSize(opts *bind.CallOpts) (uint16, error)

+ func (_OmniPortal *OmniPortalCaller) XmsgMaxGasLimit(opts *bind.CallOpts) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) XmsgMinGasLimit(opts *bind.CallOpts) (uint64, error)

+ func (_OmniPortal *OmniPortalCaller) XreceiptMaxErrorSize(opts *bind.CallOpts) (uint16, error)

+ func (_OmniPortal *OmniPortalCaller) XsubValsetCutoff(opts *bind.CallOpts) (uint8, error)

+ type OmniPortalCallerRaw struct

+ Contract *OmniPortalCaller

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

+ type OmniPortalCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OmniPortalCaller

+ func (_OmniPortal *OmniPortalCallerSession) ActionXCall() ([32]byte, error)

+ func (_OmniPortal *OmniPortalCallerSession) ActionXSubmit() ([32]byte, error)

+ func (_OmniPortal *OmniPortalCallerSession) ChainId() (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) FeeFor(destChainId uint64, data []byte, gasLimit uint64) (*big.Int, error)

+ func (_OmniPortal *OmniPortalCallerSession) FeeOracle() (common.Address, error)

+ func (_OmniPortal *OmniPortalCallerSession) InXBlockOffset(arg0 uint64, arg1 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) InXMsgOffset(arg0 uint64, arg1 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) IsPaused(actionId [32]byte) (bool, error)

+ func (_OmniPortal *OmniPortalCallerSession) IsPaused0(actionId [32]byte, chainId_ uint64) (bool, error)

+ func (_OmniPortal *OmniPortalCallerSession) IsPaused1() (bool, error)

+ func (_OmniPortal *OmniPortalCallerSession) IsSupportedDest(arg0 uint64) (bool, error)

+ func (_OmniPortal *OmniPortalCallerSession) IsSupportedShard(arg0 uint64) (bool, error)

+ func (_OmniPortal *OmniPortalCallerSession) IsXCall() (bool, error)

+ func (_OmniPortal *OmniPortalCallerSession) KeyPauseAll() ([32]byte, error)

+ func (_OmniPortal *OmniPortalCallerSession) LatestValSetId() (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) Network(arg0 *big.Int) (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) OmniCChainId() (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) OmniChainId() (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) OutXMsgOffset(arg0 uint64, arg1 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) Owner() (common.Address, error)

+ func (_OmniPortal *OmniPortalCallerSession) ValSet(arg0 uint64, arg1 common.Address) (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) ValSetTotalPower(arg0 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) XSubQuorumDenominator() (uint8, error)

+ func (_OmniPortal *OmniPortalCallerSession) XSubQuorumNumerator() (uint8, error)

+ func (_OmniPortal *OmniPortalCallerSession) Xmsg() (XTypesMsgContext, error)

+ func (_OmniPortal *OmniPortalCallerSession) XmsgMaxDataSize() (uint16, error)

+ func (_OmniPortal *OmniPortalCallerSession) XmsgMaxGasLimit() (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) XmsgMinGasLimit() (uint64, error)

+ func (_OmniPortal *OmniPortalCallerSession) XreceiptMaxErrorSize() (uint16, error)

+ func (_OmniPortal *OmniPortalCallerSession) XsubValsetCutoff() (uint8, error)

+ type OmniPortalFeeOracleSet struct

+ Oracle common.Address

+ Raw types.Log

+ type OmniPortalFeeOracleSetIterator struct

+ Event *OmniPortalFeeOracleSet

+ func (it *OmniPortalFeeOracleSetIterator) Close() error

+ func (it *OmniPortalFeeOracleSetIterator) Error() error

+ func (it *OmniPortalFeeOracleSetIterator) Next() bool

+ type OmniPortalFeesCollected struct

+ Amount *big.Int

+ Raw types.Log

+ To common.Address

+ type OmniPortalFeesCollectedIterator struct

+ Event *OmniPortalFeesCollected

+ func (it *OmniPortalFeesCollectedIterator) Close() error

+ func (it *OmniPortalFeesCollectedIterator) Error() error

+ func (it *OmniPortalFeesCollectedIterator) Next() bool

+ type OmniPortalFilterer struct

+ func NewOmniPortalFilterer(address common.Address, filterer bind.ContractFilterer) (*OmniPortalFilterer, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterFeeOracleSet(opts *bind.FilterOpts) (*OmniPortalFeeOracleSetIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterFeesCollected(opts *bind.FilterOpts, to []common.Address) (*OmniPortalFeesCollectedIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterInXBlockOffsetSet(opts *bind.FilterOpts, srcChainId []uint64, shardId []uint64) (*OmniPortalInXBlockOffsetSetIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterInXMsgOffsetSet(opts *bind.FilterOpts, srcChainId []uint64, shardId []uint64) (*OmniPortalInXMsgOffsetSetIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterInitialized(opts *bind.FilterOpts) (*OmniPortalInitializedIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*OmniPortalOwnershipTransferredIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterPaused(opts *bind.FilterOpts) (*OmniPortalPausedIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterPaused0(opts *bind.FilterOpts, key [][32]byte) (*OmniPortalPaused0Iterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterUnpaused(opts *bind.FilterOpts) (*OmniPortalUnpausedIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterUnpaused0(opts *bind.FilterOpts, key [][32]byte) (*OmniPortalUnpaused0Iterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterValidatorSetAdded(opts *bind.FilterOpts, setId []uint64) (*OmniPortalValidatorSetAddedIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterXCallPaused(opts *bind.FilterOpts) (*OmniPortalXCallPausedIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterXCallToPaused(opts *bind.FilterOpts, chainId []uint64) (*OmniPortalXCallToPausedIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterXCallToUnpaused(opts *bind.FilterOpts, chainId []uint64) (*OmniPortalXCallToUnpausedIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterXCallUnpaused(opts *bind.FilterOpts) (*OmniPortalXCallUnpausedIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterXMsg(opts *bind.FilterOpts, destChainId []uint64, shardId []uint64, offset []uint64) (*OmniPortalXMsgIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterXMsgMaxDataSizeSet(opts *bind.FilterOpts) (*OmniPortalXMsgMaxDataSizeSetIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterXMsgMaxGasLimitSet(opts *bind.FilterOpts) (*OmniPortalXMsgMaxGasLimitSetIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterXMsgMinGasLimitSet(opts *bind.FilterOpts) (*OmniPortalXMsgMinGasLimitSetIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterXReceipt(opts *bind.FilterOpts, sourceChainId []uint64, shardId []uint64, ...) (*OmniPortalXReceiptIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterXReceiptMaxErrorSizeSet(opts *bind.FilterOpts) (*OmniPortalXReceiptMaxErrorSizeSetIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterXSubValsetCutoffSet(opts *bind.FilterOpts) (*OmniPortalXSubValsetCutoffSetIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterXSubmitFromPaused(opts *bind.FilterOpts, chainId []uint64) (*OmniPortalXSubmitFromPausedIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterXSubmitFromUnpaused(opts *bind.FilterOpts, chainId []uint64) (*OmniPortalXSubmitFromUnpausedIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterXSubmitPaused(opts *bind.FilterOpts) (*OmniPortalXSubmitPausedIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) FilterXSubmitUnpaused(opts *bind.FilterOpts) (*OmniPortalXSubmitUnpausedIterator, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseFeeOracleSet(log types.Log) (*OmniPortalFeeOracleSet, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseFeesCollected(log types.Log) (*OmniPortalFeesCollected, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseInXBlockOffsetSet(log types.Log) (*OmniPortalInXBlockOffsetSet, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseInXMsgOffsetSet(log types.Log) (*OmniPortalInXMsgOffsetSet, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseInitialized(log types.Log) (*OmniPortalInitialized, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseOwnershipTransferred(log types.Log) (*OmniPortalOwnershipTransferred, error)

+ func (_OmniPortal *OmniPortalFilterer) ParsePaused(log types.Log) (*OmniPortalPaused, error)

+ func (_OmniPortal *OmniPortalFilterer) ParsePaused0(log types.Log) (*OmniPortalPaused0, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseUnpaused(log types.Log) (*OmniPortalUnpaused, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseUnpaused0(log types.Log) (*OmniPortalUnpaused0, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseValidatorSetAdded(log types.Log) (*OmniPortalValidatorSetAdded, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseXCallPaused(log types.Log) (*OmniPortalXCallPaused, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseXCallToPaused(log types.Log) (*OmniPortalXCallToPaused, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseXCallToUnpaused(log types.Log) (*OmniPortalXCallToUnpaused, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseXCallUnpaused(log types.Log) (*OmniPortalXCallUnpaused, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseXMsg(log types.Log) (*OmniPortalXMsg, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseXMsgMaxDataSizeSet(log types.Log) (*OmniPortalXMsgMaxDataSizeSet, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseXMsgMaxGasLimitSet(log types.Log) (*OmniPortalXMsgMaxGasLimitSet, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseXMsgMinGasLimitSet(log types.Log) (*OmniPortalXMsgMinGasLimitSet, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseXReceipt(log types.Log) (*OmniPortalXReceipt, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseXReceiptMaxErrorSizeSet(log types.Log) (*OmniPortalXReceiptMaxErrorSizeSet, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseXSubValsetCutoffSet(log types.Log) (*OmniPortalXSubValsetCutoffSet, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseXSubmitFromPaused(log types.Log) (*OmniPortalXSubmitFromPaused, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseXSubmitFromUnpaused(log types.Log) (*OmniPortalXSubmitFromUnpaused, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseXSubmitPaused(log types.Log) (*OmniPortalXSubmitPaused, error)

+ func (_OmniPortal *OmniPortalFilterer) ParseXSubmitUnpaused(log types.Log) (*OmniPortalXSubmitUnpaused, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchFeeOracleSet(opts *bind.WatchOpts, sink chan<- *OmniPortalFeeOracleSet) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchFeesCollected(opts *bind.WatchOpts, sink chan<- *OmniPortalFeesCollected, ...) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchInXBlockOffsetSet(opts *bind.WatchOpts, sink chan<- *OmniPortalInXBlockOffsetSet, ...) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchInXMsgOffsetSet(opts *bind.WatchOpts, sink chan<- *OmniPortalInXMsgOffsetSet, ...) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *OmniPortalInitialized) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OmniPortalOwnershipTransferred, ...) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *OmniPortalPaused) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchPaused0(opts *bind.WatchOpts, sink chan<- *OmniPortalPaused0, key [][32]byte) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *OmniPortalUnpaused) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchUnpaused0(opts *bind.WatchOpts, sink chan<- *OmniPortalUnpaused0, key [][32]byte) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchValidatorSetAdded(opts *bind.WatchOpts, sink chan<- *OmniPortalValidatorSetAdded, setId []uint64) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchXCallPaused(opts *bind.WatchOpts, sink chan<- *OmniPortalXCallPaused) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchXCallToPaused(opts *bind.WatchOpts, sink chan<- *OmniPortalXCallToPaused, chainId []uint64) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchXCallToUnpaused(opts *bind.WatchOpts, sink chan<- *OmniPortalXCallToUnpaused, chainId []uint64) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchXCallUnpaused(opts *bind.WatchOpts, sink chan<- *OmniPortalXCallUnpaused) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchXMsg(opts *bind.WatchOpts, sink chan<- *OmniPortalXMsg, destChainId []uint64, ...) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchXMsgMaxDataSizeSet(opts *bind.WatchOpts, sink chan<- *OmniPortalXMsgMaxDataSizeSet) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchXMsgMaxGasLimitSet(opts *bind.WatchOpts, sink chan<- *OmniPortalXMsgMaxGasLimitSet) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchXMsgMinGasLimitSet(opts *bind.WatchOpts, sink chan<- *OmniPortalXMsgMinGasLimitSet) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchXReceipt(opts *bind.WatchOpts, sink chan<- *OmniPortalXReceipt, sourceChainId []uint64, ...) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchXReceiptMaxErrorSizeSet(opts *bind.WatchOpts, sink chan<- *OmniPortalXReceiptMaxErrorSizeSet) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchXSubValsetCutoffSet(opts *bind.WatchOpts, sink chan<- *OmniPortalXSubValsetCutoffSet) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchXSubmitFromPaused(opts *bind.WatchOpts, sink chan<- *OmniPortalXSubmitFromPaused, ...) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchXSubmitFromUnpaused(opts *bind.WatchOpts, sink chan<- *OmniPortalXSubmitFromUnpaused, ...) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchXSubmitPaused(opts *bind.WatchOpts, sink chan<- *OmniPortalXSubmitPaused) (event.Subscription, error)

+ func (_OmniPortal *OmniPortalFilterer) WatchXSubmitUnpaused(opts *bind.WatchOpts, sink chan<- *OmniPortalXSubmitUnpaused) (event.Subscription, error)

+ type OmniPortalInXBlockOffsetSet struct

+ Offset uint64

+ Raw types.Log

+ ShardId uint64

+ SrcChainId uint64

+ type OmniPortalInXBlockOffsetSetIterator struct

+ Event *OmniPortalInXBlockOffsetSet

+ func (it *OmniPortalInXBlockOffsetSetIterator) Close() error

+ func (it *OmniPortalInXBlockOffsetSetIterator) Error() error

+ func (it *OmniPortalInXBlockOffsetSetIterator) Next() bool

+ type OmniPortalInXMsgOffsetSet struct

+ Offset uint64

+ Raw types.Log

+ ShardId uint64

+ SrcChainId uint64

+ type OmniPortalInXMsgOffsetSetIterator struct

+ Event *OmniPortalInXMsgOffsetSet

+ func (it *OmniPortalInXMsgOffsetSetIterator) Close() error

+ func (it *OmniPortalInXMsgOffsetSetIterator) Error() error

+ func (it *OmniPortalInXMsgOffsetSetIterator) Next() bool

+ type OmniPortalInitParams struct

+ CChainXBlockOffset uint64

+ CChainXMsgOffset uint64

+ FeeOracle common.Address

+ OmniCChainId uint64

+ OmniChainId uint64

+ Owner common.Address

+ ValSetId uint64

+ Validators []XTypesValidator

+ XmsgMaxDataSize uint16

+ XmsgMaxGasLimit uint64

+ XmsgMinGasLimit uint64

+ XreceiptMaxErrorSize uint16

+ XsubValsetCutoff uint8

+ type OmniPortalInitialized struct

+ Raw types.Log

+ Version uint64

+ type OmniPortalInitializedIterator struct

+ Event *OmniPortalInitialized

+ func (it *OmniPortalInitializedIterator) Close() error

+ func (it *OmniPortalInitializedIterator) Error() error

+ func (it *OmniPortalInitializedIterator) Next() bool

+ type OmniPortalOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type OmniPortalOwnershipTransferredIterator struct

+ Event *OmniPortalOwnershipTransferred

+ func (it *OmniPortalOwnershipTransferredIterator) Close() error

+ func (it *OmniPortalOwnershipTransferredIterator) Error() error

+ func (it *OmniPortalOwnershipTransferredIterator) Next() bool

+ type OmniPortalPaused struct

+ Raw types.Log

+ type OmniPortalPaused0 struct

+ Key [32]byte

+ Raw types.Log

+ type OmniPortalPaused0Iterator struct

+ Event *OmniPortalPaused0

+ func (it *OmniPortalPaused0Iterator) Close() error

+ func (it *OmniPortalPaused0Iterator) Error() error

+ func (it *OmniPortalPaused0Iterator) Next() bool

+ type OmniPortalPausedIterator struct

+ Event *OmniPortalPaused

+ func (it *OmniPortalPausedIterator) Close() error

+ func (it *OmniPortalPausedIterator) Error() error

+ func (it *OmniPortalPausedIterator) Next() bool

+ type OmniPortalRaw struct

+ Contract *OmniPortal

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

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

+ func (_OmniPortal *OmniPortalRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OmniPortalSession struct

+ CallOpts bind.CallOpts

+ Contract *OmniPortal

+ TransactOpts bind.TransactOpts

+ func (_OmniPortal *OmniPortalSession) ActionXCall() ([32]byte, error)

+ func (_OmniPortal *OmniPortalSession) ActionXSubmit() ([32]byte, error)

+ func (_OmniPortal *OmniPortalSession) AddValidatorSet(valSetId uint64, validators []XTypesValidator) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) ChainId() (uint64, error)

+ func (_OmniPortal *OmniPortalSession) CollectFees(to common.Address) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) FeeFor(destChainId uint64, data []byte, gasLimit uint64) (*big.Int, error)

+ func (_OmniPortal *OmniPortalSession) FeeOracle() (common.Address, error)

+ func (_OmniPortal *OmniPortalSession) InXBlockOffset(arg0 uint64, arg1 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalSession) InXMsgOffset(arg0 uint64, arg1 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalSession) Initialize(p OmniPortalInitParams) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) IsPaused(actionId [32]byte) (bool, error)

+ func (_OmniPortal *OmniPortalSession) IsPaused0(actionId [32]byte, chainId_ uint64) (bool, error)

+ func (_OmniPortal *OmniPortalSession) IsPaused1() (bool, error)

+ func (_OmniPortal *OmniPortalSession) IsSupportedDest(arg0 uint64) (bool, error)

+ func (_OmniPortal *OmniPortalSession) IsSupportedShard(arg0 uint64) (bool, error)

+ func (_OmniPortal *OmniPortalSession) IsXCall() (bool, error)

+ func (_OmniPortal *OmniPortalSession) KeyPauseAll() ([32]byte, error)

+ func (_OmniPortal *OmniPortalSession) LatestValSetId() (uint64, error)

+ func (_OmniPortal *OmniPortalSession) Network(arg0 *big.Int) (uint64, error)

+ func (_OmniPortal *OmniPortalSession) OmniCChainId() (uint64, error)

+ func (_OmniPortal *OmniPortalSession) OmniChainId() (uint64, error)

+ func (_OmniPortal *OmniPortalSession) OutXMsgOffset(arg0 uint64, arg1 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalSession) Owner() (common.Address, error)

+ func (_OmniPortal *OmniPortalSession) Pause() (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) PauseXCall() (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) PauseXCallTo(chainId_ uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) PauseXSubmit() (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) PauseXSubmitFrom(chainId_ uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) RenounceOwnership() (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) SetFeeOracle(feeOracle_ common.Address) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) SetInXBlockOffset(sourceChainId uint64, shardId uint64, offset uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) SetInXMsgOffset(sourceChainId uint64, shardId uint64, offset uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) SetNetwork(network_ []XTypesChain) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) SetXMsgMaxDataSize(numBytes uint16) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) SetXMsgMaxGasLimit(gasLimit uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) SetXMsgMinGasLimit(gasLimit uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) SetXReceiptMaxErrorSize(numBytes uint16) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) SetXSubValsetCutoff(xsubValsetCutoff_ uint8) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) Unpause() (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) UnpauseXCall() (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) UnpauseXCallTo(chainId_ uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) UnpauseXSubmit() (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) UnpauseXSubmitFrom(chainId_ uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) ValSet(arg0 uint64, arg1 common.Address) (uint64, error)

+ func (_OmniPortal *OmniPortalSession) ValSetTotalPower(arg0 uint64) (uint64, error)

+ func (_OmniPortal *OmniPortalSession) XSubQuorumDenominator() (uint8, error)

+ func (_OmniPortal *OmniPortalSession) XSubQuorumNumerator() (uint8, error)

+ func (_OmniPortal *OmniPortalSession) Xcall(destChainId uint64, conf uint8, to common.Address, data []byte, ...) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalSession) Xmsg() (XTypesMsgContext, error)

+ func (_OmniPortal *OmniPortalSession) XmsgMaxDataSize() (uint16, error)

+ func (_OmniPortal *OmniPortalSession) XmsgMaxGasLimit() (uint64, error)

+ func (_OmniPortal *OmniPortalSession) XmsgMinGasLimit() (uint64, error)

+ func (_OmniPortal *OmniPortalSession) XreceiptMaxErrorSize() (uint16, error)

+ func (_OmniPortal *OmniPortalSession) XsubValsetCutoff() (uint8, error)

+ func (_OmniPortal *OmniPortalSession) Xsubmit(xsub XTypesSubmission) (*types.Transaction, error)

+ type OmniPortalTransactor struct

+ func NewOmniPortalTransactor(address common.Address, transactor bind.ContractTransactor) (*OmniPortalTransactor, error)

+ func (_OmniPortal *OmniPortalTransactor) AddValidatorSet(opts *bind.TransactOpts, valSetId uint64, validators []XTypesValidator) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) CollectFees(opts *bind.TransactOpts, to common.Address) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) Initialize(opts *bind.TransactOpts, p OmniPortalInitParams) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) PauseXCall(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) PauseXCallTo(opts *bind.TransactOpts, chainId_ uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) PauseXSubmit(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) PauseXSubmitFrom(opts *bind.TransactOpts, chainId_ uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) SetFeeOracle(opts *bind.TransactOpts, feeOracle_ common.Address) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) SetInXBlockOffset(opts *bind.TransactOpts, sourceChainId uint64, shardId uint64, offset uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) SetInXMsgOffset(opts *bind.TransactOpts, sourceChainId uint64, shardId uint64, offset uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) SetNetwork(opts *bind.TransactOpts, network_ []XTypesChain) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) SetXMsgMaxDataSize(opts *bind.TransactOpts, numBytes uint16) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) SetXMsgMaxGasLimit(opts *bind.TransactOpts, gasLimit uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) SetXMsgMinGasLimit(opts *bind.TransactOpts, gasLimit uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) SetXReceiptMaxErrorSize(opts *bind.TransactOpts, numBytes uint16) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) SetXSubValsetCutoff(opts *bind.TransactOpts, xsubValsetCutoff_ uint8) (*types.Transaction, error)

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

+ func (_OmniPortal *OmniPortalTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) UnpauseXCall(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) UnpauseXCallTo(opts *bind.TransactOpts, chainId_ uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) UnpauseXSubmit(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) UnpauseXSubmitFrom(opts *bind.TransactOpts, chainId_ uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) Xcall(opts *bind.TransactOpts, destChainId uint64, conf uint8, to common.Address, ...) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactor) Xsubmit(opts *bind.TransactOpts, xsub XTypesSubmission) (*types.Transaction, error)

+ type OmniPortalTransactorRaw struct

+ Contract *OmniPortalTransactor

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

+ func (_OmniPortal *OmniPortalTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OmniPortalTransactorSession struct

+ Contract *OmniPortalTransactor

+ TransactOpts bind.TransactOpts

+ func (_OmniPortal *OmniPortalTransactorSession) AddValidatorSet(valSetId uint64, validators []XTypesValidator) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) CollectFees(to common.Address) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) Initialize(p OmniPortalInitParams) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) Pause() (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) PauseXCall() (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) PauseXCallTo(chainId_ uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) PauseXSubmit() (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) PauseXSubmitFrom(chainId_ uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) SetFeeOracle(feeOracle_ common.Address) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) SetInXBlockOffset(sourceChainId uint64, shardId uint64, offset uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) SetInXMsgOffset(sourceChainId uint64, shardId uint64, offset uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) SetNetwork(network_ []XTypesChain) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) SetXMsgMaxDataSize(numBytes uint16) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) SetXMsgMaxGasLimit(gasLimit uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) SetXMsgMinGasLimit(gasLimit uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) SetXReceiptMaxErrorSize(numBytes uint16) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) SetXSubValsetCutoff(xsubValsetCutoff_ uint8) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) Unpause() (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) UnpauseXCall() (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) UnpauseXCallTo(chainId_ uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) UnpauseXSubmit() (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) UnpauseXSubmitFrom(chainId_ uint64) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) Xcall(destChainId uint64, conf uint8, to common.Address, data []byte, ...) (*types.Transaction, error)

+ func (_OmniPortal *OmniPortalTransactorSession) Xsubmit(xsub XTypesSubmission) (*types.Transaction, error)

+ type OmniPortalUnpaused struct

+ Raw types.Log

+ type OmniPortalUnpaused0 struct

+ Key [32]byte

+ Raw types.Log

+ type OmniPortalUnpaused0Iterator struct

+ Event *OmniPortalUnpaused0

+ func (it *OmniPortalUnpaused0Iterator) Close() error

+ func (it *OmniPortalUnpaused0Iterator) Error() error

+ func (it *OmniPortalUnpaused0Iterator) Next() bool

+ type OmniPortalUnpausedIterator struct

+ Event *OmniPortalUnpaused

+ func (it *OmniPortalUnpausedIterator) Close() error

+ func (it *OmniPortalUnpausedIterator) Error() error

+ func (it *OmniPortalUnpausedIterator) Next() bool

+ type OmniPortalValidatorSetAdded struct

+ Raw types.Log

+ SetId uint64

+ type OmniPortalValidatorSetAddedIterator struct

+ Event *OmniPortalValidatorSetAdded

+ func (it *OmniPortalValidatorSetAddedIterator) Close() error

+ func (it *OmniPortalValidatorSetAddedIterator) Error() error

+ func (it *OmniPortalValidatorSetAddedIterator) Next() bool

+ type OmniPortalXCallPaused struct

+ Raw types.Log

+ type OmniPortalXCallPausedIterator struct

+ Event *OmniPortalXCallPaused

+ func (it *OmniPortalXCallPausedIterator) Close() error

+ func (it *OmniPortalXCallPausedIterator) Error() error

+ func (it *OmniPortalXCallPausedIterator) Next() bool

+ type OmniPortalXCallToPaused struct

+ ChainId uint64

+ Raw types.Log

+ type OmniPortalXCallToPausedIterator struct

+ Event *OmniPortalXCallToPaused

+ func (it *OmniPortalXCallToPausedIterator) Close() error

+ func (it *OmniPortalXCallToPausedIterator) Error() error

+ func (it *OmniPortalXCallToPausedIterator) Next() bool

+ type OmniPortalXCallToUnpaused struct

+ ChainId uint64

+ Raw types.Log

+ type OmniPortalXCallToUnpausedIterator struct

+ Event *OmniPortalXCallToUnpaused

+ func (it *OmniPortalXCallToUnpausedIterator) Close() error

+ func (it *OmniPortalXCallToUnpausedIterator) Error() error

+ func (it *OmniPortalXCallToUnpausedIterator) Next() bool

+ type OmniPortalXCallUnpaused struct

+ Raw types.Log

+ type OmniPortalXCallUnpausedIterator struct

+ Event *OmniPortalXCallUnpaused

+ func (it *OmniPortalXCallUnpausedIterator) Close() error

+ func (it *OmniPortalXCallUnpausedIterator) Error() error

+ func (it *OmniPortalXCallUnpausedIterator) Next() bool

+ type OmniPortalXMsg struct

+ Data []byte

+ DestChainId uint64

+ Fees *big.Int

+ GasLimit uint64

+ Offset uint64

+ Raw types.Log

+ Sender common.Address

+ ShardId uint64

+ To common.Address

+ type OmniPortalXMsgIterator struct

+ Event *OmniPortalXMsg

+ func (it *OmniPortalXMsgIterator) Close() error

+ func (it *OmniPortalXMsgIterator) Error() error

+ func (it *OmniPortalXMsgIterator) Next() bool

+ type OmniPortalXMsgMaxDataSizeSet struct

+ Raw types.Log

+ Size uint16

+ type OmniPortalXMsgMaxDataSizeSetIterator struct

+ Event *OmniPortalXMsgMaxDataSizeSet

+ func (it *OmniPortalXMsgMaxDataSizeSetIterator) Close() error

+ func (it *OmniPortalXMsgMaxDataSizeSetIterator) Error() error

+ func (it *OmniPortalXMsgMaxDataSizeSetIterator) Next() bool

+ type OmniPortalXMsgMaxGasLimitSet struct

+ GasLimit uint64

+ Raw types.Log

+ type OmniPortalXMsgMaxGasLimitSetIterator struct

+ Event *OmniPortalXMsgMaxGasLimitSet

+ func (it *OmniPortalXMsgMaxGasLimitSetIterator) Close() error

+ func (it *OmniPortalXMsgMaxGasLimitSetIterator) Error() error

+ func (it *OmniPortalXMsgMaxGasLimitSetIterator) Next() bool

+ type OmniPortalXMsgMinGasLimitSet struct

+ GasLimit uint64

+ Raw types.Log

+ type OmniPortalXMsgMinGasLimitSetIterator struct

+ Event *OmniPortalXMsgMinGasLimitSet

+ func (it *OmniPortalXMsgMinGasLimitSetIterator) Close() error

+ func (it *OmniPortalXMsgMinGasLimitSetIterator) Error() error

+ func (it *OmniPortalXMsgMinGasLimitSetIterator) Next() bool

+ type OmniPortalXReceipt struct

+ Err []byte

+ GasUsed *big.Int

+ Offset uint64

+ Raw types.Log

+ Relayer common.Address

+ ShardId uint64

+ SourceChainId uint64

+ Success bool

+ type OmniPortalXReceiptIterator struct

+ Event *OmniPortalXReceipt

+ func (it *OmniPortalXReceiptIterator) Close() error

+ func (it *OmniPortalXReceiptIterator) Error() error

+ func (it *OmniPortalXReceiptIterator) Next() bool

+ type OmniPortalXReceiptMaxErrorSizeSet struct

+ Raw types.Log

+ Size uint16

+ type OmniPortalXReceiptMaxErrorSizeSetIterator struct

+ Event *OmniPortalXReceiptMaxErrorSizeSet

+ func (it *OmniPortalXReceiptMaxErrorSizeSetIterator) Close() error

+ func (it *OmniPortalXReceiptMaxErrorSizeSetIterator) Error() error

+ func (it *OmniPortalXReceiptMaxErrorSizeSetIterator) Next() bool

+ type OmniPortalXSubValsetCutoffSet struct

+ Cutoff uint8

+ Raw types.Log

+ type OmniPortalXSubValsetCutoffSetIterator struct

+ Event *OmniPortalXSubValsetCutoffSet

+ func (it *OmniPortalXSubValsetCutoffSetIterator) Close() error

+ func (it *OmniPortalXSubValsetCutoffSetIterator) Error() error

+ func (it *OmniPortalXSubValsetCutoffSetIterator) Next() bool

+ type OmniPortalXSubmitFromPaused struct

+ ChainId uint64

+ Raw types.Log

+ type OmniPortalXSubmitFromPausedIterator struct

+ Event *OmniPortalXSubmitFromPaused

+ func (it *OmniPortalXSubmitFromPausedIterator) Close() error

+ func (it *OmniPortalXSubmitFromPausedIterator) Error() error

+ func (it *OmniPortalXSubmitFromPausedIterator) Next() bool

+ type OmniPortalXSubmitFromUnpaused struct

+ ChainId uint64

+ Raw types.Log

+ type OmniPortalXSubmitFromUnpausedIterator struct

+ Event *OmniPortalXSubmitFromUnpaused

+ func (it *OmniPortalXSubmitFromUnpausedIterator) Close() error

+ func (it *OmniPortalXSubmitFromUnpausedIterator) Error() error

+ func (it *OmniPortalXSubmitFromUnpausedIterator) Next() bool

+ type OmniPortalXSubmitPaused struct

+ Raw types.Log

+ type OmniPortalXSubmitPausedIterator struct

+ Event *OmniPortalXSubmitPaused

+ func (it *OmniPortalXSubmitPausedIterator) Close() error

+ func (it *OmniPortalXSubmitPausedIterator) Error() error

+ func (it *OmniPortalXSubmitPausedIterator) Next() bool

+ type OmniPortalXSubmitUnpaused struct

+ Raw types.Log

+ type OmniPortalXSubmitUnpausedIterator struct

+ Event *OmniPortalXSubmitUnpaused

+ func (it *OmniPortalXSubmitUnpausedIterator) Close() error

+ func (it *OmniPortalXSubmitUnpausedIterator) Error() error

+ func (it *OmniPortalXSubmitUnpausedIterator) Next() bool

+ type OmniRaw struct

+ Contract *Omni

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

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

+ func (_Omni *OmniRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OmniSession struct

+ CallOpts bind.CallOpts

+ Contract *Omni

+ TransactOpts bind.TransactOpts

+ func (_Omni *OmniSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

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

+ func (_Omni *OmniSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_Omni *OmniSession) DOMAINSEPARATOR() ([32]byte, error)

+ func (_Omni *OmniSession) Decimals() (uint8, error)

+ func (_Omni *OmniSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_Omni *OmniSession) Eip712Domain() (struct{ ... }, error)

+ func (_Omni *OmniSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_Omni *OmniSession) Name() (string, error)

+ func (_Omni *OmniSession) Nonces(owner common.Address) (*big.Int, error)

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

+ func (_Omni *OmniSession) Symbol() (string, error)

+ func (_Omni *OmniSession) TotalSupply() (*big.Int, error)

+ func (_Omni *OmniSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_Omni *OmniSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error)

+ type OmniTransactor struct

+ func NewOmniTransactor(address common.Address, transactor bind.ContractTransactor) (*OmniTransactor, error)

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

+ func (_Omni *OmniTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_Omni *OmniTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error)

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

+ func (_Omni *OmniTransactor) Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_Omni *OmniTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ type OmniTransactorRaw struct

+ Contract *OmniTransactor

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

+ func (_Omni *OmniTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OmniTransactorSession struct

+ Contract *OmniTransactor

+ TransactOpts bind.TransactOpts

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

+ func (_Omni *OmniTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_Omni *OmniTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

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

+ func (_Omni *OmniTransactorSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_Omni *OmniTransactorSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error)

+ type OmniTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type OmniTransferIterator struct

+ Event *OmniTransfer

+ func (it *OmniTransferIterator) Close() error

+ func (it *OmniTransferIterator) Error() error

+ func (it *OmniTransferIterator) Next() bool

+ type PingPong struct

+ func DeployPingPong(auth *bind.TransactOpts, backend bind.ContractBackend, portal common.Address) (common.Address, *types.Transaction, *PingPong, error)

+ func NewPingPong(address common.Address, backend bind.ContractBackend) (*PingPong, error)

+ type PingPongCaller struct

+ func NewPingPongCaller(address common.Address, caller bind.ContractCaller) (*PingPongCaller, error)

+ func (_PingPong *PingPongCaller) DefaultConfLevel(opts *bind.CallOpts) (uint8, error)

+ func (_PingPong *PingPongCaller) GASLIMIT(opts *bind.CallOpts) (uint64, error)

+ func (_PingPong *PingPongCaller) Omni(opts *bind.CallOpts) (common.Address, error)

+ type PingPongCallerRaw struct

+ Contract *PingPongCaller

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

+ type PingPongCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *PingPongCaller

+ func (_PingPong *PingPongCallerSession) DefaultConfLevel() (uint8, error)

+ func (_PingPong *PingPongCallerSession) GASLIMIT() (uint64, error)

+ func (_PingPong *PingPongCallerSession) Omni() (common.Address, error)

+ type PingPongDefaultConfLevelSet struct

+ Conf uint8

+ Raw types.Log

+ type PingPongDefaultConfLevelSetIterator struct

+ Event *PingPongDefaultConfLevelSet

+ func (it *PingPongDefaultConfLevelSetIterator) Close() error

+ func (it *PingPongDefaultConfLevelSetIterator) Error() error

+ func (it *PingPongDefaultConfLevelSetIterator) Next() bool

+ type PingPongDone struct

+ DestChainID uint64

+ Id string

+ Raw types.Log

+ Times uint64

+ To common.Address

+ type PingPongDoneIterator struct

+ Event *PingPongDone

+ func (it *PingPongDoneIterator) Close() error

+ func (it *PingPongDoneIterator) Error() error

+ func (it *PingPongDoneIterator) Next() bool

+ type PingPongFilterer struct

+ func NewPingPongFilterer(address common.Address, filterer bind.ContractFilterer) (*PingPongFilterer, error)

+ func (_PingPong *PingPongFilterer) FilterDefaultConfLevelSet(opts *bind.FilterOpts) (*PingPongDefaultConfLevelSetIterator, error)

+ func (_PingPong *PingPongFilterer) FilterDone(opts *bind.FilterOpts) (*PingPongDoneIterator, error)

+ func (_PingPong *PingPongFilterer) FilterOmniPortalSet(opts *bind.FilterOpts) (*PingPongOmniPortalSetIterator, error)

+ func (_PingPong *PingPongFilterer) FilterPing(opts *bind.FilterOpts) (*PingPongPingIterator, error)

+ func (_PingPong *PingPongFilterer) ParseDefaultConfLevelSet(log types.Log) (*PingPongDefaultConfLevelSet, error)

+ func (_PingPong *PingPongFilterer) ParseDone(log types.Log) (*PingPongDone, error)

+ func (_PingPong *PingPongFilterer) ParseOmniPortalSet(log types.Log) (*PingPongOmniPortalSet, error)

+ func (_PingPong *PingPongFilterer) ParsePing(log types.Log) (*PingPongPing, error)

+ func (_PingPong *PingPongFilterer) WatchDefaultConfLevelSet(opts *bind.WatchOpts, sink chan<- *PingPongDefaultConfLevelSet) (event.Subscription, error)

+ func (_PingPong *PingPongFilterer) WatchDone(opts *bind.WatchOpts, sink chan<- *PingPongDone) (event.Subscription, error)

+ func (_PingPong *PingPongFilterer) WatchOmniPortalSet(opts *bind.WatchOpts, sink chan<- *PingPongOmniPortalSet) (event.Subscription, error)

+ func (_PingPong *PingPongFilterer) WatchPing(opts *bind.WatchOpts, sink chan<- *PingPongPing) (event.Subscription, error)

+ type PingPongOmniPortalSet struct

+ Omni common.Address

+ Raw types.Log

+ type PingPongOmniPortalSetIterator struct

+ Event *PingPongOmniPortalSet

+ func (it *PingPongOmniPortalSetIterator) Close() error

+ func (it *PingPongOmniPortalSetIterator) Error() error

+ func (it *PingPongOmniPortalSetIterator) Next() bool

+ type PingPongPing struct

+ From common.Address

+ Id string

+ N uint64

+ Raw types.Log

+ SrcChainID uint64

+ type PingPongPingIterator struct

+ Event *PingPongPing

+ func (it *PingPongPingIterator) Close() error

+ func (it *PingPongPingIterator) Error() error

+ func (it *PingPongPingIterator) Next() bool

+ type PingPongRaw struct

+ Contract *PingPong

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

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

+ func (_PingPong *PingPongRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type PingPongSession struct

+ CallOpts bind.CallOpts

+ Contract *PingPong

+ TransactOpts bind.TransactOpts

+ func (_PingPong *PingPongSession) DefaultConfLevel() (uint8, error)

+ func (_PingPong *PingPongSession) GASLIMIT() (uint64, error)

+ func (_PingPong *PingPongSession) Omni() (common.Address, error)

+ func (_PingPong *PingPongSession) Pingpong(id string, conf uint8, times uint64, n uint64) (*types.Transaction, error)

+ func (_PingPong *PingPongSession) Receive() (*types.Transaction, error)

+ func (_PingPong *PingPongSession) Start(id string, destChainID uint64, conf uint8, to common.Address, times uint64) (*types.Transaction, error)

+ type PingPongTransactor struct

+ func NewPingPongTransactor(address common.Address, transactor bind.ContractTransactor) (*PingPongTransactor, error)

+ func (_PingPong *PingPongTransactor) Pingpong(opts *bind.TransactOpts, id string, conf uint8, times uint64, n uint64) (*types.Transaction, error)

+ func (_PingPong *PingPongTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_PingPong *PingPongTransactor) Start(opts *bind.TransactOpts, id string, destChainID uint64, conf uint8, ...) (*types.Transaction, error)

+ type PingPongTransactorRaw struct

+ Contract *PingPongTransactor

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

+ func (_PingPong *PingPongTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type PingPongTransactorSession struct

+ Contract *PingPongTransactor

+ TransactOpts bind.TransactOpts

+ func (_PingPong *PingPongTransactorSession) Pingpong(id string, conf uint8, times uint64, n uint64) (*types.Transaction, error)

+ func (_PingPong *PingPongTransactorSession) Receive() (*types.Transaction, error)

+ func (_PingPong *PingPongTransactorSession) Start(id string, destChainID uint64, conf uint8, to common.Address, times uint64) (*types.Transaction, error)

+ type PortalRegistry struct

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

+ func NewPortalRegistry(address common.Address, backend bind.ContractBackend) (*PortalRegistry, error)

+ type PortalRegistryCaller struct

+ func NewPortalRegistryCaller(address common.Address, caller bind.ContractCaller) (*PortalRegistryCaller, error)

+ func (_PortalRegistry *PortalRegistryCaller) ChainIds(opts *bind.CallOpts, arg0 *big.Int) (uint64, error)

+ func (_PortalRegistry *PortalRegistryCaller) Deployments(opts *bind.CallOpts, arg0 uint64) (struct{ ... }, error)

+ func (_PortalRegistry *PortalRegistryCaller) Get(opts *bind.CallOpts, chainId uint64) (PortalRegistryDeployment, error)

+ func (_PortalRegistry *PortalRegistryCaller) List(opts *bind.CallOpts) ([]PortalRegistryDeployment, error)

+ func (_PortalRegistry *PortalRegistryCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ type PortalRegistryCallerRaw struct

+ Contract *PortalRegistryCaller

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

+ type PortalRegistryCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *PortalRegistryCaller

+ func (_PortalRegistry *PortalRegistryCallerSession) ChainIds(arg0 *big.Int) (uint64, error)

+ func (_PortalRegistry *PortalRegistryCallerSession) Deployments(arg0 uint64) (struct{ ... }, error)

+ func (_PortalRegistry *PortalRegistryCallerSession) Get(chainId uint64) (PortalRegistryDeployment, error)

+ func (_PortalRegistry *PortalRegistryCallerSession) List() ([]PortalRegistryDeployment, error)

+ func (_PortalRegistry *PortalRegistryCallerSession) Owner() (common.Address, error)

+ type PortalRegistryDeployment struct

+ Addr common.Address

+ AttestInterval uint64

+ BlockPeriodNs uint64

+ ChainId uint64

+ DeployHeight uint64

+ Name string

+ Shards []uint64

+ type PortalRegistryFilterer struct

+ func NewPortalRegistryFilterer(address common.Address, filterer bind.ContractFilterer) (*PortalRegistryFilterer, error)

+ func (_PortalRegistry *PortalRegistryFilterer) FilterInitialized(opts *bind.FilterOpts) (*PortalRegistryInitializedIterator, error)

+ func (_PortalRegistry *PortalRegistryFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*PortalRegistryOwnershipTransferredIterator, error)

+ func (_PortalRegistry *PortalRegistryFilterer) FilterPortalRegistered(opts *bind.FilterOpts, chainId []uint64, addr []common.Address) (*PortalRegistryPortalRegisteredIterator, error)

+ func (_PortalRegistry *PortalRegistryFilterer) ParseInitialized(log types.Log) (*PortalRegistryInitialized, error)

+ func (_PortalRegistry *PortalRegistryFilterer) ParseOwnershipTransferred(log types.Log) (*PortalRegistryOwnershipTransferred, error)

+ func (_PortalRegistry *PortalRegistryFilterer) ParsePortalRegistered(log types.Log) (*PortalRegistryPortalRegistered, error)

+ func (_PortalRegistry *PortalRegistryFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *PortalRegistryInitialized) (event.Subscription, error)

+ func (_PortalRegistry *PortalRegistryFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *PortalRegistryOwnershipTransferred, ...) (event.Subscription, error)

+ func (_PortalRegistry *PortalRegistryFilterer) WatchPortalRegistered(opts *bind.WatchOpts, sink chan<- *PortalRegistryPortalRegistered, ...) (event.Subscription, error)

+ type PortalRegistryInitialized struct

+ Raw types.Log

+ Version uint64

+ type PortalRegistryInitializedIterator struct

+ Event *PortalRegistryInitialized

+ func (it *PortalRegistryInitializedIterator) Close() error

+ func (it *PortalRegistryInitializedIterator) Error() error

+ func (it *PortalRegistryInitializedIterator) Next() bool

+ type PortalRegistryOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type PortalRegistryOwnershipTransferredIterator struct

+ Event *PortalRegistryOwnershipTransferred

+ func (it *PortalRegistryOwnershipTransferredIterator) Close() error

+ func (it *PortalRegistryOwnershipTransferredIterator) Error() error

+ func (it *PortalRegistryOwnershipTransferredIterator) Next() bool

+ type PortalRegistryPortalRegistered struct

+ Addr common.Address

+ AttestInterval uint64

+ BlockPeriodNs uint64

+ ChainId uint64

+ DeployHeight uint64

+ Name string

+ Raw types.Log

+ Shards []uint64

+ type PortalRegistryPortalRegisteredIterator struct

+ Event *PortalRegistryPortalRegistered

+ func (it *PortalRegistryPortalRegisteredIterator) Close() error

+ func (it *PortalRegistryPortalRegisteredIterator) Error() error

+ func (it *PortalRegistryPortalRegisteredIterator) Next() bool

+ type PortalRegistryRaw struct

+ Contract *PortalRegistry

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

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

+ func (_PortalRegistry *PortalRegistryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type PortalRegistrySession struct

+ CallOpts bind.CallOpts

+ Contract *PortalRegistry

+ TransactOpts bind.TransactOpts

+ func (_PortalRegistry *PortalRegistrySession) BulkRegister(deps []PortalRegistryDeployment) (*types.Transaction, error)

+ func (_PortalRegistry *PortalRegistrySession) ChainIds(arg0 *big.Int) (uint64, error)

+ func (_PortalRegistry *PortalRegistrySession) Deployments(arg0 uint64) (struct{ ... }, error)

+ func (_PortalRegistry *PortalRegistrySession) Get(chainId uint64) (PortalRegistryDeployment, error)

+ func (_PortalRegistry *PortalRegistrySession) Initialize(owner_ common.Address) (*types.Transaction, error)

+ func (_PortalRegistry *PortalRegistrySession) List() ([]PortalRegistryDeployment, error)

+ func (_PortalRegistry *PortalRegistrySession) Owner() (common.Address, error)

+ func (_PortalRegistry *PortalRegistrySession) Register(dep PortalRegistryDeployment) (*types.Transaction, error)

+ func (_PortalRegistry *PortalRegistrySession) RenounceOwnership() (*types.Transaction, error)

+ func (_PortalRegistry *PortalRegistrySession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type PortalRegistryTransactor struct

+ func NewPortalRegistryTransactor(address common.Address, transactor bind.ContractTransactor) (*PortalRegistryTransactor, error)

+ func (_PortalRegistry *PortalRegistryTransactor) BulkRegister(opts *bind.TransactOpts, deps []PortalRegistryDeployment) (*types.Transaction, error)

+ func (_PortalRegistry *PortalRegistryTransactor) Initialize(opts *bind.TransactOpts, owner_ common.Address) (*types.Transaction, error)

+ func (_PortalRegistry *PortalRegistryTransactor) Register(opts *bind.TransactOpts, dep PortalRegistryDeployment) (*types.Transaction, error)

+ func (_PortalRegistry *PortalRegistryTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

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

+ type PortalRegistryTransactorRaw struct

+ Contract *PortalRegistryTransactor

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

+ func (_PortalRegistry *PortalRegistryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type PortalRegistryTransactorSession struct

+ Contract *PortalRegistryTransactor

+ TransactOpts bind.TransactOpts

+ func (_PortalRegistry *PortalRegistryTransactorSession) BulkRegister(deps []PortalRegistryDeployment) (*types.Transaction, error)

+ func (_PortalRegistry *PortalRegistryTransactorSession) Initialize(owner_ common.Address) (*types.Transaction, error)

+ func (_PortalRegistry *PortalRegistryTransactorSession) Register(dep PortalRegistryDeployment) (*types.Transaction, error)

+ func (_PortalRegistry *PortalRegistryTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_PortalRegistry *PortalRegistryTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type ProxyAdmin struct

+ func DeployProxyAdmin(auth *bind.TransactOpts, backend bind.ContractBackend, ...) (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) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_ProxyAdmin *ProxyAdminCaller) UPGRADEINTERFACEVERSION(opts *bind.CallOpts) (string, 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) Owner() (common.Address, error)

+ func (_ProxyAdmin *ProxyAdminCallerSession) UPGRADEINTERFACEVERSION() (string, error)

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

+ func (_ProxyAdmin *ProxyAdminSession) RenounceOwnership() (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminSession) UPGRADEINTERFACEVERSION() (string, 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) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner 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) RenounceOwnership() (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_ProxyAdmin *ProxyAdminTransactorSession) UpgradeAndCall(proxy common.Address, implementation common.Address, data []byte) (*types.Transaction, error)

+ type Slashing struct

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

+ func NewSlashing(address common.Address, backend bind.ContractBackend) (*Slashing, error)

+ type SlashingCaller struct

+ func NewSlashingCaller(address common.Address, caller bind.ContractCaller) (*SlashingCaller, error)

+ func (_Slashing *SlashingCaller) Fee(opts *bind.CallOpts) (*big.Int, error)

+ type SlashingCallerRaw struct

+ Contract *SlashingCaller

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

+ type SlashingCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SlashingCaller

+ func (_Slashing *SlashingCallerSession) Fee() (*big.Int, error)

+ type SlashingFilterer struct

+ func NewSlashingFilterer(address common.Address, filterer bind.ContractFilterer) (*SlashingFilterer, error)

+ func (_Slashing *SlashingFilterer) FilterUnjail(opts *bind.FilterOpts, validator []common.Address) (*SlashingUnjailIterator, error)

+ func (_Slashing *SlashingFilterer) ParseUnjail(log types.Log) (*SlashingUnjail, error)

+ func (_Slashing *SlashingFilterer) WatchUnjail(opts *bind.WatchOpts, sink chan<- *SlashingUnjail, validator []common.Address) (event.Subscription, error)

+ type SlashingRaw struct

+ Contract *Slashing

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

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

+ func (_Slashing *SlashingRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SlashingSession struct

+ CallOpts bind.CallOpts

+ Contract *Slashing

+ TransactOpts bind.TransactOpts

+ func (_Slashing *SlashingSession) Fee() (*big.Int, error)

+ func (_Slashing *SlashingSession) Unjail() (*types.Transaction, error)

+ type SlashingTransactor struct

+ func NewSlashingTransactor(address common.Address, transactor bind.ContractTransactor) (*SlashingTransactor, error)

+ func (_Slashing *SlashingTransactor) Unjail(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SlashingTransactorRaw struct

+ Contract *SlashingTransactor

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

+ func (_Slashing *SlashingTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SlashingTransactorSession struct

+ Contract *SlashingTransactor

+ TransactOpts bind.TransactOpts

+ func (_Slashing *SlashingTransactorSession) Unjail() (*types.Transaction, error)

+ type SlashingUnjail struct

+ Raw types.Log

+ Validator common.Address

+ type SlashingUnjailIterator struct

+ Event *SlashingUnjail

+ func (it *SlashingUnjailIterator) Close() error

+ func (it *SlashingUnjailIterator) Error() error

+ func (it *SlashingUnjailIterator) Next() bool

+ type Staking struct

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

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

+ type StakingAllowlistDisabled struct

+ Raw types.Log

+ type StakingAllowlistDisabledIterator struct

+ Event *StakingAllowlistDisabled

+ func (it *StakingAllowlistDisabledIterator) Close() error

+ func (it *StakingAllowlistDisabledIterator) Error() error

+ func (it *StakingAllowlistDisabledIterator) Next() bool

+ type StakingAllowlistEnabled struct

+ Raw types.Log

+ type StakingAllowlistEnabledIterator struct

+ Event *StakingAllowlistEnabled

+ func (it *StakingAllowlistEnabledIterator) Close() error

+ func (it *StakingAllowlistEnabledIterator) Error() error

+ func (it *StakingAllowlistEnabledIterator) Next() bool

+ type StakingCaller struct

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

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

+ func (_Staking *StakingCaller) IsAllowlistEnabled(opts *bind.CallOpts) (bool, error)

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

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

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

+ type StakingCallerRaw struct

+ Contract *StakingCaller

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

+ type StakingCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *StakingCaller

+ func (_Staking *StakingCallerSession) IsAllowedValidator(arg0 common.Address) (bool, error)

+ func (_Staking *StakingCallerSession) IsAllowlistEnabled() (bool, error)

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

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

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

+ type StakingCreateValidator struct

+ Deposit *big.Int

+ Pubkey []byte

+ Raw types.Log

+ Validator common.Address

+ type StakingCreateValidatorIterator struct

+ Event *StakingCreateValidator

+ func (it *StakingCreateValidatorIterator) Close() error

+ func (it *StakingCreateValidatorIterator) Error() error

+ func (it *StakingCreateValidatorIterator) Next() bool

+ type StakingDelegate struct

+ Amount *big.Int

+ Delegator common.Address

+ Raw types.Log

+ Validator common.Address

+ type StakingDelegateIterator struct

+ Event *StakingDelegate

+ func (it *StakingDelegateIterator) Close() error

+ func (it *StakingDelegateIterator) Error() error

+ func (it *StakingDelegateIterator) Next() bool

+ type StakingFilterer struct

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

+ func (_Staking *StakingFilterer) FilterAllowlistDisabled(opts *bind.FilterOpts) (*StakingAllowlistDisabledIterator, error)

+ func (_Staking *StakingFilterer) FilterAllowlistEnabled(opts *bind.FilterOpts) (*StakingAllowlistEnabledIterator, error)

+ func (_Staking *StakingFilterer) FilterCreateValidator(opts *bind.FilterOpts, validator []common.Address) (*StakingCreateValidatorIterator, error)

+ func (_Staking *StakingFilterer) FilterDelegate(opts *bind.FilterOpts, delegator []common.Address, validator []common.Address) (*StakingDelegateIterator, error)

+ func (_Staking *StakingFilterer) FilterInitialized(opts *bind.FilterOpts) (*StakingInitializedIterator, error)

+ func (_Staking *StakingFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*StakingOwnershipTransferredIterator, error)

+ func (_Staking *StakingFilterer) FilterValidatorAllowed(opts *bind.FilterOpts, validator []common.Address) (*StakingValidatorAllowedIterator, error)

+ func (_Staking *StakingFilterer) FilterValidatorDisallowed(opts *bind.FilterOpts, validator []common.Address) (*StakingValidatorDisallowedIterator, error)

+ func (_Staking *StakingFilterer) ParseAllowlistDisabled(log types.Log) (*StakingAllowlistDisabled, error)

+ func (_Staking *StakingFilterer) ParseAllowlistEnabled(log types.Log) (*StakingAllowlistEnabled, error)

+ func (_Staking *StakingFilterer) ParseCreateValidator(log types.Log) (*StakingCreateValidator, error)

+ func (_Staking *StakingFilterer) ParseDelegate(log types.Log) (*StakingDelegate, error)

+ func (_Staking *StakingFilterer) ParseInitialized(log types.Log) (*StakingInitialized, error)

+ func (_Staking *StakingFilterer) ParseOwnershipTransferred(log types.Log) (*StakingOwnershipTransferred, error)

+ func (_Staking *StakingFilterer) ParseValidatorAllowed(log types.Log) (*StakingValidatorAllowed, error)

+ func (_Staking *StakingFilterer) ParseValidatorDisallowed(log types.Log) (*StakingValidatorDisallowed, error)

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

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

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

+ func (_Staking *StakingFilterer) WatchDelegate(opts *bind.WatchOpts, sink chan<- *StakingDelegate, delegator []common.Address, ...) (event.Subscription, error)

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

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

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

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

+ type StakingInitialized struct

+ Raw types.Log

+ Version uint64

+ type StakingInitializedIterator struct

+ Event *StakingInitialized

+ func (it *StakingInitializedIterator) Close() error

+ func (it *StakingInitializedIterator) Error() error

+ func (it *StakingInitializedIterator) Next() bool

+ type StakingOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type StakingOwnershipTransferredIterator struct

+ Event *StakingOwnershipTransferred

+ func (it *StakingOwnershipTransferredIterator) Close() error

+ func (it *StakingOwnershipTransferredIterator) Error() error

+ func (it *StakingOwnershipTransferredIterator) Next() bool

+ type StakingRaw struct

+ Contract *Staking

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

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

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

+ type StakingSession struct

+ CallOpts bind.CallOpts

+ Contract *Staking

+ TransactOpts bind.TransactOpts

+ func (_Staking *StakingSession) AllowValidators(validators []common.Address) (*types.Transaction, error)

+ func (_Staking *StakingSession) CreateValidator(pubkey []byte) (*types.Transaction, error)

+ func (_Staking *StakingSession) Delegate(validator common.Address) (*types.Transaction, error)

+ func (_Staking *StakingSession) DisableAllowlist() (*types.Transaction, error)

+ func (_Staking *StakingSession) DisallowValidators(validators []common.Address) (*types.Transaction, error)

+ func (_Staking *StakingSession) EnableAllowlist() (*types.Transaction, error)

+ func (_Staking *StakingSession) Initialize(owner_ common.Address, isAllowlistEnabled_ bool) (*types.Transaction, error)

+ func (_Staking *StakingSession) IsAllowedValidator(arg0 common.Address) (bool, error)

+ func (_Staking *StakingSession) IsAllowlistEnabled() (bool, error)

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

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

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

+ func (_Staking *StakingSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Staking *StakingSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type StakingTransactor struct

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

+ func (_Staking *StakingTransactor) AllowValidators(opts *bind.TransactOpts, validators []common.Address) (*types.Transaction, error)

+ func (_Staking *StakingTransactor) CreateValidator(opts *bind.TransactOpts, pubkey []byte) (*types.Transaction, error)

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

+ func (_Staking *StakingTransactor) DisableAllowlist(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Staking *StakingTransactor) DisallowValidators(opts *bind.TransactOpts, validators []common.Address) (*types.Transaction, error)

+ func (_Staking *StakingTransactor) EnableAllowlist(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Staking *StakingTransactor) Initialize(opts *bind.TransactOpts, owner_ common.Address, isAllowlistEnabled_ bool) (*types.Transaction, error)

+ func (_Staking *StakingTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

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

+ type StakingTransactorRaw struct

+ Contract *StakingTransactor

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

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

+ type StakingTransactorSession struct

+ Contract *StakingTransactor

+ TransactOpts bind.TransactOpts

+ func (_Staking *StakingTransactorSession) AllowValidators(validators []common.Address) (*types.Transaction, error)

+ func (_Staking *StakingTransactorSession) CreateValidator(pubkey []byte) (*types.Transaction, error)

+ func (_Staking *StakingTransactorSession) Delegate(validator common.Address) (*types.Transaction, error)

+ func (_Staking *StakingTransactorSession) DisableAllowlist() (*types.Transaction, error)

+ func (_Staking *StakingTransactorSession) DisallowValidators(validators []common.Address) (*types.Transaction, error)

+ func (_Staking *StakingTransactorSession) EnableAllowlist() (*types.Transaction, error)

+ func (_Staking *StakingTransactorSession) Initialize(owner_ common.Address, isAllowlistEnabled_ bool) (*types.Transaction, error)

+ func (_Staking *StakingTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Staking *StakingTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type StakingValidatorAllowed struct

+ Raw types.Log

+ Validator common.Address

+ type StakingValidatorAllowedIterator struct

+ Event *StakingValidatorAllowed

+ func (it *StakingValidatorAllowedIterator) Close() error

+ func (it *StakingValidatorAllowedIterator) Error() error

+ func (it *StakingValidatorAllowedIterator) Next() bool

+ type StakingValidatorDisallowed struct

+ Raw types.Log

+ Validator common.Address

+ type StakingValidatorDisallowedIterator struct

+ Event *StakingValidatorDisallowed

+ func (it *StakingValidatorDisallowedIterator) Close() error

+ func (it *StakingValidatorDisallowedIterator) Error() error

+ func (it *StakingValidatorDisallowedIterator) Next() bool

+ type StrategyBase struct

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

+ func NewStrategyBase(address common.Address, backend bind.ContractBackend) (*StrategyBase, error)

+ type StrategyBaseCaller struct

+ func NewStrategyBaseCaller(address common.Address, caller bind.ContractCaller) (*StrategyBaseCaller, error)

+ func (_StrategyBase *StrategyBaseCaller) Explanation(opts *bind.CallOpts) (string, error)

+ func (_StrategyBase *StrategyBaseCaller) Paused(opts *bind.CallOpts, index uint8) (bool, error)

+ func (_StrategyBase *StrategyBaseCaller) Paused0(opts *bind.CallOpts) (*big.Int, error)

+ func (_StrategyBase *StrategyBaseCaller) PauserRegistry(opts *bind.CallOpts) (common.Address, error)

+ func (_StrategyBase *StrategyBaseCaller) Shares(opts *bind.CallOpts, user common.Address) (*big.Int, error)

+ func (_StrategyBase *StrategyBaseCaller) SharesToUnderlying(opts *bind.CallOpts, amountShares *big.Int) (*big.Int, error)

+ func (_StrategyBase *StrategyBaseCaller) SharesToUnderlyingView(opts *bind.CallOpts, amountShares *big.Int) (*big.Int, error)

+ func (_StrategyBase *StrategyBaseCaller) StrategyManager(opts *bind.CallOpts) (common.Address, error)

+ func (_StrategyBase *StrategyBaseCaller) TotalShares(opts *bind.CallOpts) (*big.Int, error)

+ func (_StrategyBase *StrategyBaseCaller) UnderlyingToShares(opts *bind.CallOpts, amountUnderlying *big.Int) (*big.Int, error)

+ func (_StrategyBase *StrategyBaseCaller) UnderlyingToSharesView(opts *bind.CallOpts, amountUnderlying *big.Int) (*big.Int, error)

+ func (_StrategyBase *StrategyBaseCaller) UnderlyingToken(opts *bind.CallOpts) (common.Address, error)

+ func (_StrategyBase *StrategyBaseCaller) UserUnderlyingView(opts *bind.CallOpts, user common.Address) (*big.Int, error)

+ type StrategyBaseCallerRaw struct

+ Contract *StrategyBaseCaller

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

+ type StrategyBaseCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *StrategyBaseCaller

+ func (_StrategyBase *StrategyBaseCallerSession) Explanation() (string, error)

+ func (_StrategyBase *StrategyBaseCallerSession) Paused(index uint8) (bool, error)

+ func (_StrategyBase *StrategyBaseCallerSession) Paused0() (*big.Int, error)

+ func (_StrategyBase *StrategyBaseCallerSession) PauserRegistry() (common.Address, error)

+ func (_StrategyBase *StrategyBaseCallerSession) Shares(user common.Address) (*big.Int, error)

+ func (_StrategyBase *StrategyBaseCallerSession) SharesToUnderlying(amountShares *big.Int) (*big.Int, error)

+ func (_StrategyBase *StrategyBaseCallerSession) SharesToUnderlyingView(amountShares *big.Int) (*big.Int, error)

+ func (_StrategyBase *StrategyBaseCallerSession) StrategyManager() (common.Address, error)

+ func (_StrategyBase *StrategyBaseCallerSession) TotalShares() (*big.Int, error)

+ func (_StrategyBase *StrategyBaseCallerSession) UnderlyingToShares(amountUnderlying *big.Int) (*big.Int, error)

+ func (_StrategyBase *StrategyBaseCallerSession) UnderlyingToSharesView(amountUnderlying *big.Int) (*big.Int, error)

+ func (_StrategyBase *StrategyBaseCallerSession) UnderlyingToken() (common.Address, error)

+ func (_StrategyBase *StrategyBaseCallerSession) UserUnderlyingView(user common.Address) (*big.Int, error)

+ type StrategyBaseFilterer struct

+ func NewStrategyBaseFilterer(address common.Address, filterer bind.ContractFilterer) (*StrategyBaseFilterer, error)

+ func (_StrategyBase *StrategyBaseFilterer) FilterInitialized(opts *bind.FilterOpts) (*StrategyBaseInitializedIterator, error)

+ func (_StrategyBase *StrategyBaseFilterer) FilterPaused(opts *bind.FilterOpts, account []common.Address) (*StrategyBasePausedIterator, error)

+ func (_StrategyBase *StrategyBaseFilterer) FilterPauserRegistrySet(opts *bind.FilterOpts) (*StrategyBasePauserRegistrySetIterator, error)

+ func (_StrategyBase *StrategyBaseFilterer) FilterUnpaused(opts *bind.FilterOpts, account []common.Address) (*StrategyBaseUnpausedIterator, error)

+ func (_StrategyBase *StrategyBaseFilterer) ParseInitialized(log types.Log) (*StrategyBaseInitialized, error)

+ func (_StrategyBase *StrategyBaseFilterer) ParsePaused(log types.Log) (*StrategyBasePaused, error)

+ func (_StrategyBase *StrategyBaseFilterer) ParsePauserRegistrySet(log types.Log) (*StrategyBasePauserRegistrySet, error)

+ func (_StrategyBase *StrategyBaseFilterer) ParseUnpaused(log types.Log) (*StrategyBaseUnpaused, error)

+ func (_StrategyBase *StrategyBaseFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *StrategyBaseInitialized) (event.Subscription, error)

+ func (_StrategyBase *StrategyBaseFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *StrategyBasePaused, ...) (event.Subscription, error)

+ func (_StrategyBase *StrategyBaseFilterer) WatchPauserRegistrySet(opts *bind.WatchOpts, sink chan<- *StrategyBasePauserRegistrySet) (event.Subscription, error)

+ func (_StrategyBase *StrategyBaseFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *StrategyBaseUnpaused, ...) (event.Subscription, error)

+ type StrategyBaseInitialized struct

+ Raw types.Log

+ Version uint8

+ type StrategyBaseInitializedIterator struct

+ Event *StrategyBaseInitialized

+ func (it *StrategyBaseInitializedIterator) Close() error

+ func (it *StrategyBaseInitializedIterator) Error() error

+ func (it *StrategyBaseInitializedIterator) Next() bool

+ type StrategyBasePaused struct

+ Account common.Address

+ NewPausedStatus *big.Int

+ Raw types.Log

+ type StrategyBasePausedIterator struct

+ Event *StrategyBasePaused

+ func (it *StrategyBasePausedIterator) Close() error

+ func (it *StrategyBasePausedIterator) Error() error

+ func (it *StrategyBasePausedIterator) Next() bool

+ type StrategyBasePauserRegistrySet struct

+ NewPauserRegistry common.Address

+ PauserRegistry common.Address

+ Raw types.Log

+ type StrategyBasePauserRegistrySetIterator struct

+ Event *StrategyBasePauserRegistrySet

+ func (it *StrategyBasePauserRegistrySetIterator) Close() error

+ func (it *StrategyBasePauserRegistrySetIterator) Error() error

+ func (it *StrategyBasePauserRegistrySetIterator) Next() bool

+ type StrategyBaseRaw struct

+ Contract *StrategyBase

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

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

+ func (_StrategyBase *StrategyBaseRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type StrategyBaseSession struct

+ CallOpts bind.CallOpts

+ Contract *StrategyBase

+ TransactOpts bind.TransactOpts

+ func (_StrategyBase *StrategyBaseSession) Deposit(token common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_StrategyBase *StrategyBaseSession) Explanation() (string, error)

+ func (_StrategyBase *StrategyBaseSession) Initialize(_underlyingToken common.Address, _pauserRegistry common.Address) (*types.Transaction, error)

+ func (_StrategyBase *StrategyBaseSession) Pause(newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_StrategyBase *StrategyBaseSession) PauseAll() (*types.Transaction, error)

+ func (_StrategyBase *StrategyBaseSession) Paused(index uint8) (bool, error)

+ func (_StrategyBase *StrategyBaseSession) Paused0() (*big.Int, error)

+ func (_StrategyBase *StrategyBaseSession) PauserRegistry() (common.Address, error)

+ func (_StrategyBase *StrategyBaseSession) SetPauserRegistry(newPauserRegistry common.Address) (*types.Transaction, error)

+ func (_StrategyBase *StrategyBaseSession) Shares(user common.Address) (*big.Int, error)

+ func (_StrategyBase *StrategyBaseSession) SharesToUnderlying(amountShares *big.Int) (*big.Int, error)

+ func (_StrategyBase *StrategyBaseSession) SharesToUnderlyingView(amountShares *big.Int) (*big.Int, error)

+ func (_StrategyBase *StrategyBaseSession) StrategyManager() (common.Address, error)

+ func (_StrategyBase *StrategyBaseSession) TotalShares() (*big.Int, error)

+ func (_StrategyBase *StrategyBaseSession) UnderlyingToShares(amountUnderlying *big.Int) (*big.Int, error)

+ func (_StrategyBase *StrategyBaseSession) UnderlyingToSharesView(amountUnderlying *big.Int) (*big.Int, error)

+ func (_StrategyBase *StrategyBaseSession) UnderlyingToken() (common.Address, error)

+ func (_StrategyBase *StrategyBaseSession) Unpause(newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_StrategyBase *StrategyBaseSession) UserUnderlying(user common.Address) (*types.Transaction, error)

+ func (_StrategyBase *StrategyBaseSession) UserUnderlyingView(user common.Address) (*big.Int, error)

+ func (_StrategyBase *StrategyBaseSession) Withdraw(recipient common.Address, token common.Address, amountShares *big.Int) (*types.Transaction, error)

+ type StrategyBaseTransactor struct

+ func NewStrategyBaseTransactor(address common.Address, transactor bind.ContractTransactor) (*StrategyBaseTransactor, error)

+ func (_StrategyBase *StrategyBaseTransactor) Deposit(opts *bind.TransactOpts, token common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_StrategyBase *StrategyBaseTransactor) Initialize(opts *bind.TransactOpts, _underlyingToken common.Address, ...) (*types.Transaction, error)

+ func (_StrategyBase *StrategyBaseTransactor) Pause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_StrategyBase *StrategyBaseTransactor) PauseAll(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_StrategyBase *StrategyBaseTransactor) SetPauserRegistry(opts *bind.TransactOpts, newPauserRegistry common.Address) (*types.Transaction, error)

+ func (_StrategyBase *StrategyBaseTransactor) Unpause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_StrategyBase *StrategyBaseTransactor) UserUnderlying(opts *bind.TransactOpts, user common.Address) (*types.Transaction, error)

+ func (_StrategyBase *StrategyBaseTransactor) Withdraw(opts *bind.TransactOpts, recipient common.Address, token common.Address, ...) (*types.Transaction, error)

+ type StrategyBaseTransactorRaw struct

+ Contract *StrategyBaseTransactor

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

+ func (_StrategyBase *StrategyBaseTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type StrategyBaseTransactorSession struct

+ Contract *StrategyBaseTransactor

+ TransactOpts bind.TransactOpts

+ func (_StrategyBase *StrategyBaseTransactorSession) Deposit(token common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_StrategyBase *StrategyBaseTransactorSession) Initialize(_underlyingToken common.Address, _pauserRegistry common.Address) (*types.Transaction, error)

+ func (_StrategyBase *StrategyBaseTransactorSession) Pause(newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_StrategyBase *StrategyBaseTransactorSession) PauseAll() (*types.Transaction, error)

+ func (_StrategyBase *StrategyBaseTransactorSession) SetPauserRegistry(newPauserRegistry common.Address) (*types.Transaction, error)

+ func (_StrategyBase *StrategyBaseTransactorSession) Unpause(newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_StrategyBase *StrategyBaseTransactorSession) UserUnderlying(user common.Address) (*types.Transaction, error)

+ func (_StrategyBase *StrategyBaseTransactorSession) Withdraw(recipient common.Address, token common.Address, amountShares *big.Int) (*types.Transaction, error)

+ type StrategyBaseUnpaused struct

+ Account common.Address

+ NewPausedStatus *big.Int

+ Raw types.Log

+ type StrategyBaseUnpausedIterator struct

+ Event *StrategyBaseUnpaused

+ func (it *StrategyBaseUnpausedIterator) Close() error

+ func (it *StrategyBaseUnpausedIterator) Error() error

+ func (it *StrategyBaseUnpausedIterator) Next() bool

+ type StrategyManager struct

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

+ func NewStrategyManager(address common.Address, backend bind.ContractBackend) (*StrategyManager, error)

+ type StrategyManagerCaller struct

+ func NewStrategyManagerCaller(address common.Address, caller bind.ContractCaller) (*StrategyManagerCaller, error)

+ func (_StrategyManager *StrategyManagerCaller) CalculateWithdrawalRoot(opts *bind.CallOpts, ...) ([32]byte, error)

+ func (_StrategyManager *StrategyManagerCaller) DEPOSITTYPEHASH(opts *bind.CallOpts) ([32]byte, error)

+ func (_StrategyManager *StrategyManagerCaller) DOMAINTYPEHASH(opts *bind.CallOpts) ([32]byte, error)

+ func (_StrategyManager *StrategyManagerCaller) Delegation(opts *bind.CallOpts) (common.Address, error)

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

+ func (_StrategyManager *StrategyManagerCaller) EigenPodManager(opts *bind.CallOpts) (common.Address, error)

+ func (_StrategyManager *StrategyManagerCaller) GetDeposits(opts *bind.CallOpts, staker common.Address) ([]common.Address, []*big.Int, error)

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

+ func (_StrategyManager *StrategyManagerCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_StrategyManager *StrategyManagerCaller) Paused(opts *bind.CallOpts, index uint8) (bool, error)

+ func (_StrategyManager *StrategyManagerCaller) Paused0(opts *bind.CallOpts) (*big.Int, error)

+ func (_StrategyManager *StrategyManagerCaller) PauserRegistry(opts *bind.CallOpts) (common.Address, error)

+ func (_StrategyManager *StrategyManagerCaller) Slasher(opts *bind.CallOpts) (common.Address, error)

+ func (_StrategyManager *StrategyManagerCaller) StakerStrategyList(opts *bind.CallOpts, arg0 common.Address, arg1 *big.Int) (common.Address, error)

+ func (_StrategyManager *StrategyManagerCaller) StakerStrategyListLength(opts *bind.CallOpts, staker common.Address) (*big.Int, error)

+ func (_StrategyManager *StrategyManagerCaller) StakerStrategyShares(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_StrategyManager *StrategyManagerCaller) StrategyIsWhitelistedForDeposit(opts *bind.CallOpts, arg0 common.Address) (bool, error)

+ func (_StrategyManager *StrategyManagerCaller) StrategyWhitelister(opts *bind.CallOpts) (common.Address, error)

+ func (_StrategyManager *StrategyManagerCaller) ThirdPartyTransfersForbidden(opts *bind.CallOpts, arg0 common.Address) (bool, error)

+ func (_StrategyManager *StrategyManagerCaller) WithdrawalRootPending(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ type StrategyManagerCallerRaw struct

+ Contract *StrategyManagerCaller

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

+ type StrategyManagerCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *StrategyManagerCaller

+ func (_StrategyManager *StrategyManagerCallerSession) CalculateWithdrawalRoot(queuedWithdrawal IStrategyManagerDeprecatedStructQueuedWithdrawal) ([32]byte, error)

+ func (_StrategyManager *StrategyManagerCallerSession) DEPOSITTYPEHASH() ([32]byte, error)

+ func (_StrategyManager *StrategyManagerCallerSession) DOMAINTYPEHASH() ([32]byte, error)

+ func (_StrategyManager *StrategyManagerCallerSession) Delegation() (common.Address, error)

+ func (_StrategyManager *StrategyManagerCallerSession) DomainSeparator() ([32]byte, error)

+ func (_StrategyManager *StrategyManagerCallerSession) EigenPodManager() (common.Address, error)

+ func (_StrategyManager *StrategyManagerCallerSession) GetDeposits(staker common.Address) ([]common.Address, []*big.Int, error)

+ func (_StrategyManager *StrategyManagerCallerSession) Nonces(arg0 common.Address) (*big.Int, error)

+ func (_StrategyManager *StrategyManagerCallerSession) Owner() (common.Address, error)

+ func (_StrategyManager *StrategyManagerCallerSession) Paused(index uint8) (bool, error)

+ func (_StrategyManager *StrategyManagerCallerSession) Paused0() (*big.Int, error)

+ func (_StrategyManager *StrategyManagerCallerSession) PauserRegistry() (common.Address, error)

+ func (_StrategyManager *StrategyManagerCallerSession) Slasher() (common.Address, error)

+ func (_StrategyManager *StrategyManagerCallerSession) StakerStrategyList(arg0 common.Address, arg1 *big.Int) (common.Address, error)

+ func (_StrategyManager *StrategyManagerCallerSession) StakerStrategyListLength(staker common.Address) (*big.Int, error)

+ func (_StrategyManager *StrategyManagerCallerSession) StakerStrategyShares(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_StrategyManager *StrategyManagerCallerSession) StrategyIsWhitelistedForDeposit(arg0 common.Address) (bool, error)

+ func (_StrategyManager *StrategyManagerCallerSession) StrategyWhitelister() (common.Address, error)

+ func (_StrategyManager *StrategyManagerCallerSession) ThirdPartyTransfersForbidden(arg0 common.Address) (bool, error)

+ func (_StrategyManager *StrategyManagerCallerSession) WithdrawalRootPending(arg0 [32]byte) (bool, error)

+ type StrategyManagerDeposit struct

+ Raw types.Log

+ Shares *big.Int

+ Staker common.Address

+ Strategy common.Address

+ Token common.Address

+ type StrategyManagerDepositIterator struct

+ Event *StrategyManagerDeposit

+ func (it *StrategyManagerDepositIterator) Close() error

+ func (it *StrategyManagerDepositIterator) Error() error

+ func (it *StrategyManagerDepositIterator) Next() bool

+ type StrategyManagerFilterer struct

+ func NewStrategyManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*StrategyManagerFilterer, error)

+ func (_StrategyManager *StrategyManagerFilterer) FilterDeposit(opts *bind.FilterOpts) (*StrategyManagerDepositIterator, error)

+ func (_StrategyManager *StrategyManagerFilterer) FilterInitialized(opts *bind.FilterOpts) (*StrategyManagerInitializedIterator, error)

+ func (_StrategyManager *StrategyManagerFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*StrategyManagerOwnershipTransferredIterator, error)

+ func (_StrategyManager *StrategyManagerFilterer) FilterPaused(opts *bind.FilterOpts, account []common.Address) (*StrategyManagerPausedIterator, error)

+ func (_StrategyManager *StrategyManagerFilterer) FilterPauserRegistrySet(opts *bind.FilterOpts) (*StrategyManagerPauserRegistrySetIterator, error)

+ func (_StrategyManager *StrategyManagerFilterer) FilterStrategyAddedToDepositWhitelist(opts *bind.FilterOpts) (*StrategyManagerStrategyAddedToDepositWhitelistIterator, error)

+ func (_StrategyManager *StrategyManagerFilterer) FilterStrategyRemovedFromDepositWhitelist(opts *bind.FilterOpts) (*StrategyManagerStrategyRemovedFromDepositWhitelistIterator, error)

+ func (_StrategyManager *StrategyManagerFilterer) FilterStrategyWhitelisterChanged(opts *bind.FilterOpts) (*StrategyManagerStrategyWhitelisterChangedIterator, error)

+ func (_StrategyManager *StrategyManagerFilterer) FilterUnpaused(opts *bind.FilterOpts, account []common.Address) (*StrategyManagerUnpausedIterator, error)

+ func (_StrategyManager *StrategyManagerFilterer) FilterUpdatedThirdPartyTransfersForbidden(opts *bind.FilterOpts) (*StrategyManagerUpdatedThirdPartyTransfersForbiddenIterator, error)

+ func (_StrategyManager *StrategyManagerFilterer) ParseDeposit(log types.Log) (*StrategyManagerDeposit, error)

+ func (_StrategyManager *StrategyManagerFilterer) ParseInitialized(log types.Log) (*StrategyManagerInitialized, error)

+ func (_StrategyManager *StrategyManagerFilterer) ParseOwnershipTransferred(log types.Log) (*StrategyManagerOwnershipTransferred, error)

+ func (_StrategyManager *StrategyManagerFilterer) ParsePaused(log types.Log) (*StrategyManagerPaused, error)

+ func (_StrategyManager *StrategyManagerFilterer) ParsePauserRegistrySet(log types.Log) (*StrategyManagerPauserRegistrySet, error)

+ func (_StrategyManager *StrategyManagerFilterer) ParseStrategyAddedToDepositWhitelist(log types.Log) (*StrategyManagerStrategyAddedToDepositWhitelist, error)

+ func (_StrategyManager *StrategyManagerFilterer) ParseStrategyRemovedFromDepositWhitelist(log types.Log) (*StrategyManagerStrategyRemovedFromDepositWhitelist, error)

+ func (_StrategyManager *StrategyManagerFilterer) ParseStrategyWhitelisterChanged(log types.Log) (*StrategyManagerStrategyWhitelisterChanged, error)

+ func (_StrategyManager *StrategyManagerFilterer) ParseUnpaused(log types.Log) (*StrategyManagerUnpaused, error)

+ func (_StrategyManager *StrategyManagerFilterer) ParseUpdatedThirdPartyTransfersForbidden(log types.Log) (*StrategyManagerUpdatedThirdPartyTransfersForbidden, error)

+ func (_StrategyManager *StrategyManagerFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *StrategyManagerDeposit) (event.Subscription, error)

+ func (_StrategyManager *StrategyManagerFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *StrategyManagerInitialized) (event.Subscription, error)

+ func (_StrategyManager *StrategyManagerFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *StrategyManagerOwnershipTransferred, ...) (event.Subscription, error)

+ func (_StrategyManager *StrategyManagerFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *StrategyManagerPaused, ...) (event.Subscription, error)

+ func (_StrategyManager *StrategyManagerFilterer) WatchPauserRegistrySet(opts *bind.WatchOpts, sink chan<- *StrategyManagerPauserRegistrySet) (event.Subscription, error)

+ func (_StrategyManager *StrategyManagerFilterer) WatchStrategyAddedToDepositWhitelist(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ func (_StrategyManager *StrategyManagerFilterer) WatchStrategyRemovedFromDepositWhitelist(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ func (_StrategyManager *StrategyManagerFilterer) WatchStrategyWhitelisterChanged(opts *bind.WatchOpts, sink chan<- *StrategyManagerStrategyWhitelisterChanged) (event.Subscription, error)

+ func (_StrategyManager *StrategyManagerFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *StrategyManagerUnpaused, ...) (event.Subscription, error)

+ func (_StrategyManager *StrategyManagerFilterer) WatchUpdatedThirdPartyTransfersForbidden(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ type StrategyManagerInitialized struct

+ Raw types.Log

+ Version uint8

+ type StrategyManagerInitializedIterator struct

+ Event *StrategyManagerInitialized

+ func (it *StrategyManagerInitializedIterator) Close() error

+ func (it *StrategyManagerInitializedIterator) Error() error

+ func (it *StrategyManagerInitializedIterator) Next() bool

+ type StrategyManagerOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type StrategyManagerOwnershipTransferredIterator struct

+ Event *StrategyManagerOwnershipTransferred

+ func (it *StrategyManagerOwnershipTransferredIterator) Close() error

+ func (it *StrategyManagerOwnershipTransferredIterator) Error() error

+ func (it *StrategyManagerOwnershipTransferredIterator) Next() bool

+ type StrategyManagerPaused struct

+ Account common.Address

+ NewPausedStatus *big.Int

+ Raw types.Log

+ type StrategyManagerPausedIterator struct

+ Event *StrategyManagerPaused

+ func (it *StrategyManagerPausedIterator) Close() error

+ func (it *StrategyManagerPausedIterator) Error() error

+ func (it *StrategyManagerPausedIterator) Next() bool

+ type StrategyManagerPauserRegistrySet struct

+ NewPauserRegistry common.Address

+ PauserRegistry common.Address

+ Raw types.Log

+ type StrategyManagerPauserRegistrySetIterator struct

+ Event *StrategyManagerPauserRegistrySet

+ func (it *StrategyManagerPauserRegistrySetIterator) Close() error

+ func (it *StrategyManagerPauserRegistrySetIterator) Error() error

+ func (it *StrategyManagerPauserRegistrySetIterator) Next() bool

+ type StrategyManagerRaw struct

+ Contract *StrategyManager

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

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

+ func (_StrategyManager *StrategyManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type StrategyManagerSession struct

+ CallOpts bind.CallOpts

+ Contract *StrategyManager

+ TransactOpts bind.TransactOpts

+ func (_StrategyManager *StrategyManagerSession) AddShares(staker common.Address, token common.Address, strategy common.Address, ...) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerSession) AddStrategiesToDepositWhitelist(strategiesToWhitelist []common.Address, ...) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerSession) CalculateWithdrawalRoot(queuedWithdrawal IStrategyManagerDeprecatedStructQueuedWithdrawal) ([32]byte, error)

+ func (_StrategyManager *StrategyManagerSession) DEPOSITTYPEHASH() ([32]byte, error)

+ func (_StrategyManager *StrategyManagerSession) DOMAINTYPEHASH() ([32]byte, error)

+ func (_StrategyManager *StrategyManagerSession) Delegation() (common.Address, error)

+ func (_StrategyManager *StrategyManagerSession) DepositIntoStrategy(strategy common.Address, token common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerSession) DepositIntoStrategyWithSignature(strategy common.Address, token common.Address, amount *big.Int, ...) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerSession) DomainSeparator() ([32]byte, error)

+ func (_StrategyManager *StrategyManagerSession) EigenPodManager() (common.Address, error)

+ func (_StrategyManager *StrategyManagerSession) GetDeposits(staker common.Address) ([]common.Address, []*big.Int, error)

+ func (_StrategyManager *StrategyManagerSession) Initialize(initialOwner common.Address, initialStrategyWhitelister common.Address, ...) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerSession) MigrateQueuedWithdrawal(queuedWithdrawal IStrategyManagerDeprecatedStructQueuedWithdrawal) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerSession) Nonces(arg0 common.Address) (*big.Int, error)

+ func (_StrategyManager *StrategyManagerSession) Owner() (common.Address, error)

+ func (_StrategyManager *StrategyManagerSession) Pause(newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerSession) PauseAll() (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerSession) Paused(index uint8) (bool, error)

+ func (_StrategyManager *StrategyManagerSession) Paused0() (*big.Int, error)

+ func (_StrategyManager *StrategyManagerSession) PauserRegistry() (common.Address, error)

+ func (_StrategyManager *StrategyManagerSession) RemoveShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerSession) RemoveStrategiesFromDepositWhitelist(strategiesToRemoveFromWhitelist []common.Address) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerSession) RenounceOwnership() (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerSession) SetPauserRegistry(newPauserRegistry common.Address) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerSession) SetStrategyWhitelister(newStrategyWhitelister common.Address) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerSession) SetThirdPartyTransfersForbidden(strategy common.Address, value bool) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerSession) Slasher() (common.Address, error)

+ func (_StrategyManager *StrategyManagerSession) StakerStrategyList(arg0 common.Address, arg1 *big.Int) (common.Address, error)

+ func (_StrategyManager *StrategyManagerSession) StakerStrategyListLength(staker common.Address) (*big.Int, error)

+ func (_StrategyManager *StrategyManagerSession) StakerStrategyShares(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_StrategyManager *StrategyManagerSession) StrategyIsWhitelistedForDeposit(arg0 common.Address) (bool, error)

+ func (_StrategyManager *StrategyManagerSession) StrategyWhitelister() (common.Address, error)

+ func (_StrategyManager *StrategyManagerSession) ThirdPartyTransfersForbidden(arg0 common.Address) (bool, error)

+ func (_StrategyManager *StrategyManagerSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerSession) Unpause(newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerSession) WithdrawSharesAsTokens(recipient common.Address, strategy common.Address, shares *big.Int, ...) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerSession) WithdrawalRootPending(arg0 [32]byte) (bool, error)

+ type StrategyManagerStrategyAddedToDepositWhitelist struct

+ Raw types.Log

+ Strategy common.Address

+ type StrategyManagerStrategyAddedToDepositWhitelistIterator struct

+ Event *StrategyManagerStrategyAddedToDepositWhitelist

+ func (it *StrategyManagerStrategyAddedToDepositWhitelistIterator) Close() error

+ func (it *StrategyManagerStrategyAddedToDepositWhitelistIterator) Error() error

+ func (it *StrategyManagerStrategyAddedToDepositWhitelistIterator) Next() bool

+ type StrategyManagerStrategyRemovedFromDepositWhitelist struct

+ Raw types.Log

+ Strategy common.Address

+ type StrategyManagerStrategyRemovedFromDepositWhitelistIterator struct

+ Event *StrategyManagerStrategyRemovedFromDepositWhitelist

+ func (it *StrategyManagerStrategyRemovedFromDepositWhitelistIterator) Close() error

+ func (it *StrategyManagerStrategyRemovedFromDepositWhitelistIterator) Error() error

+ func (it *StrategyManagerStrategyRemovedFromDepositWhitelistIterator) Next() bool

+ type StrategyManagerStrategyWhitelisterChanged struct

+ NewAddress common.Address

+ PreviousAddress common.Address

+ Raw types.Log

+ type StrategyManagerStrategyWhitelisterChangedIterator struct

+ Event *StrategyManagerStrategyWhitelisterChanged

+ func (it *StrategyManagerStrategyWhitelisterChangedIterator) Close() error

+ func (it *StrategyManagerStrategyWhitelisterChangedIterator) Error() error

+ func (it *StrategyManagerStrategyWhitelisterChangedIterator) Next() bool

+ type StrategyManagerTransactor struct

+ func NewStrategyManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*StrategyManagerTransactor, error)

+ func (_StrategyManager *StrategyManagerTransactor) AddShares(opts *bind.TransactOpts, staker common.Address, token common.Address, ...) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactor) AddStrategiesToDepositWhitelist(opts *bind.TransactOpts, strategiesToWhitelist []common.Address, ...) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactor) DepositIntoStrategy(opts *bind.TransactOpts, strategy common.Address, token common.Address, ...) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactor) DepositIntoStrategyWithSignature(opts *bind.TransactOpts, strategy common.Address, token common.Address, ...) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactor) Initialize(opts *bind.TransactOpts, initialOwner common.Address, ...) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactor) MigrateQueuedWithdrawal(opts *bind.TransactOpts, ...) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactor) Pause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactor) PauseAll(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactor) RemoveShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, ...) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactor) RemoveStrategiesFromDepositWhitelist(opts *bind.TransactOpts, strategiesToRemoveFromWhitelist []common.Address) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactor) SetPauserRegistry(opts *bind.TransactOpts, newPauserRegistry common.Address) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactor) SetStrategyWhitelister(opts *bind.TransactOpts, newStrategyWhitelister common.Address) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactor) SetThirdPartyTransfersForbidden(opts *bind.TransactOpts, strategy common.Address, value bool) (*types.Transaction, error)

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

+ func (_StrategyManager *StrategyManagerTransactor) Unpause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactor) WithdrawSharesAsTokens(opts *bind.TransactOpts, recipient common.Address, strategy common.Address, ...) (*types.Transaction, error)

+ type StrategyManagerTransactorRaw struct

+ Contract *StrategyManagerTransactor

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

+ func (_StrategyManager *StrategyManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type StrategyManagerTransactorSession struct

+ Contract *StrategyManagerTransactor

+ TransactOpts bind.TransactOpts

+ func (_StrategyManager *StrategyManagerTransactorSession) AddShares(staker common.Address, token common.Address, strategy common.Address, ...) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactorSession) AddStrategiesToDepositWhitelist(strategiesToWhitelist []common.Address, ...) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactorSession) DepositIntoStrategy(strategy common.Address, token common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactorSession) DepositIntoStrategyWithSignature(strategy common.Address, token common.Address, amount *big.Int, ...) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactorSession) Initialize(initialOwner common.Address, initialStrategyWhitelister common.Address, ...) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactorSession) MigrateQueuedWithdrawal(queuedWithdrawal IStrategyManagerDeprecatedStructQueuedWithdrawal) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactorSession) Pause(newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactorSession) PauseAll() (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactorSession) RemoveShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactorSession) RemoveStrategiesFromDepositWhitelist(strategiesToRemoveFromWhitelist []common.Address) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactorSession) SetPauserRegistry(newPauserRegistry common.Address) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactorSession) SetStrategyWhitelister(newStrategyWhitelister common.Address) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactorSession) SetThirdPartyTransfersForbidden(strategy common.Address, value bool) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactorSession) Unpause(newPausedStatus *big.Int) (*types.Transaction, error)

+ func (_StrategyManager *StrategyManagerTransactorSession) WithdrawSharesAsTokens(recipient common.Address, strategy common.Address, shares *big.Int, ...) (*types.Transaction, error)

+ type StrategyManagerUnpaused struct

+ Account common.Address

+ NewPausedStatus *big.Int

+ Raw types.Log

+ type StrategyManagerUnpausedIterator struct

+ Event *StrategyManagerUnpaused

+ func (it *StrategyManagerUnpausedIterator) Close() error

+ func (it *StrategyManagerUnpausedIterator) Error() error

+ func (it *StrategyManagerUnpausedIterator) Next() bool

+ type StrategyManagerUpdatedThirdPartyTransfersForbidden struct

+ Raw types.Log

+ Strategy common.Address

+ Value bool

+ type StrategyManagerUpdatedThirdPartyTransfersForbiddenIterator struct

+ Event *StrategyManagerUpdatedThirdPartyTransfersForbidden

+ func (it *StrategyManagerUpdatedThirdPartyTransfersForbiddenIterator) Close() error

+ func (it *StrategyManagerUpdatedThirdPartyTransfersForbiddenIterator) Error() error

+ func (it *StrategyManagerUpdatedThirdPartyTransfersForbiddenIterator) Next() bool

+ type TransparentUpgradeableProxy struct

+ func DeployTransparentUpgradeableProxy(auth *bind.TransactOpts, backend bind.ContractBackend, _logic common.Address, ...) (common.Address, *types.Transaction, *TransparentUpgradeableProxy, error)

+ func NewTransparentUpgradeableProxy(address common.Address, backend bind.ContractBackend) (*TransparentUpgradeableProxy, error)

+ type TransparentUpgradeableProxyAdminChanged struct

+ NewAdmin common.Address

+ PreviousAdmin common.Address

+ Raw types.Log

+ type TransparentUpgradeableProxyAdminChangedIterator struct

+ Event *TransparentUpgradeableProxyAdminChanged

+ func (it *TransparentUpgradeableProxyAdminChangedIterator) Close() error

+ func (it *TransparentUpgradeableProxyAdminChangedIterator) Error() error

+ func (it *TransparentUpgradeableProxyAdminChangedIterator) Next() bool

+ type TransparentUpgradeableProxyCaller struct

+ func NewTransparentUpgradeableProxyCaller(address common.Address, caller bind.ContractCaller) (*TransparentUpgradeableProxyCaller, error)

+ type TransparentUpgradeableProxyCallerRaw struct

+ Contract *TransparentUpgradeableProxyCaller

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

+ type TransparentUpgradeableProxyCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *TransparentUpgradeableProxyCaller

+ type TransparentUpgradeableProxyFilterer struct

+ func NewTransparentUpgradeableProxyFilterer(address common.Address, filterer bind.ContractFilterer) (*TransparentUpgradeableProxyFilterer, error)

+ func (_TransparentUpgradeableProxy *TransparentUpgradeableProxyFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*TransparentUpgradeableProxyAdminChangedIterator, error)

+ func (_TransparentUpgradeableProxy *TransparentUpgradeableProxyFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*TransparentUpgradeableProxyUpgradedIterator, error)

+ func (_TransparentUpgradeableProxy *TransparentUpgradeableProxyFilterer) ParseAdminChanged(log types.Log) (*TransparentUpgradeableProxyAdminChanged, error)

+ func (_TransparentUpgradeableProxy *TransparentUpgradeableProxyFilterer) ParseUpgraded(log types.Log) (*TransparentUpgradeableProxyUpgraded, error)

+ func (_TransparentUpgradeableProxy *TransparentUpgradeableProxyFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *TransparentUpgradeableProxyAdminChanged) (event.Subscription, error)

+ func (_TransparentUpgradeableProxy *TransparentUpgradeableProxyFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *TransparentUpgradeableProxyUpgraded, ...) (event.Subscription, error)

+ type TransparentUpgradeableProxyRaw struct

+ Contract *TransparentUpgradeableProxy

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

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

+ func (_TransparentUpgradeableProxy *TransparentUpgradeableProxyRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type TransparentUpgradeableProxySession struct

+ CallOpts bind.CallOpts

+ Contract *TransparentUpgradeableProxy

+ TransactOpts bind.TransactOpts

+ func (_TransparentUpgradeableProxy *TransparentUpgradeableProxySession) Fallback(calldata []byte) (*types.Transaction, error)

+ type TransparentUpgradeableProxyTransactor struct

+ func NewTransparentUpgradeableProxyTransactor(address common.Address, transactor bind.ContractTransactor) (*TransparentUpgradeableProxyTransactor, error)

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

+ type TransparentUpgradeableProxyTransactorRaw struct

+ Contract *TransparentUpgradeableProxyTransactor

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

+ func (_TransparentUpgradeableProxy *TransparentUpgradeableProxyTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type TransparentUpgradeableProxyTransactorSession struct

+ Contract *TransparentUpgradeableProxyTransactor

+ TransactOpts bind.TransactOpts

+ func (_TransparentUpgradeableProxy *TransparentUpgradeableProxyTransactorSession) Fallback(calldata []byte) (*types.Transaction, error)

+ type TransparentUpgradeableProxyUpgraded struct

+ Implementation common.Address

+ Raw types.Log

+ type TransparentUpgradeableProxyUpgradedIterator struct

+ Event *TransparentUpgradeableProxyUpgraded

+ func (it *TransparentUpgradeableProxyUpgradedIterator) Close() error

+ func (it *TransparentUpgradeableProxyUpgradedIterator) Error() error

+ func (it *TransparentUpgradeableProxyUpgradedIterator) Next() bool

+ type Upgrade struct

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

+ func NewUpgrade(address common.Address, backend bind.ContractBackend) (*Upgrade, error)

+ type UpgradeCaller struct

+ func NewUpgradeCaller(address common.Address, caller bind.ContractCaller) (*UpgradeCaller, error)

+ func (_Upgrade *UpgradeCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ type UpgradeCallerRaw struct

+ Contract *UpgradeCaller

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

+ type UpgradeCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *UpgradeCaller

+ func (_Upgrade *UpgradeCallerSession) Owner() (common.Address, error)

+ type UpgradeCancelUpgrade struct

+ Raw types.Log

+ type UpgradeCancelUpgradeIterator struct

+ Event *UpgradeCancelUpgrade

+ func (it *UpgradeCancelUpgradeIterator) Close() error

+ func (it *UpgradeCancelUpgradeIterator) Error() error

+ func (it *UpgradeCancelUpgradeIterator) Next() bool

+ type UpgradeFilterer struct

+ func NewUpgradeFilterer(address common.Address, filterer bind.ContractFilterer) (*UpgradeFilterer, error)

+ func (_Upgrade *UpgradeFilterer) FilterCancelUpgrade(opts *bind.FilterOpts) (*UpgradeCancelUpgradeIterator, error)

+ func (_Upgrade *UpgradeFilterer) FilterInitialized(opts *bind.FilterOpts) (*UpgradeInitializedIterator, error)

+ func (_Upgrade *UpgradeFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*UpgradeOwnershipTransferredIterator, error)

+ func (_Upgrade *UpgradeFilterer) FilterPlanUpgrade(opts *bind.FilterOpts) (*UpgradePlanUpgradeIterator, error)

+ func (_Upgrade *UpgradeFilterer) ParseCancelUpgrade(log types.Log) (*UpgradeCancelUpgrade, error)

+ func (_Upgrade *UpgradeFilterer) ParseInitialized(log types.Log) (*UpgradeInitialized, error)

+ func (_Upgrade *UpgradeFilterer) ParseOwnershipTransferred(log types.Log) (*UpgradeOwnershipTransferred, error)

+ func (_Upgrade *UpgradeFilterer) ParsePlanUpgrade(log types.Log) (*UpgradePlanUpgrade, error)

+ func (_Upgrade *UpgradeFilterer) WatchCancelUpgrade(opts *bind.WatchOpts, sink chan<- *UpgradeCancelUpgrade) (event.Subscription, error)

+ func (_Upgrade *UpgradeFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *UpgradeInitialized) (event.Subscription, error)

+ func (_Upgrade *UpgradeFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *UpgradeOwnershipTransferred, ...) (event.Subscription, error)

+ func (_Upgrade *UpgradeFilterer) WatchPlanUpgrade(opts *bind.WatchOpts, sink chan<- *UpgradePlanUpgrade) (event.Subscription, error)

+ type UpgradeInitialized struct

+ Raw types.Log

+ Version uint64

+ type UpgradeInitializedIterator struct

+ Event *UpgradeInitialized

+ func (it *UpgradeInitializedIterator) Close() error

+ func (it *UpgradeInitializedIterator) Error() error

+ func (it *UpgradeInitializedIterator) Next() bool

+ type UpgradeOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type UpgradeOwnershipTransferredIterator struct

+ Event *UpgradeOwnershipTransferred

+ func (it *UpgradeOwnershipTransferredIterator) Close() error

+ func (it *UpgradeOwnershipTransferredIterator) Error() error

+ func (it *UpgradeOwnershipTransferredIterator) Next() bool

+ type UpgradePlan struct

+ Height uint64

+ Info string

+ Name string

+ type UpgradePlanUpgrade struct

+ Height uint64

+ Info string

+ Name string

+ Raw types.Log

+ type UpgradePlanUpgradeIterator struct

+ Event *UpgradePlanUpgrade

+ func (it *UpgradePlanUpgradeIterator) Close() error

+ func (it *UpgradePlanUpgradeIterator) Error() error

+ func (it *UpgradePlanUpgradeIterator) Next() bool

+ type UpgradeRaw struct

+ Contract *Upgrade

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

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

+ func (_Upgrade *UpgradeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type UpgradeSession struct

+ CallOpts bind.CallOpts

+ Contract *Upgrade

+ TransactOpts bind.TransactOpts

+ func (_Upgrade *UpgradeSession) CancelUpgrade() (*types.Transaction, error)

+ func (_Upgrade *UpgradeSession) Initialize(owner_ common.Address) (*types.Transaction, error)

+ func (_Upgrade *UpgradeSession) Owner() (common.Address, error)

+ func (_Upgrade *UpgradeSession) PlanUpgrade(plan UpgradePlan) (*types.Transaction, error)

+ func (_Upgrade *UpgradeSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Upgrade *UpgradeSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type UpgradeTransactor struct

+ func NewUpgradeTransactor(address common.Address, transactor bind.ContractTransactor) (*UpgradeTransactor, error)

+ func (_Upgrade *UpgradeTransactor) CancelUpgrade(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Upgrade *UpgradeTransactor) Initialize(opts *bind.TransactOpts, owner_ common.Address) (*types.Transaction, error)

+ func (_Upgrade *UpgradeTransactor) PlanUpgrade(opts *bind.TransactOpts, plan UpgradePlan) (*types.Transaction, error)

+ func (_Upgrade *UpgradeTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

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

+ type UpgradeTransactorRaw struct

+ Contract *UpgradeTransactor

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

+ func (_Upgrade *UpgradeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type UpgradeTransactorSession struct

+ Contract *UpgradeTransactor

+ TransactOpts bind.TransactOpts

+ func (_Upgrade *UpgradeTransactorSession) CancelUpgrade() (*types.Transaction, error)

+ func (_Upgrade *UpgradeTransactorSession) Initialize(owner_ common.Address) (*types.Transaction, error)

+ func (_Upgrade *UpgradeTransactorSession) PlanUpgrade(plan UpgradePlan) (*types.Transaction, error)

+ func (_Upgrade *UpgradeTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Upgrade *UpgradeTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type Validator = XTypesValidator

+ type ValidatorSigTuple = XTypesSigTuple

+ type WOmni struct

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

+ func NewWOmni(address common.Address, backend bind.ContractBackend) (*WOmni, error)

+ type WOmniApproval struct

+ Guy common.Address

+ Raw types.Log

+ Src common.Address

+ Wad *big.Int

+ type WOmniApprovalIterator struct

+ Event *WOmniApproval

+ func (it *WOmniApprovalIterator) Close() error

+ func (it *WOmniApprovalIterator) Error() error

+ func (it *WOmniApprovalIterator) Next() bool

+ type WOmniCaller struct

+ func NewWOmniCaller(address common.Address, caller bind.ContractCaller) (*WOmniCaller, error)

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

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

+ func (_WOmni *WOmniCaller) Decimals(opts *bind.CallOpts) (uint8, error)

+ func (_WOmni *WOmniCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_WOmni *WOmniCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_WOmni *WOmniCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type WOmniCallerRaw struct

+ Contract *WOmniCaller

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

+ type WOmniCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *WOmniCaller

+ func (_WOmni *WOmniCallerSession) Allowance(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_WOmni *WOmniCallerSession) BalanceOf(arg0 common.Address) (*big.Int, error)

+ func (_WOmni *WOmniCallerSession) Decimals() (uint8, error)

+ func (_WOmni *WOmniCallerSession) Name() (string, error)

+ func (_WOmni *WOmniCallerSession) Symbol() (string, error)

+ func (_WOmni *WOmniCallerSession) TotalSupply() (*big.Int, error)

+ type WOmniDeposit struct

+ Dst common.Address

+ Raw types.Log

+ Wad *big.Int

+ type WOmniDepositIterator struct

+ Event *WOmniDeposit

+ func (it *WOmniDepositIterator) Close() error

+ func (it *WOmniDepositIterator) Error() error

+ func (it *WOmniDepositIterator) Next() bool

+ type WOmniFilterer struct

+ func NewWOmniFilterer(address common.Address, filterer bind.ContractFilterer) (*WOmniFilterer, error)

+ func (_WOmni *WOmniFilterer) FilterApproval(opts *bind.FilterOpts, src []common.Address, guy []common.Address) (*WOmniApprovalIterator, error)

+ func (_WOmni *WOmniFilterer) FilterDeposit(opts *bind.FilterOpts, dst []common.Address) (*WOmniDepositIterator, error)

+ func (_WOmni *WOmniFilterer) FilterTransfer(opts *bind.FilterOpts, src []common.Address, dst []common.Address) (*WOmniTransferIterator, error)

+ func (_WOmni *WOmniFilterer) FilterWithdrawal(opts *bind.FilterOpts, src []common.Address) (*WOmniWithdrawalIterator, error)

+ func (_WOmni *WOmniFilterer) ParseApproval(log types.Log) (*WOmniApproval, error)

+ func (_WOmni *WOmniFilterer) ParseDeposit(log types.Log) (*WOmniDeposit, error)

+ func (_WOmni *WOmniFilterer) ParseTransfer(log types.Log) (*WOmniTransfer, error)

+ func (_WOmni *WOmniFilterer) ParseWithdrawal(log types.Log) (*WOmniWithdrawal, error)

+ func (_WOmni *WOmniFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *WOmniApproval, src []common.Address, ...) (event.Subscription, error)

+ func (_WOmni *WOmniFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *WOmniDeposit, dst []common.Address) (event.Subscription, error)

+ func (_WOmni *WOmniFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *WOmniTransfer, src []common.Address, ...) (event.Subscription, error)

+ func (_WOmni *WOmniFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *WOmniWithdrawal, src []common.Address) (event.Subscription, error)

+ type WOmniRaw struct

+ Contract *WOmni

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

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

+ func (_WOmni *WOmniRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type WOmniSession struct

+ CallOpts bind.CallOpts

+ Contract *WOmni

+ TransactOpts bind.TransactOpts

+ func (_WOmni *WOmniSession) Allowance(arg0 common.Address, arg1 common.Address) (*big.Int, error)

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

+ func (_WOmni *WOmniSession) BalanceOf(arg0 common.Address) (*big.Int, error)

+ func (_WOmni *WOmniSession) Decimals() (uint8, error)

+ func (_WOmni *WOmniSession) Deposit() (*types.Transaction, error)

+ func (_WOmni *WOmniSession) Fallback(calldata []byte) (*types.Transaction, error)

+ func (_WOmni *WOmniSession) Name() (string, error)

+ func (_WOmni *WOmniSession) Receive() (*types.Transaction, error)

+ func (_WOmni *WOmniSession) Symbol() (string, error)

+ func (_WOmni *WOmniSession) TotalSupply() (*big.Int, error)

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

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

+ func (_WOmni *WOmniSession) Withdraw(wad *big.Int) (*types.Transaction, error)

+ type WOmniTransactor struct

+ func NewWOmniTransactor(address common.Address, transactor bind.ContractTransactor) (*WOmniTransactor, error)

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

+ func (_WOmni *WOmniTransactor) Deposit(opts *bind.TransactOpts) (*types.Transaction, error)

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

+ func (_WOmni *WOmniTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

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

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

+ func (_WOmni *WOmniTransactor) Withdraw(opts *bind.TransactOpts, wad *big.Int) (*types.Transaction, error)

+ type WOmniTransactorRaw struct

+ Contract *WOmniTransactor

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

+ func (_WOmni *WOmniTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type WOmniTransactorSession struct

+ Contract *WOmniTransactor

+ TransactOpts bind.TransactOpts

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

+ func (_WOmni *WOmniTransactorSession) Deposit() (*types.Transaction, error)

+ func (_WOmni *WOmniTransactorSession) Fallback(calldata []byte) (*types.Transaction, error)

+ func (_WOmni *WOmniTransactorSession) Receive() (*types.Transaction, error)

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

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

+ func (_WOmni *WOmniTransactorSession) Withdraw(wad *big.Int) (*types.Transaction, error)

+ type WOmniTransfer struct

+ Dst common.Address

+ Raw types.Log

+ Src common.Address

+ Wad *big.Int

+ type WOmniTransferIterator struct

+ Event *WOmniTransfer

+ func (it *WOmniTransferIterator) Close() error

+ func (it *WOmniTransferIterator) Error() error

+ func (it *WOmniTransferIterator) Next() bool

+ type WOmniWithdrawal struct

+ Raw types.Log

+ Src common.Address

+ Wad *big.Int

+ type WOmniWithdrawalIterator struct

+ Event *WOmniWithdrawal

+ func (it *WOmniWithdrawalIterator) Close() error

+ func (it *WOmniWithdrawalIterator) Error() error

+ func (it *WOmniWithdrawalIterator) Next() bool

+ type XBlockHeader = XTypesBlockHeader

+ type XMsg = XTypesMsg

+ type XSubmission = XTypesSubmission

+ type XTypesBlockHeader struct

+ ConfLevel uint8

+ ConsensusChainId uint64

+ Offset uint64

+ SourceBlockHash [32]byte

+ SourceBlockHeight uint64

+ SourceChainId uint64

+ type XTypesChain struct

+ ChainId uint64

+ Shards []uint64

+ type XTypesMsg struct

+ Data []byte

+ DestChainId uint64

+ GasLimit uint64

+ Offset uint64

+ Sender common.Address

+ ShardId uint64

+ To common.Address

+ type XTypesMsgContext struct

+ Sender common.Address

+ SourceChainId uint64

+ type XTypesSigTuple struct

+ Signature []byte

+ ValidatorAddr common.Address

+ type XTypesSubmission struct

+ AttestationRoot [32]byte

+ BlockHeader XTypesBlockHeader

+ Msgs []XTypesMsg

+ Proof [][32]byte

+ ProofFlags []bool

+ Signatures []XTypesSigTuple

+ ValidatorSetId uint64

+ type XTypesValidator struct

+ Addr common.Address

+ Power uint64

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