interchainclient

package

Go to main page

Versions in this module

v0

v0.14.0

Jun 4, 2024

v0.13.7

Jun 1, 2024

v0.13.6

Jun 1, 2024

v0.13.5

May 31, 2024

v0.13.4

May 31, 2024

v0.13.3

May 31, 2024

v0.13.2

May 31, 2024

v0.13.1

May 31, 2024

v0.13.0

May 21, 2024

v0.12.2

May 14, 2024

v0.12.1

May 14, 2024

v0.12.0

May 14, 2024

v0.11.0

May 9, 2024

v0.10.0

May 6, 2024

Changes in this version

+ var BatchingV1LibABI = BatchingV1LibMetaData.ABI

+ var BatchingV1LibBin = BatchingV1LibMetaData.Bin

+ var BatchingV1LibMetaData = &bind.MetaData

type AppConfigV1

+ Guard common.Address

+ GuardFlag *big.Int

+ type BatchingV1Lib struct

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

+ func NewBatchingV1Lib(address common.Address, backend bind.ContractBackend) (*BatchingV1Lib, error)

+ type BatchingV1LibCaller struct

+ func NewBatchingV1LibCaller(address common.Address, caller bind.ContractCaller) (*BatchingV1LibCaller, error)

+ type BatchingV1LibCallerRaw struct

+ Contract *BatchingV1LibCaller

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

+ type BatchingV1LibCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *BatchingV1LibCaller

+ type BatchingV1LibFilterer struct

+ func NewBatchingV1LibFilterer(address common.Address, filterer bind.ContractFilterer) (*BatchingV1LibFilterer, error)

+ type BatchingV1LibRaw struct

+ Contract *BatchingV1Lib

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

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

+ func (_BatchingV1Lib *BatchingV1LibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BatchingV1LibSession struct

+ CallOpts bind.CallOpts

+ Contract *BatchingV1Lib

+ TransactOpts bind.TransactOpts

+ type BatchingV1LibTransactor struct

+ func NewBatchingV1LibTransactor(address common.Address, transactor bind.ContractTransactor) (*BatchingV1LibTransactor, error)

+ type BatchingV1LibTransactorRaw struct

+ Contract *BatchingV1LibTransactor

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

+ func (_BatchingV1Lib *BatchingV1LibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BatchingV1LibTransactorSession struct

+ Contract *BatchingV1LibTransactor

+ TransactOpts bind.TransactOpts

type IExecutionServiceSession

+ func (_IExecutionService *IExecutionServiceSession) RequestTxExecution(dstChainId uint64, txPayloadSize *big.Int, transactionId [32]byte, ...) (*types.Transaction, error)

type IExecutionServiceTransactor

+ func (_IExecutionService *IExecutionServiceTransactor) RequestTxExecution(opts *bind.TransactOpts, dstChainId uint64, txPayloadSize *big.Int, ...) (*types.Transaction, error)

type IExecutionServiceTransactorSession

+ func (_IExecutionService *IExecutionServiceTransactorSession) RequestTxExecution(dstChainId uint64, txPayloadSize *big.Int, transactionId [32]byte, ...) (*types.Transaction, error)

type IInterchainClientV1Caller

+ func (_IInterchainClientV1 *IInterchainClientV1Caller) GetTxReadinessV1(opts *bind.CallOpts, icTx InterchainTransaction, proof [][32]byte) (struct{ ... }, error)

type IInterchainClientV1CallerSession

+ func (_IInterchainClientV1 *IInterchainClientV1CallerSession) GetTxReadinessV1(icTx InterchainTransaction, proof [][32]byte) (struct{ ... }, error)

type IInterchainClientV1Session

+ func (_IInterchainClientV1 *IInterchainClientV1Session) GetTxReadinessV1(icTx InterchainTransaction, proof [][32]byte) (struct{ ... }, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Session) SetDefaultGuard(guard_ common.Address) (*types.Transaction, error)

type IInterchainClientV1Transactor

+ func (_IInterchainClientV1 *IInterchainClientV1Transactor) SetDefaultGuard(opts *bind.TransactOpts, guard_ common.Address) (*types.Transaction, error)

type IInterchainClientV1TransactorSession

+ func (_IInterchainClientV1 *IInterchainClientV1TransactorSession) SetDefaultGuard(guard_ common.Address) (*types.Transaction, error)

type IInterchainDBCaller

+ func (_IInterchainDB *IInterchainDBCaller) CheckBatchVerification(opts *bind.CallOpts, dstModule common.Address, batch InterchainBatch) (*big.Int, error)

+ func (_IInterchainDB *IInterchainDBCaller) GetBatchRoot(opts *bind.CallOpts, entry InterchainEntry, proof [][32]byte) ([32]byte, error)

+ func (_IInterchainDB *IInterchainDBCaller) GetVersionedBatch(opts *bind.CallOpts, dbNonce uint64) ([]byte, error)

type IInterchainDBCallerSession

+ func (_IInterchainDB *IInterchainDBCallerSession) CheckBatchVerification(dstModule common.Address, batch InterchainBatch) (*big.Int, error)

+ func (_IInterchainDB *IInterchainDBCallerSession) GetBatchRoot(entry InterchainEntry, proof [][32]byte) ([32]byte, error)

+ func (_IInterchainDB *IInterchainDBCallerSession) GetVersionedBatch(dbNonce uint64) ([]byte, error)

type IInterchainDBSession

+ func (_IInterchainDB *IInterchainDBSession) CheckBatchVerification(dstModule common.Address, batch InterchainBatch) (*big.Int, error)

+ func (_IInterchainDB *IInterchainDBSession) GetBatchRoot(entry InterchainEntry, proof [][32]byte) ([32]byte, error)

+ func (_IInterchainDB *IInterchainDBSession) GetVersionedBatch(dbNonce uint64) ([]byte, error)

type InterchainClientV1Caller

+ func (_InterchainClientV1 *InterchainClientV1Caller) DefaultGuard(opts *bind.CallOpts) (common.Address, error)

+ func (_InterchainClientV1 *InterchainClientV1Caller) GetTxReadinessV1(opts *bind.CallOpts, icTx InterchainTransaction, proof [][32]byte) (struct{ ... }, error)

type InterchainClientV1CallerSession

+ func (_InterchainClientV1 *InterchainClientV1CallerSession) DefaultGuard() (common.Address, error)

+ func (_InterchainClientV1 *InterchainClientV1CallerSession) GetTxReadinessV1(icTx InterchainTransaction, proof [][32]byte) (struct{ ... }, error)

+ type InterchainClientV1DefaultGuardSet struct

+ Guard common.Address

+ Raw types.Log

+ type InterchainClientV1DefaultGuardSetIterator struct

+ Event *InterchainClientV1DefaultGuardSet

+ func (it *InterchainClientV1DefaultGuardSetIterator) Close() error

+ func (it *InterchainClientV1DefaultGuardSetIterator) Error() error

+ func (it *InterchainClientV1DefaultGuardSetIterator) Next() bool

+ type InterchainClientV1EventsDefaultGuardSet struct

+ Guard common.Address

+ Raw types.Log

+ type InterchainClientV1EventsDefaultGuardSetIterator struct

+ Event *InterchainClientV1EventsDefaultGuardSet

+ func (it *InterchainClientV1EventsDefaultGuardSetIterator) Close() error

+ func (it *InterchainClientV1EventsDefaultGuardSetIterator) Error() error

+ func (it *InterchainClientV1EventsDefaultGuardSetIterator) Next() bool

type InterchainClientV1EventsFilterer

+ func (_InterchainClientV1Events *InterchainClientV1EventsFilterer) FilterDefaultGuardSet(opts *bind.FilterOpts) (*InterchainClientV1EventsDefaultGuardSetIterator, error)

+ func (_InterchainClientV1Events *InterchainClientV1EventsFilterer) ParseDefaultGuardSet(log types.Log) (*InterchainClientV1EventsDefaultGuardSet, error)

+ func (_InterchainClientV1Events *InterchainClientV1EventsFilterer) WatchDefaultGuardSet(opts *bind.WatchOpts, sink chan<- *InterchainClientV1EventsDefaultGuardSet) (event.Subscription, error)

type InterchainClientV1Filterer

+ func (_InterchainClientV1 *InterchainClientV1Filterer) FilterDefaultGuardSet(opts *bind.FilterOpts) (*InterchainClientV1DefaultGuardSetIterator, error)

+ func (_InterchainClientV1 *InterchainClientV1Filterer) ParseDefaultGuardSet(log types.Log) (*InterchainClientV1DefaultGuardSet, error)

+ func (_InterchainClientV1 *InterchainClientV1Filterer) WatchDefaultGuardSet(opts *bind.WatchOpts, sink chan<- *InterchainClientV1DefaultGuardSet) (event.Subscription, error)

type InterchainClientV1Session

+ func (_InterchainClientV1 *InterchainClientV1Session) DefaultGuard() (common.Address, error)

+ func (_InterchainClientV1 *InterchainClientV1Session) GetTxReadinessV1(icTx InterchainTransaction, proof [][32]byte) (struct{ ... }, error)

+ func (_InterchainClientV1 *InterchainClientV1Session) SetDefaultGuard(guard common.Address) (*types.Transaction, error)

type InterchainClientV1Transactor

+ func (_InterchainClientV1 *InterchainClientV1Transactor) SetDefaultGuard(opts *bind.TransactOpts, guard common.Address) (*types.Transaction, error)

type InterchainClientV1TransactorSession

+ func (_InterchainClientV1 *InterchainClientV1TransactorSession) SetDefaultGuard(guard common.Address) (*types.Transaction, error)

v0.9.0

Apr 30, 2024

v0.8.0

Apr 21, 2024

v0.7.0

Apr 18, 2024

v0.6.1

Apr 16, 2024

Changes in this version

+ type AppConfigV1 struct

+ OptimisticPeriod *big.Int

+ RequiredResponses *big.Int

type InterchainClientV1Caller

+ func (_InterchainClientV1 *InterchainClientV1Caller) GetAppReceivingConfigV1(opts *bind.CallOpts, receiver common.Address) (struct{ ... }, error)

type InterchainClientV1CallerSession

+ func (_InterchainClientV1 *InterchainClientV1CallerSession) GetAppReceivingConfigV1(receiver common.Address) (struct{ ... }, error)

type InterchainClientV1Session

+ func (_InterchainClientV1 *InterchainClientV1Session) GetAppReceivingConfigV1(receiver common.Address) (struct{ ... }, error)

v0.6.0

Apr 16, 2024

Changes in this version

+ var SafeCastABI = SafeCastMetaData.ABI

+ var SafeCastBin = SafeCastMetaData.Bin

+ var SafeCastMetaData = &bind.MetaData

+ type SafeCast struct

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

+ func NewSafeCast(address common.Address, backend bind.ContractBackend) (*SafeCast, error)

+ type SafeCastCaller struct

+ func NewSafeCastCaller(address common.Address, caller bind.ContractCaller) (*SafeCastCaller, error)

+ type SafeCastCallerRaw struct

+ Contract *SafeCastCaller

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

+ type SafeCastCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SafeCastCaller

+ type SafeCastFilterer struct

+ func NewSafeCastFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeCastFilterer, error)

+ type SafeCastRaw struct

+ Contract *SafeCast

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

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

+ func (_SafeCast *SafeCastRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeCastSession struct

+ CallOpts bind.CallOpts

+ Contract *SafeCast

+ TransactOpts bind.TransactOpts

+ type SafeCastTransactor struct

+ func NewSafeCastTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeCastTransactor, error)

+ type SafeCastTransactorRaw struct

+ Contract *SafeCastTransactor

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

+ func (_SafeCast *SafeCastTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeCastTransactorSession struct

+ Contract *SafeCastTransactor

+ TransactOpts bind.TransactOpts

v0.5.5

Apr 11, 2024

v0.5.4

Apr 9, 2024

v0.5.3

Apr 9, 2024

v0.5.2

Apr 7, 2024

v0.5.1

Apr 6, 2024

v0.5.0

Apr 6, 2024

v0.4.0

Apr 4, 2024

Changes in this version

+ var VersionedPayloadLibABI = VersionedPayloadLibMetaData.ABI

+ var VersionedPayloadLibBin = VersionedPayloadLibMetaData.Bin

+ var VersionedPayloadLibMetaData = &bind.MetaData

type IInterchainDBCaller

+ func (_IInterchainDB *IInterchainDBCaller) DBVERSION(opts *bind.CallOpts) (uint16, error)

type IInterchainDBCallerSession

+ func (_IInterchainDB *IInterchainDBCallerSession) DBVERSION() (uint16, error)

type IInterchainDBSession

+ func (_IInterchainDB *IInterchainDBSession) DBVERSION() (uint16, error)

type InterchainClientV1Caller

+ func (_InterchainClientV1 *InterchainClientV1Caller) CLIENTVERSION(opts *bind.CallOpts) (uint16, error)

type InterchainClientV1CallerSession

+ func (_InterchainClientV1 *InterchainClientV1CallerSession) CLIENTVERSION() (uint16, error)

type InterchainClientV1Session

+ func (_InterchainClientV1 *InterchainClientV1Session) CLIENTVERSION() (uint16, error)

+ type VersionedPayloadLib struct

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

+ func NewVersionedPayloadLib(address common.Address, backend bind.ContractBackend) (*VersionedPayloadLib, error)

+ type VersionedPayloadLibCaller struct

+ func NewVersionedPayloadLibCaller(address common.Address, caller bind.ContractCaller) (*VersionedPayloadLibCaller, error)

+ type VersionedPayloadLibCallerRaw struct

+ Contract *VersionedPayloadLibCaller

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

+ type VersionedPayloadLibCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *VersionedPayloadLibCaller

+ type VersionedPayloadLibFilterer struct

+ func NewVersionedPayloadLibFilterer(address common.Address, filterer bind.ContractFilterer) (*VersionedPayloadLibFilterer, error)

+ type VersionedPayloadLibRaw struct

+ Contract *VersionedPayloadLib

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

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

+ func (_VersionedPayloadLib *VersionedPayloadLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type VersionedPayloadLibSession struct

+ CallOpts bind.CallOpts

+ Contract *VersionedPayloadLib

+ TransactOpts bind.TransactOpts

+ type VersionedPayloadLibTransactor struct

+ func NewVersionedPayloadLibTransactor(address common.Address, transactor bind.ContractTransactor) (*VersionedPayloadLibTransactor, error)

+ type VersionedPayloadLibTransactorRaw struct

+ Contract *VersionedPayloadLibTransactor

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

+ func (_VersionedPayloadLib *VersionedPayloadLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type VersionedPayloadLibTransactorSession struct

+ Contract *VersionedPayloadLibTransactor

+ TransactOpts bind.TransactOpts

v0.3.6

Apr 3, 2024

v0.3.5

Apr 2, 2024

v0.3.4

Apr 2, 2024

v0.3.3

Apr 2, 2024

v0.3.2

Apr 2, 2024

v0.3.1

Apr 2, 2024

v0.3.0

Apr 1, 2024

v0.2.1

Apr 1, 2024

v0.2.0

Apr 1, 2024

v0.1.2

Mar 29, 2024

v0.1.1

Mar 28, 2024

Changes in this version

+ var MathLibABI = MathLibMetaData.ABI

+ var MathLibBin = MathLibMetaData.Bin

+ var MathLibMetaData = &bind.MetaData

+ type MathLib struct

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

+ func NewMathLib(address common.Address, backend bind.ContractBackend) (*MathLib, error)

+ type MathLibCaller struct

+ func NewMathLibCaller(address common.Address, caller bind.ContractCaller) (*MathLibCaller, error)

+ type MathLibCallerRaw struct

+ Contract *MathLibCaller

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

+ type MathLibCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *MathLibCaller

+ type MathLibFilterer struct

+ func NewMathLibFilterer(address common.Address, filterer bind.ContractFilterer) (*MathLibFilterer, error)

+ type MathLibRaw struct

+ Contract *MathLib

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

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

+ func (_MathLib *MathLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MathLibSession struct

+ CallOpts bind.CallOpts

+ Contract *MathLib

+ TransactOpts bind.TransactOpts

+ type MathLibTransactor struct

+ func NewMathLibTransactor(address common.Address, transactor bind.ContractTransactor) (*MathLibTransactor, error)

+ type MathLibTransactorRaw struct

+ Contract *MathLibTransactor

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

+ func (_MathLib *MathLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MathLibTransactorSession struct

+ Contract *MathLibTransactor

+ TransactOpts bind.TransactOpts

v0.1.0

Mar 28, 2024

v0.0.4

Mar 27, 2024

Changes in this version

type IInterchainDBCaller

+ func (_IInterchainDB *IInterchainDBCaller) GetEntryValue(opts *bind.CallOpts, dbNonce *big.Int, entryIndex uint64) ([32]byte, error)

type IInterchainDBCallerSession

+ func (_IInterchainDB *IInterchainDBCallerSession) GetEntryValue(dbNonce *big.Int, entryIndex uint64) ([32]byte, error)

type IInterchainDBSession

+ func (_IInterchainDB *IInterchainDBSession) GetEntryValue(dbNonce *big.Int, entryIndex uint64) ([32]byte, error)

v0.0.3

Mar 27, 2024

v0.0.2

Mar 27, 2024

v0.0.1

Mar 27, 2024

Changes in this version

+ var AppConfigLibABI = AppConfigLibMetaData.ABI

+ var AppConfigLibBin = AppConfigLibMetaData.Bin

+ var AppConfigLibMetaData = &bind.MetaData

+ var ContextABI = ContextMetaData.ABI

+ var ContextMetaData = &bind.MetaData

+ var Contracts map[string]*compiler.Contract

+ var IExecutionFeesABI = IExecutionFeesMetaData.ABI

+ var IExecutionFeesFuncSigs = IExecutionFeesMetaData.Sigs

+ var IExecutionFeesMetaData = &bind.MetaData

+ var IExecutionServiceABI = IExecutionServiceMetaData.ABI

+ var IExecutionServiceFuncSigs = IExecutionServiceMetaData.Sigs

+ var IExecutionServiceMetaData = &bind.MetaData

+ var IInterchainAppABI = IInterchainAppMetaData.ABI

+ var IInterchainAppFuncSigs = IInterchainAppMetaData.Sigs

+ var IInterchainAppMetaData = &bind.MetaData

+ var IInterchainClientV1ABI = IInterchainClientV1MetaData.ABI

+ var IInterchainClientV1FuncSigs = IInterchainClientV1MetaData.Sigs

+ var IInterchainClientV1MetaData = &bind.MetaData

+ var IInterchainDBABI = IInterchainDBMetaData.ABI

+ var IInterchainDBFuncSigs = IInterchainDBMetaData.Sigs

+ var IInterchainDBMetaData = &bind.MetaData

+ var InterchainBatchLibABI = InterchainBatchLibMetaData.ABI

+ var InterchainBatchLibBin = InterchainBatchLibMetaData.Bin

+ var InterchainBatchLibMetaData = &bind.MetaData

+ var InterchainClientV1ABI = InterchainClientV1MetaData.ABI

+ var InterchainClientV1Bin = InterchainClientV1MetaData.Bin

+ var InterchainClientV1EventsABI = InterchainClientV1EventsMetaData.ABI

+ var InterchainClientV1EventsMetaData = &bind.MetaData

+ var InterchainClientV1FuncSigs = InterchainClientV1MetaData.Sigs

+ var InterchainClientV1MetaData = &bind.MetaData

+ var InterchainEntryLibABI = InterchainEntryLibMetaData.ABI

+ var InterchainEntryLibBin = InterchainEntryLibMetaData.Bin

+ var InterchainEntryLibMetaData = &bind.MetaData

+ var InterchainTransactionLibABI = InterchainTransactionLibMetaData.ABI

+ var InterchainTransactionLibBin = InterchainTransactionLibMetaData.Bin

+ var InterchainTransactionLibMetaData = &bind.MetaData

+ var InterchainTransactionSentTopic common.Hash

+ var OptionsLibABI = OptionsLibMetaData.ABI

+ var OptionsLibBin = OptionsLibMetaData.Bin

+ var OptionsLibMetaData = &bind.MetaData

+ var OwnableABI = OwnableMetaData.ABI

+ var OwnableFuncSigs = OwnableMetaData.Sigs

+ var OwnableMetaData = &bind.MetaData

+ var TypeCastsABI = TypeCastsMetaData.ABI

+ var TypeCastsBin = TypeCastsMetaData.Bin

+ var TypeCastsMetaData = &bind.MetaData

+ type AppConfigLib struct

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

+ func NewAppConfigLib(address common.Address, backend bind.ContractBackend) (*AppConfigLib, error)

+ type AppConfigLibCaller struct

+ func NewAppConfigLibCaller(address common.Address, caller bind.ContractCaller) (*AppConfigLibCaller, error)

+ type AppConfigLibCallerRaw struct

+ Contract *AppConfigLibCaller

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

+ type AppConfigLibCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *AppConfigLibCaller

+ type AppConfigLibFilterer struct

+ func NewAppConfigLibFilterer(address common.Address, filterer bind.ContractFilterer) (*AppConfigLibFilterer, error)

+ type AppConfigLibRaw struct

+ Contract *AppConfigLib

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

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

+ func (_AppConfigLib *AppConfigLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AppConfigLibSession struct

+ CallOpts bind.CallOpts

+ Contract *AppConfigLib

+ TransactOpts bind.TransactOpts

+ type AppConfigLibTransactor struct

+ func NewAppConfigLibTransactor(address common.Address, transactor bind.ContractTransactor) (*AppConfigLibTransactor, error)

+ type AppConfigLibTransactorRaw struct

+ Contract *AppConfigLibTransactor

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

+ func (_AppConfigLib *AppConfigLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AppConfigLibTransactorSession struct

+ Contract *AppConfigLibTransactor

+ TransactOpts bind.TransactOpts

+ type Context struct

+ func NewContext(address common.Address, backend bind.ContractBackend) (*Context, error)

+ type ContextCaller struct

+ func NewContextCaller(address common.Address, caller bind.ContractCaller) (*ContextCaller, error)

+ type ContextCallerRaw struct

+ Contract *ContextCaller

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

+ type ContextCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ContextCaller

+ type ContextFilterer struct

+ func NewContextFilterer(address common.Address, filterer bind.ContractFilterer) (*ContextFilterer, error)

+ type ContextRaw struct

+ Contract *Context

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

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

+ func (_Context *ContextRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ContextSession struct

+ CallOpts bind.CallOpts

+ Contract *Context

+ TransactOpts bind.TransactOpts

+ type ContextTransactor struct

+ func NewContextTransactor(address common.Address, transactor bind.ContractTransactor) (*ContextTransactor, error)

+ type ContextTransactorRaw struct

+ Contract *ContextTransactor

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

+ func (_Context *ContextTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ContextTransactorSession struct

+ Contract *ContextTransactor

+ TransactOpts bind.TransactOpts

+ type EventType uint

+ const InterchainTransactionSentEvent

+ func (i EventType) String() string

+ type IExecutionFees struct

+ func NewIExecutionFees(address common.Address, backend bind.ContractBackend) (*IExecutionFees, error)

+ type IExecutionFeesCaller struct

+ func NewIExecutionFeesCaller(address common.Address, caller bind.ContractCaller) (*IExecutionFeesCaller, error)

+ func (_IExecutionFees *IExecutionFeesCaller) AccumulatedRewards(opts *bind.CallOpts, executor common.Address) (*big.Int, error)

+ func (_IExecutionFees *IExecutionFeesCaller) ExecutionFee(opts *bind.CallOpts, dstChainId *big.Int, transactionId [32]byte) (*big.Int, error)

+ func (_IExecutionFees *IExecutionFeesCaller) RecordedExecutor(opts *bind.CallOpts, dstChainId *big.Int, transactionId [32]byte) (common.Address, error)

+ func (_IExecutionFees *IExecutionFeesCaller) UnclaimedRewards(opts *bind.CallOpts, executor common.Address) (*big.Int, error)

+ type IExecutionFeesCallerRaw struct

+ Contract *IExecutionFeesCaller

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

+ type IExecutionFeesCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IExecutionFeesCaller

+ func (_IExecutionFees *IExecutionFeesCallerSession) AccumulatedRewards(executor common.Address) (*big.Int, error)

+ func (_IExecutionFees *IExecutionFeesCallerSession) ExecutionFee(dstChainId *big.Int, transactionId [32]byte) (*big.Int, error)

+ func (_IExecutionFees *IExecutionFeesCallerSession) RecordedExecutor(dstChainId *big.Int, transactionId [32]byte) (common.Address, error)

+ func (_IExecutionFees *IExecutionFeesCallerSession) UnclaimedRewards(executor common.Address) (*big.Int, error)

+ type IExecutionFeesFilterer struct

+ func NewIExecutionFeesFilterer(address common.Address, filterer bind.ContractFilterer) (*IExecutionFeesFilterer, error)

+ type IExecutionFeesRaw struct

+ Contract *IExecutionFees

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

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

+ func (_IExecutionFees *IExecutionFeesRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IExecutionFeesSession struct

+ CallOpts bind.CallOpts

+ Contract *IExecutionFees

+ TransactOpts bind.TransactOpts

+ func (_IExecutionFees *IExecutionFeesSession) AccumulatedRewards(executor common.Address) (*big.Int, error)

+ func (_IExecutionFees *IExecutionFeesSession) AddExecutionFee(dstChainId *big.Int, transactionId [32]byte) (*types.Transaction, error)

+ func (_IExecutionFees *IExecutionFeesSession) ClaimExecutionFees(executor common.Address) (*types.Transaction, error)

+ func (_IExecutionFees *IExecutionFeesSession) ExecutionFee(dstChainId *big.Int, transactionId [32]byte) (*big.Int, error)

+ func (_IExecutionFees *IExecutionFeesSession) RecordExecutor(dstChainId *big.Int, transactionId [32]byte, executor common.Address) (*types.Transaction, error)

+ func (_IExecutionFees *IExecutionFeesSession) RecordedExecutor(dstChainId *big.Int, transactionId [32]byte) (common.Address, error)

+ func (_IExecutionFees *IExecutionFeesSession) UnclaimedRewards(executor common.Address) (*big.Int, error)

+ type IExecutionFeesTransactor struct

+ func NewIExecutionFeesTransactor(address common.Address, transactor bind.ContractTransactor) (*IExecutionFeesTransactor, error)

+ func (_IExecutionFees *IExecutionFeesTransactor) AddExecutionFee(opts *bind.TransactOpts, dstChainId *big.Int, transactionId [32]byte) (*types.Transaction, error)

+ func (_IExecutionFees *IExecutionFeesTransactor) ClaimExecutionFees(opts *bind.TransactOpts, executor common.Address) (*types.Transaction, error)

+ func (_IExecutionFees *IExecutionFeesTransactor) RecordExecutor(opts *bind.TransactOpts, dstChainId *big.Int, transactionId [32]byte, ...) (*types.Transaction, error)

+ type IExecutionFeesTransactorRaw struct

+ Contract *IExecutionFeesTransactor

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

+ func (_IExecutionFees *IExecutionFeesTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IExecutionFeesTransactorSession struct

+ Contract *IExecutionFeesTransactor

+ TransactOpts bind.TransactOpts

+ func (_IExecutionFees *IExecutionFeesTransactorSession) AddExecutionFee(dstChainId *big.Int, transactionId [32]byte) (*types.Transaction, error)

+ func (_IExecutionFees *IExecutionFeesTransactorSession) ClaimExecutionFees(executor common.Address) (*types.Transaction, error)

+ func (_IExecutionFees *IExecutionFeesTransactorSession) RecordExecutor(dstChainId *big.Int, transactionId [32]byte, executor common.Address) (*types.Transaction, error)

+ type IExecutionService struct

+ func NewIExecutionService(address common.Address, backend bind.ContractBackend) (*IExecutionService, error)

+ type IExecutionServiceCaller struct

+ func NewIExecutionServiceCaller(address common.Address, caller bind.ContractCaller) (*IExecutionServiceCaller, error)

+ func (_IExecutionService *IExecutionServiceCaller) ExecutorEOA(opts *bind.CallOpts) (common.Address, error)

+ func (_IExecutionService *IExecutionServiceCaller) GetExecutionFee(opts *bind.CallOpts, dstChainId *big.Int, txPayloadSize *big.Int, ...) (*big.Int, error)

+ type IExecutionServiceCallerRaw struct

+ Contract *IExecutionServiceCaller

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

+ type IExecutionServiceCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IExecutionServiceCaller

+ func (_IExecutionService *IExecutionServiceCallerSession) ExecutorEOA() (common.Address, error)

+ func (_IExecutionService *IExecutionServiceCallerSession) GetExecutionFee(dstChainId *big.Int, txPayloadSize *big.Int, options []byte) (*big.Int, error)

+ type IExecutionServiceFilterer struct

+ func NewIExecutionServiceFilterer(address common.Address, filterer bind.ContractFilterer) (*IExecutionServiceFilterer, error)

+ type IExecutionServiceRaw struct

+ Contract *IExecutionService

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

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

+ func (_IExecutionService *IExecutionServiceRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IExecutionServiceSession struct

+ CallOpts bind.CallOpts

+ Contract *IExecutionService

+ TransactOpts bind.TransactOpts

+ func (_IExecutionService *IExecutionServiceSession) ExecutorEOA() (common.Address, error)

+ func (_IExecutionService *IExecutionServiceSession) GetExecutionFee(dstChainId *big.Int, txPayloadSize *big.Int, options []byte) (*big.Int, error)

+ func (_IExecutionService *IExecutionServiceSession) RequestExecution(dstChainId *big.Int, txPayloadSize *big.Int, transactionId [32]byte, ...) (*types.Transaction, error)

+ type IExecutionServiceTransactor struct

+ func NewIExecutionServiceTransactor(address common.Address, transactor bind.ContractTransactor) (*IExecutionServiceTransactor, error)

+ func (_IExecutionService *IExecutionServiceTransactor) RequestExecution(opts *bind.TransactOpts, dstChainId *big.Int, txPayloadSize *big.Int, ...) (*types.Transaction, error)

+ type IExecutionServiceTransactorRaw struct

+ Contract *IExecutionServiceTransactor

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

+ func (_IExecutionService *IExecutionServiceTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IExecutionServiceTransactorSession struct

+ Contract *IExecutionServiceTransactor

+ TransactOpts bind.TransactOpts

+ func (_IExecutionService *IExecutionServiceTransactorSession) RequestExecution(dstChainId *big.Int, txPayloadSize *big.Int, transactionId [32]byte, ...) (*types.Transaction, error)

+ type IInterchainApp struct

+ func NewIInterchainApp(address common.Address, backend bind.ContractBackend) (*IInterchainApp, error)

+ type IInterchainAppCaller struct

+ func NewIInterchainAppCaller(address common.Address, caller bind.ContractCaller) (*IInterchainAppCaller, error)

+ func (_IInterchainApp *IInterchainAppCaller) GetReceivingConfig(opts *bind.CallOpts) (struct{ ... }, error)

+ type IInterchainAppCallerRaw struct

+ Contract *IInterchainAppCaller

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

+ type IInterchainAppCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IInterchainAppCaller

+ func (_IInterchainApp *IInterchainAppCallerSession) GetReceivingConfig() (struct{ ... }, error)

+ type IInterchainAppFilterer struct

+ func NewIInterchainAppFilterer(address common.Address, filterer bind.ContractFilterer) (*IInterchainAppFilterer, error)

+ type IInterchainAppRaw struct

+ Contract *IInterchainApp

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

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

+ func (_IInterchainApp *IInterchainAppRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IInterchainAppSession struct

+ CallOpts bind.CallOpts

+ Contract *IInterchainApp

+ TransactOpts bind.TransactOpts

+ func (_IInterchainApp *IInterchainAppSession) AppReceive(srcChainId *big.Int, sender [32]byte, dbNonce *big.Int, entryIndex uint64, ...) (*types.Transaction, error)

+ func (_IInterchainApp *IInterchainAppSession) GetReceivingConfig() (struct{ ... }, error)

+ type IInterchainAppTransactor struct

+ func NewIInterchainAppTransactor(address common.Address, transactor bind.ContractTransactor) (*IInterchainAppTransactor, error)

+ func (_IInterchainApp *IInterchainAppTransactor) AppReceive(opts *bind.TransactOpts, srcChainId *big.Int, sender [32]byte, ...) (*types.Transaction, error)

+ type IInterchainAppTransactorRaw struct

+ Contract *IInterchainAppTransactor

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

+ func (_IInterchainApp *IInterchainAppTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IInterchainAppTransactorSession struct

+ Contract *IInterchainAppTransactor

+ TransactOpts bind.TransactOpts

+ func (_IInterchainApp *IInterchainAppTransactorSession) AppReceive(srcChainId *big.Int, sender [32]byte, dbNonce *big.Int, entryIndex uint64, ...) (*types.Transaction, error)

+ type IInterchainClientV1 struct

+ func NewIInterchainClientV1(address common.Address, backend bind.ContractBackend) (*IInterchainClientV1, error)

+ type IInterchainClientV1Caller struct

+ func NewIInterchainClientV1Caller(address common.Address, caller bind.ContractCaller) (*IInterchainClientV1Caller, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Caller) GetExecutor(opts *bind.CallOpts, transaction []byte) (common.Address, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Caller) GetExecutorById(opts *bind.CallOpts, transactionId [32]byte) (common.Address, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Caller) GetInterchainFee(opts *bind.CallOpts, dstChainId *big.Int, srcExecutionService common.Address, ...) (*big.Int, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Caller) GetLinkedClient(opts *bind.CallOpts, chainId *big.Int) ([32]byte, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Caller) GetLinkedClientEVM(opts *bind.CallOpts, chainId *big.Int) (common.Address, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Caller) IsExecutable(opts *bind.CallOpts, transaction []byte, proof [][32]byte) (bool, error)

+ type IInterchainClientV1CallerRaw struct

+ Contract *IInterchainClientV1Caller

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

+ type IInterchainClientV1CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IInterchainClientV1Caller

+ func (_IInterchainClientV1 *IInterchainClientV1CallerSession) GetExecutor(transaction []byte) (common.Address, error)

+ func (_IInterchainClientV1 *IInterchainClientV1CallerSession) GetExecutorById(transactionId [32]byte) (common.Address, error)

+ func (_IInterchainClientV1 *IInterchainClientV1CallerSession) GetInterchainFee(dstChainId *big.Int, srcExecutionService common.Address, ...) (*big.Int, error)

+ func (_IInterchainClientV1 *IInterchainClientV1CallerSession) GetLinkedClient(chainId *big.Int) ([32]byte, error)

+ func (_IInterchainClientV1 *IInterchainClientV1CallerSession) GetLinkedClientEVM(chainId *big.Int) (common.Address, error)

+ func (_IInterchainClientV1 *IInterchainClientV1CallerSession) IsExecutable(transaction []byte, proof [][32]byte) (bool, error)

+ type IInterchainClientV1Filterer struct

+ func NewIInterchainClientV1Filterer(address common.Address, filterer bind.ContractFilterer) (*IInterchainClientV1Filterer, error)

+ type IInterchainClientV1Raw struct

+ Contract *IInterchainClientV1

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

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

+ func (_IInterchainClientV1 *IInterchainClientV1Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IInterchainClientV1Session struct

+ CallOpts bind.CallOpts

+ Contract *IInterchainClientV1

+ TransactOpts bind.TransactOpts

+ func (_IInterchainClientV1 *IInterchainClientV1Session) GetExecutor(transaction []byte) (common.Address, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Session) GetExecutorById(transactionId [32]byte) (common.Address, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Session) GetInterchainFee(dstChainId *big.Int, srcExecutionService common.Address, ...) (*big.Int, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Session) GetLinkedClient(chainId *big.Int) ([32]byte, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Session) GetLinkedClientEVM(chainId *big.Int) (common.Address, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Session) InterchainExecute(gasLimit *big.Int, transaction []byte, proof [][32]byte) (*types.Transaction, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Session) InterchainSend(dstChainId *big.Int, receiver [32]byte, srcExecutionService common.Address, ...) (*types.Transaction, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Session) InterchainSendEVM(dstChainId *big.Int, receiver common.Address, ...) (*types.Transaction, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Session) IsExecutable(transaction []byte, proof [][32]byte) (bool, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Session) SetExecutionFees(executionFees_ common.Address) (*types.Transaction, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Session) SetLinkedClient(chainId *big.Int, client [32]byte) (*types.Transaction, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Session) WriteExecutionProof(transactionId [32]byte) (*types.Transaction, error)

+ type IInterchainClientV1Transactor struct

+ func NewIInterchainClientV1Transactor(address common.Address, transactor bind.ContractTransactor) (*IInterchainClientV1Transactor, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Transactor) InterchainExecute(opts *bind.TransactOpts, gasLimit *big.Int, transaction []byte, ...) (*types.Transaction, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Transactor) InterchainSend(opts *bind.TransactOpts, dstChainId *big.Int, receiver [32]byte, ...) (*types.Transaction, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Transactor) InterchainSendEVM(opts *bind.TransactOpts, dstChainId *big.Int, receiver common.Address, ...) (*types.Transaction, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Transactor) SetExecutionFees(opts *bind.TransactOpts, executionFees_ common.Address) (*types.Transaction, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Transactor) SetLinkedClient(opts *bind.TransactOpts, chainId *big.Int, client [32]byte) (*types.Transaction, error)

+ func (_IInterchainClientV1 *IInterchainClientV1Transactor) WriteExecutionProof(opts *bind.TransactOpts, transactionId [32]byte) (*types.Transaction, error)

+ type IInterchainClientV1TransactorRaw struct

+ Contract *IInterchainClientV1Transactor

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

+ func (_IInterchainClientV1 *IInterchainClientV1TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IInterchainClientV1TransactorSession struct

+ Contract *IInterchainClientV1Transactor

+ TransactOpts bind.TransactOpts

+ func (_IInterchainClientV1 *IInterchainClientV1TransactorSession) InterchainExecute(gasLimit *big.Int, transaction []byte, proof [][32]byte) (*types.Transaction, error)

+ func (_IInterchainClientV1 *IInterchainClientV1TransactorSession) InterchainSend(dstChainId *big.Int, receiver [32]byte, srcExecutionService common.Address, ...) (*types.Transaction, error)

+ func (_IInterchainClientV1 *IInterchainClientV1TransactorSession) InterchainSendEVM(dstChainId *big.Int, receiver common.Address, ...) (*types.Transaction, error)

+ func (_IInterchainClientV1 *IInterchainClientV1TransactorSession) SetExecutionFees(executionFees_ common.Address) (*types.Transaction, error)

+ func (_IInterchainClientV1 *IInterchainClientV1TransactorSession) SetLinkedClient(chainId *big.Int, client [32]byte) (*types.Transaction, error)

+ func (_IInterchainClientV1 *IInterchainClientV1TransactorSession) WriteExecutionProof(transactionId [32]byte) (*types.Transaction, error)

+ type IInterchainDB struct

+ func NewIInterchainDB(address common.Address, backend bind.ContractBackend) (*IInterchainDB, error)

+ type IInterchainDBCaller struct

+ func NewIInterchainDBCaller(address common.Address, caller bind.ContractCaller) (*IInterchainDBCaller, error)

+ func (_IInterchainDB *IInterchainDBCaller) CheckVerification(opts *bind.CallOpts, dstModule common.Address, entry InterchainEntry, ...) (*big.Int, error)

+ func (_IInterchainDB *IInterchainDBCaller) GetBatch(opts *bind.CallOpts, dbNonce *big.Int) (InterchainBatch, error)

+ func (_IInterchainDB *IInterchainDBCaller) GetBatchLeafs(opts *bind.CallOpts, dbNonce *big.Int) ([][32]byte, error)

+ func (_IInterchainDB *IInterchainDBCaller) GetBatchLeafsPaginated(opts *bind.CallOpts, dbNonce *big.Int, start uint64, end uint64) ([][32]byte, error)

+ func (_IInterchainDB *IInterchainDBCaller) GetBatchSize(opts *bind.CallOpts, dbNonce *big.Int) (uint64, error)

+ func (_IInterchainDB *IInterchainDBCaller) GetDBNonce(opts *bind.CallOpts) (*big.Int, error)

+ func (_IInterchainDB *IInterchainDBCaller) GetEntry(opts *bind.CallOpts, dbNonce *big.Int, entryIndex uint64) (InterchainEntry, error)

+ func (_IInterchainDB *IInterchainDBCaller) GetEntryProof(opts *bind.CallOpts, dbNonce *big.Int, entryIndex uint64) ([][32]byte, error)

+ func (_IInterchainDB *IInterchainDBCaller) GetInterchainFee(opts *bind.CallOpts, dstChainId *big.Int, srcModules []common.Address) (*big.Int, error)

+ func (_IInterchainDB *IInterchainDBCaller) GetNextEntryIndex(opts *bind.CallOpts) (struct{ ... }, error)

+ type IInterchainDBCallerRaw struct

+ Contract *IInterchainDBCaller

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

+ type IInterchainDBCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IInterchainDBCaller

+ func (_IInterchainDB *IInterchainDBCallerSession) CheckVerification(dstModule common.Address, entry InterchainEntry, proof [][32]byte) (*big.Int, error)

+ func (_IInterchainDB *IInterchainDBCallerSession) GetBatch(dbNonce *big.Int) (InterchainBatch, error)

+ func (_IInterchainDB *IInterchainDBCallerSession) GetBatchLeafs(dbNonce *big.Int) ([][32]byte, error)

+ func (_IInterchainDB *IInterchainDBCallerSession) GetBatchLeafsPaginated(dbNonce *big.Int, start uint64, end uint64) ([][32]byte, error)

+ func (_IInterchainDB *IInterchainDBCallerSession) GetBatchSize(dbNonce *big.Int) (uint64, error)

+ func (_IInterchainDB *IInterchainDBCallerSession) GetDBNonce() (*big.Int, error)

+ func (_IInterchainDB *IInterchainDBCallerSession) GetEntry(dbNonce *big.Int, entryIndex uint64) (InterchainEntry, error)

+ func (_IInterchainDB *IInterchainDBCallerSession) GetEntryProof(dbNonce *big.Int, entryIndex uint64) ([][32]byte, error)

+ func (_IInterchainDB *IInterchainDBCallerSession) GetInterchainFee(dstChainId *big.Int, srcModules []common.Address) (*big.Int, error)

+ func (_IInterchainDB *IInterchainDBCallerSession) GetNextEntryIndex() (struct{ ... }, error)

+ type IInterchainDBFilterer struct

+ func NewIInterchainDBFilterer(address common.Address, filterer bind.ContractFilterer) (*IInterchainDBFilterer, error)

+ type IInterchainDBRaw struct

+ Contract *IInterchainDB

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

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

+ func (_IInterchainDB *IInterchainDBRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IInterchainDBSession struct

+ CallOpts bind.CallOpts

+ Contract *IInterchainDB

+ TransactOpts bind.TransactOpts

+ func (_IInterchainDB *IInterchainDBSession) CheckVerification(dstModule common.Address, entry InterchainEntry, proof [][32]byte) (*big.Int, error)

+ func (_IInterchainDB *IInterchainDBSession) GetBatch(dbNonce *big.Int) (InterchainBatch, error)

+ func (_IInterchainDB *IInterchainDBSession) GetBatchLeafs(dbNonce *big.Int) ([][32]byte, error)

+ func (_IInterchainDB *IInterchainDBSession) GetBatchLeafsPaginated(dbNonce *big.Int, start uint64, end uint64) ([][32]byte, error)

+ func (_IInterchainDB *IInterchainDBSession) GetBatchSize(dbNonce *big.Int) (uint64, error)

+ func (_IInterchainDB *IInterchainDBSession) GetDBNonce() (*big.Int, error)

+ func (_IInterchainDB *IInterchainDBSession) GetEntry(dbNonce *big.Int, entryIndex uint64) (InterchainEntry, error)

+ func (_IInterchainDB *IInterchainDBSession) GetEntryProof(dbNonce *big.Int, entryIndex uint64) ([][32]byte, error)

+ func (_IInterchainDB *IInterchainDBSession) GetInterchainFee(dstChainId *big.Int, srcModules []common.Address) (*big.Int, error)

+ func (_IInterchainDB *IInterchainDBSession) GetNextEntryIndex() (struct{ ... }, error)

+ func (_IInterchainDB *IInterchainDBSession) RequestBatchVerification(dstChainId *big.Int, dbNonce *big.Int, srcModules []common.Address) (*types.Transaction, error)

+ func (_IInterchainDB *IInterchainDBSession) VerifyRemoteBatch(batch InterchainBatch) (*types.Transaction, error)

+ func (_IInterchainDB *IInterchainDBSession) WriteEntry(dataHash [32]byte) (*types.Transaction, error)

+ func (_IInterchainDB *IInterchainDBSession) WriteEntryWithVerification(dstChainId *big.Int, dataHash [32]byte, srcModules []common.Address) (*types.Transaction, error)

+ type IInterchainDBTransactor struct

+ func NewIInterchainDBTransactor(address common.Address, transactor bind.ContractTransactor) (*IInterchainDBTransactor, error)

+ func (_IInterchainDB *IInterchainDBTransactor) RequestBatchVerification(opts *bind.TransactOpts, dstChainId *big.Int, dbNonce *big.Int, ...) (*types.Transaction, error)

+ func (_IInterchainDB *IInterchainDBTransactor) VerifyRemoteBatch(opts *bind.TransactOpts, batch InterchainBatch) (*types.Transaction, error)

+ func (_IInterchainDB *IInterchainDBTransactor) WriteEntry(opts *bind.TransactOpts, dataHash [32]byte) (*types.Transaction, error)

+ func (_IInterchainDB *IInterchainDBTransactor) WriteEntryWithVerification(opts *bind.TransactOpts, dstChainId *big.Int, dataHash [32]byte, ...) (*types.Transaction, error)

+ type IInterchainDBTransactorRaw struct

+ Contract *IInterchainDBTransactor

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

+ func (_IInterchainDB *IInterchainDBTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IInterchainDBTransactorSession struct

+ Contract *IInterchainDBTransactor

+ TransactOpts bind.TransactOpts

+ func (_IInterchainDB *IInterchainDBTransactorSession) RequestBatchVerification(dstChainId *big.Int, dbNonce *big.Int, srcModules []common.Address) (*types.Transaction, error)

+ func (_IInterchainDB *IInterchainDBTransactorSession) VerifyRemoteBatch(batch InterchainBatch) (*types.Transaction, error)

+ func (_IInterchainDB *IInterchainDBTransactorSession) WriteEntry(dataHash [32]byte) (*types.Transaction, error)

+ func (_IInterchainDB *IInterchainDBTransactorSession) WriteEntryWithVerification(dstChainId *big.Int, dataHash [32]byte, srcModules []common.Address) (*types.Transaction, error)

+ type InterchainBatch struct

+ BatchRoot [32]byte

+ DbNonce *big.Int

+ SrcChainId *big.Int

+ type InterchainBatchLib struct

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

+ func NewInterchainBatchLib(address common.Address, backend bind.ContractBackend) (*InterchainBatchLib, error)

+ type InterchainBatchLibCaller struct

+ func NewInterchainBatchLibCaller(address common.Address, caller bind.ContractCaller) (*InterchainBatchLibCaller, error)

+ type InterchainBatchLibCallerRaw struct

+ Contract *InterchainBatchLibCaller

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

+ type InterchainBatchLibCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *InterchainBatchLibCaller

+ type InterchainBatchLibFilterer struct

+ func NewInterchainBatchLibFilterer(address common.Address, filterer bind.ContractFilterer) (*InterchainBatchLibFilterer, error)

+ type InterchainBatchLibRaw struct

+ Contract *InterchainBatchLib

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

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

+ func (_InterchainBatchLib *InterchainBatchLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type InterchainBatchLibSession struct

+ CallOpts bind.CallOpts

+ Contract *InterchainBatchLib

+ TransactOpts bind.TransactOpts

+ type InterchainBatchLibTransactor struct

+ func NewInterchainBatchLibTransactor(address common.Address, transactor bind.ContractTransactor) (*InterchainBatchLibTransactor, error)

+ type InterchainBatchLibTransactorRaw struct

+ Contract *InterchainBatchLibTransactor

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

+ func (_InterchainBatchLib *InterchainBatchLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type InterchainBatchLibTransactorSession struct

+ Contract *InterchainBatchLibTransactor

+ TransactOpts bind.TransactOpts

+ type InterchainClientRef struct

+ func NewInterchainClientRef(address common.Address, backend bind.ContractBackend) (*InterchainClientRef, error)

+ func (i *InterchainClientRef) Address() common.Address

+ type InterchainClientV1 struct

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

+ func NewInterchainClientV1(address common.Address, backend bind.ContractBackend) (*InterchainClientV1, error)

+ type InterchainClientV1Caller struct

+ func NewInterchainClientV1Caller(address common.Address, caller bind.ContractCaller) (*InterchainClientV1Caller, error)

+ func (_InterchainClientV1 *InterchainClientV1Caller) DecodeOptions(opts *bind.CallOpts, encodedOptions []byte) (OptionsV1, error)

+ func (_InterchainClientV1 *InterchainClientV1Caller) EncodeTransaction(opts *bind.CallOpts, icTx InterchainTransaction) ([]byte, error)

+ func (_InterchainClientV1 *InterchainClientV1Caller) ExecutionFees(opts *bind.CallOpts) (common.Address, error)

+ func (_InterchainClientV1 *InterchainClientV1Caller) GetExecutor(opts *bind.CallOpts, encodedTx []byte) (common.Address, error)

+ func (_InterchainClientV1 *InterchainClientV1Caller) GetExecutorById(opts *bind.CallOpts, transactionId [32]byte) (common.Address, error)

+ func (_InterchainClientV1 *InterchainClientV1Caller) GetInterchainFee(opts *bind.CallOpts, dstChainId *big.Int, srcExecutionService common.Address, ...) (*big.Int, error)

+ func (_InterchainClientV1 *InterchainClientV1Caller) GetLinkedClient(opts *bind.CallOpts, chainId *big.Int) ([32]byte, error)

+ func (_InterchainClientV1 *InterchainClientV1Caller) GetLinkedClientEVM(opts *bind.CallOpts, chainId *big.Int) (common.Address, error)

+ func (_InterchainClientV1 *InterchainClientV1Caller) INTERCHAINDB(opts *bind.CallOpts) (common.Address, error)

+ func (_InterchainClientV1 *InterchainClientV1Caller) IsExecutable(opts *bind.CallOpts, encodedTx []byte, proof [][32]byte) (bool, error)

+ func (_InterchainClientV1 *InterchainClientV1Caller) Owner(opts *bind.CallOpts) (common.Address, error)

+ type InterchainClientV1CallerRaw struct

+ Contract *InterchainClientV1Caller

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

+ type InterchainClientV1CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *InterchainClientV1Caller

+ func (_InterchainClientV1 *InterchainClientV1CallerSession) DecodeOptions(encodedOptions []byte) (OptionsV1, error)

+ func (_InterchainClientV1 *InterchainClientV1CallerSession) EncodeTransaction(icTx InterchainTransaction) ([]byte, error)

+ func (_InterchainClientV1 *InterchainClientV1CallerSession) ExecutionFees() (common.Address, error)

+ func (_InterchainClientV1 *InterchainClientV1CallerSession) GetExecutor(encodedTx []byte) (common.Address, error)

+ func (_InterchainClientV1 *InterchainClientV1CallerSession) GetExecutorById(transactionId [32]byte) (common.Address, error)

+ func (_InterchainClientV1 *InterchainClientV1CallerSession) GetInterchainFee(dstChainId *big.Int, srcExecutionService common.Address, ...) (*big.Int, error)

+ func (_InterchainClientV1 *InterchainClientV1CallerSession) GetLinkedClient(chainId *big.Int) ([32]byte, error)

+ func (_InterchainClientV1 *InterchainClientV1CallerSession) GetLinkedClientEVM(chainId *big.Int) (common.Address, error)

+ func (_InterchainClientV1 *InterchainClientV1CallerSession) INTERCHAINDB() (common.Address, error)

+ func (_InterchainClientV1 *InterchainClientV1CallerSession) IsExecutable(encodedTx []byte, proof [][32]byte) (bool, error)

+ func (_InterchainClientV1 *InterchainClientV1CallerSession) Owner() (common.Address, error)

+ type InterchainClientV1Events struct

+ func NewInterchainClientV1Events(address common.Address, backend bind.ContractBackend) (*InterchainClientV1Events, error)

+ type InterchainClientV1EventsCaller struct

+ func NewInterchainClientV1EventsCaller(address common.Address, caller bind.ContractCaller) (*InterchainClientV1EventsCaller, error)

+ type InterchainClientV1EventsCallerRaw struct

+ Contract *InterchainClientV1EventsCaller

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

+ type InterchainClientV1EventsCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *InterchainClientV1EventsCaller

+ type InterchainClientV1EventsExecutionFeesSet struct

+ ExecutionFees common.Address

+ Raw types.Log

+ type InterchainClientV1EventsExecutionFeesSetIterator struct

+ Event *InterchainClientV1EventsExecutionFeesSet

+ func (it *InterchainClientV1EventsExecutionFeesSetIterator) Close() error

+ func (it *InterchainClientV1EventsExecutionFeesSetIterator) Error() error

+ func (it *InterchainClientV1EventsExecutionFeesSetIterator) Next() bool

+ type InterchainClientV1EventsExecutionProofWritten struct

+ DbNonce *big.Int

+ EntryIndex uint64

+ Executor common.Address

+ Raw types.Log

+ TransactionId [32]byte

+ type InterchainClientV1EventsExecutionProofWrittenIterator struct

+ Event *InterchainClientV1EventsExecutionProofWritten

+ func (it *InterchainClientV1EventsExecutionProofWrittenIterator) Close() error

+ func (it *InterchainClientV1EventsExecutionProofWrittenIterator) Error() error

+ func (it *InterchainClientV1EventsExecutionProofWrittenIterator) Next() bool

+ type InterchainClientV1EventsFilterer struct

+ func NewInterchainClientV1EventsFilterer(address common.Address, filterer bind.ContractFilterer) (*InterchainClientV1EventsFilterer, error)

+ func (_InterchainClientV1Events *InterchainClientV1EventsFilterer) FilterExecutionFeesSet(opts *bind.FilterOpts) (*InterchainClientV1EventsExecutionFeesSetIterator, error)

+ func (_InterchainClientV1Events *InterchainClientV1EventsFilterer) FilterExecutionProofWritten(opts *bind.FilterOpts, transactionId [][32]byte, dbNonce []*big.Int, ...) (*InterchainClientV1EventsExecutionProofWrittenIterator, error)

+ func (_InterchainClientV1Events *InterchainClientV1EventsFilterer) FilterInterchainTransactionReceived(opts *bind.FilterOpts, transactionId [][32]byte, dbNonce []*big.Int, ...) (*InterchainClientV1EventsInterchainTransactionReceivedIterator, error)

+ func (_InterchainClientV1Events *InterchainClientV1EventsFilterer) FilterInterchainTransactionSent(opts *bind.FilterOpts, transactionId [][32]byte, dbNonce []*big.Int, ...) (*InterchainClientV1EventsInterchainTransactionSentIterator, error)

+ func (_InterchainClientV1Events *InterchainClientV1EventsFilterer) FilterLinkedClientSet(opts *bind.FilterOpts) (*InterchainClientV1EventsLinkedClientSetIterator, error)

+ func (_InterchainClientV1Events *InterchainClientV1EventsFilterer) ParseExecutionFeesSet(log types.Log) (*InterchainClientV1EventsExecutionFeesSet, error)

+ func (_InterchainClientV1Events *InterchainClientV1EventsFilterer) ParseExecutionProofWritten(log types.Log) (*InterchainClientV1EventsExecutionProofWritten, error)

+ func (_InterchainClientV1Events *InterchainClientV1EventsFilterer) ParseInterchainTransactionReceived(log types.Log) (*InterchainClientV1EventsInterchainTransactionReceived, error)

+ func (_InterchainClientV1Events *InterchainClientV1EventsFilterer) ParseInterchainTransactionSent(log types.Log) (*InterchainClientV1EventsInterchainTransactionSent, error)

+ func (_InterchainClientV1Events *InterchainClientV1EventsFilterer) ParseLinkedClientSet(log types.Log) (*InterchainClientV1EventsLinkedClientSet, error)

+ func (_InterchainClientV1Events *InterchainClientV1EventsFilterer) WatchExecutionFeesSet(opts *bind.WatchOpts, sink chan<- *InterchainClientV1EventsExecutionFeesSet) (event.Subscription, error)

+ func (_InterchainClientV1Events *InterchainClientV1EventsFilterer) WatchExecutionProofWritten(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ func (_InterchainClientV1Events *InterchainClientV1EventsFilterer) WatchInterchainTransactionReceived(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ func (_InterchainClientV1Events *InterchainClientV1EventsFilterer) WatchInterchainTransactionSent(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ func (_InterchainClientV1Events *InterchainClientV1EventsFilterer) WatchLinkedClientSet(opts *bind.WatchOpts, sink chan<- *InterchainClientV1EventsLinkedClientSet) (event.Subscription, error)

+ type InterchainClientV1EventsInterchainTransactionReceived struct

+ DbNonce *big.Int

+ DstReceiver [32]byte

+ EntryIndex uint64

+ Raw types.Log

+ SrcChainId *big.Int

+ SrcSender [32]byte

+ TransactionId [32]byte

+ type InterchainClientV1EventsInterchainTransactionReceivedIterator struct

+ Event *InterchainClientV1EventsInterchainTransactionReceived

+ func (it *InterchainClientV1EventsInterchainTransactionReceivedIterator) Close() error

+ func (it *InterchainClientV1EventsInterchainTransactionReceivedIterator) Error() error

+ func (it *InterchainClientV1EventsInterchainTransactionReceivedIterator) Next() bool

+ type InterchainClientV1EventsInterchainTransactionSent struct

+ DbNonce *big.Int

+ DstChainId *big.Int

+ DstReceiver [32]byte

+ EntryIndex uint64

+ ExecutionFee *big.Int

+ Message []byte

+ Options []byte

+ Raw types.Log

+ SrcSender [32]byte

+ TransactionId [32]byte

+ VerificationFee *big.Int

+ type InterchainClientV1EventsInterchainTransactionSentIterator struct

+ Event *InterchainClientV1EventsInterchainTransactionSent

+ func (it *InterchainClientV1EventsInterchainTransactionSentIterator) Close() error

+ func (it *InterchainClientV1EventsInterchainTransactionSentIterator) Error() error

+ func (it *InterchainClientV1EventsInterchainTransactionSentIterator) Next() bool

+ type InterchainClientV1EventsLinkedClientSet struct

+ ChainId *big.Int

+ Client [32]byte

+ Raw types.Log

+ type InterchainClientV1EventsLinkedClientSetIterator struct

+ Event *InterchainClientV1EventsLinkedClientSet

+ func (it *InterchainClientV1EventsLinkedClientSetIterator) Close() error

+ func (it *InterchainClientV1EventsLinkedClientSetIterator) Error() error

+ func (it *InterchainClientV1EventsLinkedClientSetIterator) Next() bool

+ type InterchainClientV1EventsRaw struct

+ Contract *InterchainClientV1Events

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

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

+ func (_InterchainClientV1Events *InterchainClientV1EventsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type InterchainClientV1EventsSession struct

+ CallOpts bind.CallOpts

+ Contract *InterchainClientV1Events

+ TransactOpts bind.TransactOpts

+ type InterchainClientV1EventsTransactor struct

+ func NewInterchainClientV1EventsTransactor(address common.Address, transactor bind.ContractTransactor) (*InterchainClientV1EventsTransactor, error)

+ type InterchainClientV1EventsTransactorRaw struct

+ Contract *InterchainClientV1EventsTransactor

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

+ func (_InterchainClientV1Events *InterchainClientV1EventsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type InterchainClientV1EventsTransactorSession struct

+ Contract *InterchainClientV1EventsTransactor

+ TransactOpts bind.TransactOpts

+ type InterchainClientV1ExecutionFeesSet struct

+ ExecutionFees common.Address

+ Raw types.Log

+ type InterchainClientV1ExecutionFeesSetIterator struct

+ Event *InterchainClientV1ExecutionFeesSet

+ func (it *InterchainClientV1ExecutionFeesSetIterator) Close() error

+ func (it *InterchainClientV1ExecutionFeesSetIterator) Error() error

+ func (it *InterchainClientV1ExecutionFeesSetIterator) Next() bool

+ type InterchainClientV1ExecutionProofWritten struct

+ DbNonce *big.Int

+ EntryIndex uint64

+ Executor common.Address

+ Raw types.Log

+ TransactionId [32]byte

+ type InterchainClientV1ExecutionProofWrittenIterator struct

+ Event *InterchainClientV1ExecutionProofWritten

+ func (it *InterchainClientV1ExecutionProofWrittenIterator) Close() error

+ func (it *InterchainClientV1ExecutionProofWrittenIterator) Error() error

+ func (it *InterchainClientV1ExecutionProofWrittenIterator) Next() bool

+ type InterchainClientV1Filterer struct

+ func NewInterchainClientV1Filterer(address common.Address, filterer bind.ContractFilterer) (*InterchainClientV1Filterer, error)

+ func (_InterchainClientV1 *InterchainClientV1Filterer) FilterExecutionFeesSet(opts *bind.FilterOpts) (*InterchainClientV1ExecutionFeesSetIterator, error)

+ func (_InterchainClientV1 *InterchainClientV1Filterer) FilterExecutionProofWritten(opts *bind.FilterOpts, transactionId [][32]byte, dbNonce []*big.Int, ...) (*InterchainClientV1ExecutionProofWrittenIterator, error)

+ func (_InterchainClientV1 *InterchainClientV1Filterer) FilterInterchainTransactionReceived(opts *bind.FilterOpts, transactionId [][32]byte, dbNonce []*big.Int, ...) (*InterchainClientV1InterchainTransactionReceivedIterator, error)

+ func (_InterchainClientV1 *InterchainClientV1Filterer) FilterInterchainTransactionSent(opts *bind.FilterOpts, transactionId [][32]byte, dbNonce []*big.Int, ...) (*InterchainClientV1InterchainTransactionSentIterator, error)

+ func (_InterchainClientV1 *InterchainClientV1Filterer) FilterLinkedClientSet(opts *bind.FilterOpts) (*InterchainClientV1LinkedClientSetIterator, error)

+ func (_InterchainClientV1 *InterchainClientV1Filterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*InterchainClientV1OwnershipTransferredIterator, error)

+ func (_InterchainClientV1 *InterchainClientV1Filterer) ParseExecutionFeesSet(log types.Log) (*InterchainClientV1ExecutionFeesSet, error)

+ func (_InterchainClientV1 *InterchainClientV1Filterer) ParseExecutionProofWritten(log types.Log) (*InterchainClientV1ExecutionProofWritten, error)

+ func (_InterchainClientV1 *InterchainClientV1Filterer) ParseInterchainTransactionReceived(log types.Log) (*InterchainClientV1InterchainTransactionReceived, error)

+ func (_InterchainClientV1 *InterchainClientV1Filterer) ParseInterchainTransactionSent(log types.Log) (*InterchainClientV1InterchainTransactionSent, error)

+ func (_InterchainClientV1 *InterchainClientV1Filterer) ParseLinkedClientSet(log types.Log) (*InterchainClientV1LinkedClientSet, error)

+ func (_InterchainClientV1 *InterchainClientV1Filterer) ParseOwnershipTransferred(log types.Log) (*InterchainClientV1OwnershipTransferred, error)

+ func (_InterchainClientV1 *InterchainClientV1Filterer) WatchExecutionFeesSet(opts *bind.WatchOpts, sink chan<- *InterchainClientV1ExecutionFeesSet) (event.Subscription, error)

+ func (_InterchainClientV1 *InterchainClientV1Filterer) WatchExecutionProofWritten(opts *bind.WatchOpts, sink chan<- *InterchainClientV1ExecutionProofWritten, ...) (event.Subscription, error)

+ func (_InterchainClientV1 *InterchainClientV1Filterer) WatchInterchainTransactionReceived(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ func (_InterchainClientV1 *InterchainClientV1Filterer) WatchInterchainTransactionSent(opts *bind.WatchOpts, sink chan<- *InterchainClientV1InterchainTransactionSent, ...) (event.Subscription, error)

+ func (_InterchainClientV1 *InterchainClientV1Filterer) WatchLinkedClientSet(opts *bind.WatchOpts, sink chan<- *InterchainClientV1LinkedClientSet) (event.Subscription, error)

+ func (_InterchainClientV1 *InterchainClientV1Filterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *InterchainClientV1OwnershipTransferred, ...) (event.Subscription, error)

+ type InterchainClientV1InterchainTransactionReceived struct

+ DbNonce *big.Int

+ DstReceiver [32]byte

+ EntryIndex uint64

+ Raw types.Log

+ SrcChainId *big.Int

+ SrcSender [32]byte

+ TransactionId [32]byte

+ type InterchainClientV1InterchainTransactionReceivedIterator struct

+ Event *InterchainClientV1InterchainTransactionReceived

+ func (it *InterchainClientV1InterchainTransactionReceivedIterator) Close() error

+ func (it *InterchainClientV1InterchainTransactionReceivedIterator) Error() error

+ func (it *InterchainClientV1InterchainTransactionReceivedIterator) Next() bool

+ type InterchainClientV1InterchainTransactionSent struct

+ DbNonce *big.Int

+ DstChainId *big.Int

+ DstReceiver [32]byte

+ EntryIndex uint64

+ ExecutionFee *big.Int

+ Message []byte

+ Options []byte

+ Raw types.Log

+ SrcSender [32]byte

+ TransactionId [32]byte

+ VerificationFee *big.Int

+ type InterchainClientV1InterchainTransactionSentIterator struct

+ Event *InterchainClientV1InterchainTransactionSent

+ func (it *InterchainClientV1InterchainTransactionSentIterator) Close() error

+ func (it *InterchainClientV1InterchainTransactionSentIterator) Error() error

+ func (it *InterchainClientV1InterchainTransactionSentIterator) Next() bool

+ type InterchainClientV1LinkedClientSet struct

+ ChainId *big.Int

+ Client [32]byte

+ Raw types.Log

+ type InterchainClientV1LinkedClientSetIterator struct

+ Event *InterchainClientV1LinkedClientSet

+ func (it *InterchainClientV1LinkedClientSetIterator) Close() error

+ func (it *InterchainClientV1LinkedClientSetIterator) Error() error

+ func (it *InterchainClientV1LinkedClientSetIterator) Next() bool

+ type InterchainClientV1OwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type InterchainClientV1OwnershipTransferredIterator struct

+ Event *InterchainClientV1OwnershipTransferred

+ func (it *InterchainClientV1OwnershipTransferredIterator) Close() error

+ func (it *InterchainClientV1OwnershipTransferredIterator) Error() error

+ func (it *InterchainClientV1OwnershipTransferredIterator) Next() bool

+ type InterchainClientV1Raw struct

+ Contract *InterchainClientV1

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

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

+ func (_InterchainClientV1 *InterchainClientV1Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type InterchainClientV1Session struct

+ CallOpts bind.CallOpts

+ Contract *InterchainClientV1

+ TransactOpts bind.TransactOpts

+ func (_InterchainClientV1 *InterchainClientV1Session) DecodeOptions(encodedOptions []byte) (OptionsV1, error)

+ func (_InterchainClientV1 *InterchainClientV1Session) EncodeTransaction(icTx InterchainTransaction) ([]byte, error)

+ func (_InterchainClientV1 *InterchainClientV1Session) ExecutionFees() (common.Address, error)

+ func (_InterchainClientV1 *InterchainClientV1Session) GetExecutor(encodedTx []byte) (common.Address, error)

+ func (_InterchainClientV1 *InterchainClientV1Session) GetExecutorById(transactionId [32]byte) (common.Address, error)

+ func (_InterchainClientV1 *InterchainClientV1Session) GetInterchainFee(dstChainId *big.Int, srcExecutionService common.Address, ...) (*big.Int, error)

+ func (_InterchainClientV1 *InterchainClientV1Session) GetLinkedClient(chainId *big.Int) ([32]byte, error)

+ func (_InterchainClientV1 *InterchainClientV1Session) GetLinkedClientEVM(chainId *big.Int) (common.Address, error)

+ func (_InterchainClientV1 *InterchainClientV1Session) INTERCHAINDB() (common.Address, error)

+ func (_InterchainClientV1 *InterchainClientV1Session) InterchainExecute(gasLimit *big.Int, transaction []byte, proof [][32]byte) (*types.Transaction, error)

+ func (_InterchainClientV1 *InterchainClientV1Session) InterchainSend(dstChainId *big.Int, receiver [32]byte, srcExecutionService common.Address, ...) (*types.Transaction, error)

+ func (_InterchainClientV1 *InterchainClientV1Session) InterchainSendEVM(dstChainId *big.Int, receiver common.Address, ...) (*types.Transaction, error)

+ func (_InterchainClientV1 *InterchainClientV1Session) IsExecutable(encodedTx []byte, proof [][32]byte) (bool, error)

+ func (_InterchainClientV1 *InterchainClientV1Session) Owner() (common.Address, error)

+ func (_InterchainClientV1 *InterchainClientV1Session) RenounceOwnership() (*types.Transaction, error)

+ func (_InterchainClientV1 *InterchainClientV1Session) SetExecutionFees(executionFees_ common.Address) (*types.Transaction, error)

+ func (_InterchainClientV1 *InterchainClientV1Session) SetLinkedClient(chainId *big.Int, client [32]byte) (*types.Transaction, error)

+ func (_InterchainClientV1 *InterchainClientV1Session) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_InterchainClientV1 *InterchainClientV1Session) WriteExecutionProof(transactionId [32]byte) (*types.Transaction, error)

+ type InterchainClientV1Transactor struct

+ func NewInterchainClientV1Transactor(address common.Address, transactor bind.ContractTransactor) (*InterchainClientV1Transactor, error)

+ func (_InterchainClientV1 *InterchainClientV1Transactor) InterchainExecute(opts *bind.TransactOpts, gasLimit *big.Int, transaction []byte, ...) (*types.Transaction, error)

+ func (_InterchainClientV1 *InterchainClientV1Transactor) InterchainSend(opts *bind.TransactOpts, dstChainId *big.Int, receiver [32]byte, ...) (*types.Transaction, error)

+ func (_InterchainClientV1 *InterchainClientV1Transactor) InterchainSendEVM(opts *bind.TransactOpts, dstChainId *big.Int, receiver common.Address, ...) (*types.Transaction, error)

+ func (_InterchainClientV1 *InterchainClientV1Transactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_InterchainClientV1 *InterchainClientV1Transactor) SetExecutionFees(opts *bind.TransactOpts, executionFees_ common.Address) (*types.Transaction, error)

+ func (_InterchainClientV1 *InterchainClientV1Transactor) SetLinkedClient(opts *bind.TransactOpts, chainId *big.Int, client [32]byte) (*types.Transaction, error)

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

+ func (_InterchainClientV1 *InterchainClientV1Transactor) WriteExecutionProof(opts *bind.TransactOpts, transactionId [32]byte) (*types.Transaction, error)

+ type InterchainClientV1TransactorRaw struct

+ Contract *InterchainClientV1Transactor

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

+ func (_InterchainClientV1 *InterchainClientV1TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type InterchainClientV1TransactorSession struct

+ Contract *InterchainClientV1Transactor

+ TransactOpts bind.TransactOpts

+ func (_InterchainClientV1 *InterchainClientV1TransactorSession) InterchainExecute(gasLimit *big.Int, transaction []byte, proof [][32]byte) (*types.Transaction, error)

+ func (_InterchainClientV1 *InterchainClientV1TransactorSession) InterchainSend(dstChainId *big.Int, receiver [32]byte, srcExecutionService common.Address, ...) (*types.Transaction, error)

+ func (_InterchainClientV1 *InterchainClientV1TransactorSession) InterchainSendEVM(dstChainId *big.Int, receiver common.Address, ...) (*types.Transaction, error)

+ func (_InterchainClientV1 *InterchainClientV1TransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_InterchainClientV1 *InterchainClientV1TransactorSession) SetExecutionFees(executionFees_ common.Address) (*types.Transaction, error)

+ func (_InterchainClientV1 *InterchainClientV1TransactorSession) SetLinkedClient(chainId *big.Int, client [32]byte) (*types.Transaction, error)

+ func (_InterchainClientV1 *InterchainClientV1TransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_InterchainClientV1 *InterchainClientV1TransactorSession) WriteExecutionProof(transactionId [32]byte) (*types.Transaction, error)

+ type InterchainEntry struct

+ DataHash [32]byte

+ DbNonce *big.Int

+ EntryIndex uint64

+ SrcChainId *big.Int

+ SrcWriter [32]byte

+ type InterchainEntryLib struct

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

+ func NewInterchainEntryLib(address common.Address, backend bind.ContractBackend) (*InterchainEntryLib, error)

+ type InterchainEntryLibCaller struct

+ func NewInterchainEntryLibCaller(address common.Address, caller bind.ContractCaller) (*InterchainEntryLibCaller, error)

+ type InterchainEntryLibCallerRaw struct

+ Contract *InterchainEntryLibCaller

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

+ type InterchainEntryLibCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *InterchainEntryLibCaller

+ type InterchainEntryLibFilterer struct

+ func NewInterchainEntryLibFilterer(address common.Address, filterer bind.ContractFilterer) (*InterchainEntryLibFilterer, error)

+ type InterchainEntryLibRaw struct

+ Contract *InterchainEntryLib

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

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

+ func (_InterchainEntryLib *InterchainEntryLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type InterchainEntryLibSession struct

+ CallOpts bind.CallOpts

+ Contract *InterchainEntryLib

+ TransactOpts bind.TransactOpts

+ type InterchainEntryLibTransactor struct

+ func NewInterchainEntryLibTransactor(address common.Address, transactor bind.ContractTransactor) (*InterchainEntryLibTransactor, error)

+ type InterchainEntryLibTransactorRaw struct

+ Contract *InterchainEntryLibTransactor

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

+ func (_InterchainEntryLib *InterchainEntryLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type InterchainEntryLibTransactorSession struct

+ Contract *InterchainEntryLibTransactor

+ TransactOpts bind.TransactOpts

+ type InterchainTransaction struct

+ DbNonce *big.Int

+ DstChainId *big.Int

+ DstReceiver [32]byte

+ EntryIndex uint64

+ Message []byte

+ Options []byte

+ SrcChainId *big.Int

+ SrcSender [32]byte

+ type InterchainTransactionLib struct

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

+ func NewInterchainTransactionLib(address common.Address, backend bind.ContractBackend) (*InterchainTransactionLib, error)

+ type InterchainTransactionLibCaller struct

+ func NewInterchainTransactionLibCaller(address common.Address, caller bind.ContractCaller) (*InterchainTransactionLibCaller, error)

+ type InterchainTransactionLibCallerRaw struct

+ Contract *InterchainTransactionLibCaller

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

+ type InterchainTransactionLibCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *InterchainTransactionLibCaller

+ type InterchainTransactionLibFilterer struct

+ func NewInterchainTransactionLibFilterer(address common.Address, filterer bind.ContractFilterer) (*InterchainTransactionLibFilterer, error)

+ type InterchainTransactionLibRaw struct

+ Contract *InterchainTransactionLib

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

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

+ func (_InterchainTransactionLib *InterchainTransactionLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type InterchainTransactionLibSession struct

+ CallOpts bind.CallOpts

+ Contract *InterchainTransactionLib

+ TransactOpts bind.TransactOpts

+ type InterchainTransactionLibTransactor struct

+ func NewInterchainTransactionLibTransactor(address common.Address, transactor bind.ContractTransactor) (*InterchainTransactionLibTransactor, error)

+ type InterchainTransactionLibTransactorRaw struct

+ Contract *InterchainTransactionLibTransactor

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

+ func (_InterchainTransactionLib *InterchainTransactionLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type InterchainTransactionLibTransactorSession struct

+ Contract *InterchainTransactionLibTransactor

+ TransactOpts bind.TransactOpts

+ type InterchainTxDescriptor struct

+ DbNonce *big.Int

+ EntryIndex uint64

+ TransactionId [32]byte

+ type OptionsLib struct

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

+ func NewOptionsLib(address common.Address, backend bind.ContractBackend) (*OptionsLib, error)

+ type OptionsLibCaller struct

+ func NewOptionsLibCaller(address common.Address, caller bind.ContractCaller) (*OptionsLibCaller, error)

+ type OptionsLibCallerRaw struct

+ Contract *OptionsLibCaller

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

+ type OptionsLibCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OptionsLibCaller

+ type OptionsLibFilterer struct

+ func NewOptionsLibFilterer(address common.Address, filterer bind.ContractFilterer) (*OptionsLibFilterer, error)

+ type OptionsLibRaw struct

+ Contract *OptionsLib

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

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

+ func (_OptionsLib *OptionsLibRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OptionsLibSession struct

+ CallOpts bind.CallOpts

+ Contract *OptionsLib

+ TransactOpts bind.TransactOpts

+ type OptionsLibTransactor struct

+ func NewOptionsLibTransactor(address common.Address, transactor bind.ContractTransactor) (*OptionsLibTransactor, error)

+ type OptionsLibTransactorRaw struct

+ Contract *OptionsLibTransactor

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

+ func (_OptionsLib *OptionsLibTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OptionsLibTransactorSession struct

+ Contract *OptionsLibTransactor

+ TransactOpts bind.TransactOpts

+ type OptionsV1 struct

+ GasAirdrop *big.Int

+ GasLimit *big.Int

+ type Ownable struct

+ func NewOwnable(address common.Address, backend bind.ContractBackend) (*Ownable, error)

+ type OwnableCaller struct

+ func NewOwnableCaller(address common.Address, caller bind.ContractCaller) (*OwnableCaller, error)

+ func (_Ownable *OwnableCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ type OwnableCallerRaw struct

+ Contract *OwnableCaller

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

+ type OwnableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OwnableCaller

+ func (_Ownable *OwnableCallerSession) Owner() (common.Address, error)

+ type OwnableFilterer struct

+ func NewOwnableFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableFilterer, error)

+ func (_Ownable *OwnableFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*OwnableOwnershipTransferredIterator, error)

+ func (_Ownable *OwnableFilterer) ParseOwnershipTransferred(log types.Log) (*OwnableOwnershipTransferred, error)

+ func (_Ownable *OwnableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OwnableOwnershipTransferred, ...) (event.Subscription, error)

+ type OwnableOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type OwnableOwnershipTransferredIterator struct

+ Event *OwnableOwnershipTransferred

+ func (it *OwnableOwnershipTransferredIterator) Close() error

+ func (it *OwnableOwnershipTransferredIterator) Error() error

+ func (it *OwnableOwnershipTransferredIterator) Next() bool

+ type OwnableRaw struct

+ Contract *Ownable

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

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

+ func (_Ownable *OwnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OwnableSession struct

+ CallOpts bind.CallOpts

+ Contract *Ownable

+ TransactOpts bind.TransactOpts

+ func (_Ownable *OwnableSession) Owner() (common.Address, error)

+ func (_Ownable *OwnableSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Ownable *OwnableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type OwnableTransactor struct

+ func NewOwnableTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableTransactor, error)

+ func (_Ownable *OwnableTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

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

+ type OwnableTransactorRaw struct

+ Contract *OwnableTransactor

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

+ func (_Ownable *OwnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OwnableTransactorSession struct

+ Contract *OwnableTransactor

+ TransactOpts bind.TransactOpts

+ func (_Ownable *OwnableTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Ownable *OwnableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type Parser interface

+ ParseEvent func(log ethTypes.Log) (_ EventType, event interface{}, ok bool)

+ func NewParser(synapseModuleAddress common.Address) (Parser, error)

+ type TypeCasts struct

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

+ func NewTypeCasts(address common.Address, backend bind.ContractBackend) (*TypeCasts, error)

+ type TypeCastsCaller struct

+ func NewTypeCastsCaller(address common.Address, caller bind.ContractCaller) (*TypeCastsCaller, error)

+ type TypeCastsCallerRaw struct

+ Contract *TypeCastsCaller

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

+ type TypeCastsCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *TypeCastsCaller

+ type TypeCastsFilterer struct

+ func NewTypeCastsFilterer(address common.Address, filterer bind.ContractFilterer) (*TypeCastsFilterer, error)

+ type TypeCastsRaw struct

+ Contract *TypeCasts

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

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

+ func (_TypeCasts *TypeCastsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type TypeCastsSession struct

+ CallOpts bind.CallOpts

+ Contract *TypeCasts

+ TransactOpts bind.TransactOpts

+ type TypeCastsTransactor struct

+ func NewTypeCastsTransactor(address common.Address, transactor bind.ContractTransactor) (*TypeCastsTransactor, error)

+ type TypeCastsTransactorRaw struct

+ Contract *TypeCastsTransactor

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

+ func (_TypeCasts *TypeCastsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type TypeCastsTransactorSession struct

+ Contract *TypeCastsTransactor

+ TransactOpts bind.TransactOpts

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