mocks

package

Go to main page

Versions in this module

v0

v0.9.7

Feb 11, 2026

Changes in this version

type EVMService

+ func (_m *EVMService) GetLatestLPBlock(ctx context.Context) (*evm.LPBlock, error)

type EVMService_Expecter

+ func (_e *EVMService_Expecter) GetLatestLPBlock(ctx interface{}) *EVMService_GetLatestLPBlock_Call

+ type EVMService_GetLatestLPBlock_Call struct

+ func (_c *EVMService_GetLatestLPBlock_Call) Return(_a0 *evm.LPBlock, _a1 error) *EVMService_GetLatestLPBlock_Call

+ func (_c *EVMService_GetLatestLPBlock_Call) Run(run func(ctx context.Context)) *EVMService_GetLatestLPBlock_Call

+ func (_c *EVMService_GetLatestLPBlock_Call) RunAndReturn(run func(context.Context) (*evm.LPBlock, error)) *EVMService_GetLatestLPBlock_Call

+ type SolanaService struct

+ func NewSolanaService(t interface{ ... }) *SolanaService

+ func (_m *SolanaService) EXPECT() *SolanaService_Expecter

+ func (_m *SolanaService) GetAccountInfoWithOpts(ctx context.Context, req solana.GetAccountInfoRequest) (*solana.GetAccountInfoReply, error)

+ func (_m *SolanaService) GetBalance(ctx context.Context, req solana.GetBalanceRequest) (*solana.GetBalanceReply, error)

+ func (_m *SolanaService) GetBlock(ctx context.Context, req solana.GetBlockRequest) (*solana.GetBlockReply, error)

+ func (_m *SolanaService) GetFeeForMessage(ctx context.Context, req solana.GetFeeForMessageRequest) (*solana.GetFeeForMessageReply, error)

+ func (_m *SolanaService) GetLatestLPBlock(ctx context.Context) (*solana.LPBlock, error)

+ func (_m *SolanaService) GetMultipleAccountsWithOpts(ctx context.Context, req solana.GetMultipleAccountsRequest) (*solana.GetMultipleAccountsReply, error)

+ func (_m *SolanaService) GetSignatureStatuses(ctx context.Context, req solana.GetSignatureStatusesRequest) (*solana.GetSignatureStatusesReply, error)

+ func (_m *SolanaService) GetSlotHeight(ctx context.Context, req solana.GetSlotHeightRequest) (*solana.GetSlotHeightReply, error)

+ func (_m *SolanaService) GetTransaction(ctx context.Context, req solana.GetTransactionRequest) (*solana.GetTransactionReply, error)

+ func (_m *SolanaService) QueryTrackedLogs(ctx context.Context, filterQuery []query.Expression, ...) ([]*solana.Log, error)

+ func (_m *SolanaService) RegisterLogTracking(ctx context.Context, req solana.LPFilterQuery) error

+ func (_m *SolanaService) SimulateTX(ctx context.Context, req solana.SimulateTXRequest) (*solana.SimulateTXReply, error)

+ func (_m *SolanaService) SubmitTransaction(ctx context.Context, req solana.SubmitTransactionRequest) (*solana.SubmitTransactionReply, error)

+ func (_m *SolanaService) UnregisterLogTracking(ctx context.Context, filterName string) error

+ type SolanaService_Expecter struct

+ func (_e *SolanaService_Expecter) GetAccountInfoWithOpts(ctx interface{}, req interface{}) *SolanaService_GetAccountInfoWithOpts_Call

+ func (_e *SolanaService_Expecter) GetBalance(ctx interface{}, req interface{}) *SolanaService_GetBalance_Call

+ func (_e *SolanaService_Expecter) GetBlock(ctx interface{}, req interface{}) *SolanaService_GetBlock_Call

+ func (_e *SolanaService_Expecter) GetFeeForMessage(ctx interface{}, req interface{}) *SolanaService_GetFeeForMessage_Call

+ func (_e *SolanaService_Expecter) GetLatestLPBlock(ctx interface{}) *SolanaService_GetLatestLPBlock_Call

+ func (_e *SolanaService_Expecter) GetMultipleAccountsWithOpts(ctx interface{}, req interface{}) *SolanaService_GetMultipleAccountsWithOpts_Call

+ func (_e *SolanaService_Expecter) GetSignatureStatuses(ctx interface{}, req interface{}) *SolanaService_GetSignatureStatuses_Call

+ func (_e *SolanaService_Expecter) GetSlotHeight(ctx interface{}, req interface{}) *SolanaService_GetSlotHeight_Call

+ func (_e *SolanaService_Expecter) GetTransaction(ctx interface{}, req interface{}) *SolanaService_GetTransaction_Call

+ func (_e *SolanaService_Expecter) QueryTrackedLogs(ctx interface{}, filterQuery interface{}, limitAndSort interface{}) *SolanaService_QueryTrackedLogs_Call

+ func (_e *SolanaService_Expecter) RegisterLogTracking(ctx interface{}, req interface{}) *SolanaService_RegisterLogTracking_Call

+ func (_e *SolanaService_Expecter) SimulateTX(ctx interface{}, req interface{}) *SolanaService_SimulateTX_Call

+ func (_e *SolanaService_Expecter) SubmitTransaction(ctx interface{}, req interface{}) *SolanaService_SubmitTransaction_Call

+ func (_e *SolanaService_Expecter) UnregisterLogTracking(ctx interface{}, filterName interface{}) *SolanaService_UnregisterLogTracking_Call

+ type SolanaService_GetAccountInfoWithOpts_Call struct

+ func (_c *SolanaService_GetAccountInfoWithOpts_Call) Return(_a0 *solana.GetAccountInfoReply, _a1 error) *SolanaService_GetAccountInfoWithOpts_Call

+ func (_c *SolanaService_GetAccountInfoWithOpts_Call) Run(run func(ctx context.Context, req solana.GetAccountInfoRequest)) *SolanaService_GetAccountInfoWithOpts_Call

+ func (_c *SolanaService_GetAccountInfoWithOpts_Call) RunAndReturn(...) *SolanaService_GetAccountInfoWithOpts_Call

+ type SolanaService_GetBalance_Call struct

+ func (_c *SolanaService_GetBalance_Call) Return(_a0 *solana.GetBalanceReply, _a1 error) *SolanaService_GetBalance_Call

+ func (_c *SolanaService_GetBalance_Call) Run(run func(ctx context.Context, req solana.GetBalanceRequest)) *SolanaService_GetBalance_Call

+ func (_c *SolanaService_GetBalance_Call) RunAndReturn(...) *SolanaService_GetBalance_Call

+ type SolanaService_GetBlock_Call struct

+ func (_c *SolanaService_GetBlock_Call) Return(_a0 *solana.GetBlockReply, _a1 error) *SolanaService_GetBlock_Call

+ func (_c *SolanaService_GetBlock_Call) Run(run func(ctx context.Context, req solana.GetBlockRequest)) *SolanaService_GetBlock_Call

+ func (_c *SolanaService_GetBlock_Call) RunAndReturn(...) *SolanaService_GetBlock_Call

+ type SolanaService_GetFeeForMessage_Call struct

+ func (_c *SolanaService_GetFeeForMessage_Call) Return(_a0 *solana.GetFeeForMessageReply, _a1 error) *SolanaService_GetFeeForMessage_Call

+ func (_c *SolanaService_GetFeeForMessage_Call) Run(run func(ctx context.Context, req solana.GetFeeForMessageRequest)) *SolanaService_GetFeeForMessage_Call

+ func (_c *SolanaService_GetFeeForMessage_Call) RunAndReturn(...) *SolanaService_GetFeeForMessage_Call

+ type SolanaService_GetLatestLPBlock_Call struct

+ func (_c *SolanaService_GetLatestLPBlock_Call) Return(_a0 *solana.LPBlock, _a1 error) *SolanaService_GetLatestLPBlock_Call

+ func (_c *SolanaService_GetLatestLPBlock_Call) Run(run func(ctx context.Context)) *SolanaService_GetLatestLPBlock_Call

+ func (_c *SolanaService_GetLatestLPBlock_Call) RunAndReturn(run func(context.Context) (*solana.LPBlock, error)) *SolanaService_GetLatestLPBlock_Call

+ type SolanaService_GetMultipleAccountsWithOpts_Call struct

+ func (_c *SolanaService_GetMultipleAccountsWithOpts_Call) Return(_a0 *solana.GetMultipleAccountsReply, _a1 error) *SolanaService_GetMultipleAccountsWithOpts_Call

+ func (_c *SolanaService_GetMultipleAccountsWithOpts_Call) Run(run func(ctx context.Context, req solana.GetMultipleAccountsRequest)) *SolanaService_GetMultipleAccountsWithOpts_Call

+ func (_c *SolanaService_GetMultipleAccountsWithOpts_Call) RunAndReturn(...) *SolanaService_GetMultipleAccountsWithOpts_Call

+ type SolanaService_GetSignatureStatuses_Call struct

+ func (_c *SolanaService_GetSignatureStatuses_Call) Return(_a0 *solana.GetSignatureStatusesReply, _a1 error) *SolanaService_GetSignatureStatuses_Call

+ func (_c *SolanaService_GetSignatureStatuses_Call) Run(run func(ctx context.Context, req solana.GetSignatureStatusesRequest)) *SolanaService_GetSignatureStatuses_Call

+ func (_c *SolanaService_GetSignatureStatuses_Call) RunAndReturn(...) *SolanaService_GetSignatureStatuses_Call

+ type SolanaService_GetSlotHeight_Call struct

+ func (_c *SolanaService_GetSlotHeight_Call) Return(_a0 *solana.GetSlotHeightReply, _a1 error) *SolanaService_GetSlotHeight_Call

+ func (_c *SolanaService_GetSlotHeight_Call) Run(run func(ctx context.Context, req solana.GetSlotHeightRequest)) *SolanaService_GetSlotHeight_Call

+ func (_c *SolanaService_GetSlotHeight_Call) RunAndReturn(...) *SolanaService_GetSlotHeight_Call

+ type SolanaService_GetTransaction_Call struct

+ func (_c *SolanaService_GetTransaction_Call) Return(_a0 *solana.GetTransactionReply, _a1 error) *SolanaService_GetTransaction_Call

+ func (_c *SolanaService_GetTransaction_Call) Run(run func(ctx context.Context, req solana.GetTransactionRequest)) *SolanaService_GetTransaction_Call

+ func (_c *SolanaService_GetTransaction_Call) RunAndReturn(...) *SolanaService_GetTransaction_Call

+ type SolanaService_QueryTrackedLogs_Call struct

+ func (_c *SolanaService_QueryTrackedLogs_Call) Return(_a0 []*solana.Log, _a1 error) *SolanaService_QueryTrackedLogs_Call

+ func (_c *SolanaService_QueryTrackedLogs_Call) Run(run func(ctx context.Context, filterQuery []query.Expression, ...)) *SolanaService_QueryTrackedLogs_Call

+ func (_c *SolanaService_QueryTrackedLogs_Call) RunAndReturn(...) *SolanaService_QueryTrackedLogs_Call

+ type SolanaService_RegisterLogTracking_Call struct

+ func (_c *SolanaService_RegisterLogTracking_Call) Return(_a0 error) *SolanaService_RegisterLogTracking_Call

+ func (_c *SolanaService_RegisterLogTracking_Call) Run(run func(ctx context.Context, req solana.LPFilterQuery)) *SolanaService_RegisterLogTracking_Call

+ func (_c *SolanaService_RegisterLogTracking_Call) RunAndReturn(run func(context.Context, solana.LPFilterQuery) error) *SolanaService_RegisterLogTracking_Call

+ type SolanaService_SimulateTX_Call struct

+ func (_c *SolanaService_SimulateTX_Call) Return(_a0 *solana.SimulateTXReply, _a1 error) *SolanaService_SimulateTX_Call

+ func (_c *SolanaService_SimulateTX_Call) Run(run func(ctx context.Context, req solana.SimulateTXRequest)) *SolanaService_SimulateTX_Call

+ func (_c *SolanaService_SimulateTX_Call) RunAndReturn(...) *SolanaService_SimulateTX_Call

+ type SolanaService_SubmitTransaction_Call struct

+ func (_c *SolanaService_SubmitTransaction_Call) Return(_a0 *solana.SubmitTransactionReply, _a1 error) *SolanaService_SubmitTransaction_Call

+ func (_c *SolanaService_SubmitTransaction_Call) Run(run func(ctx context.Context, req solana.SubmitTransactionRequest)) *SolanaService_SubmitTransaction_Call

+ func (_c *SolanaService_SubmitTransaction_Call) RunAndReturn(...) *SolanaService_SubmitTransaction_Call

+ type SolanaService_UnregisterLogTracking_Call struct

+ func (_c *SolanaService_UnregisterLogTracking_Call) Return(_a0 error) *SolanaService_UnregisterLogTracking_Call

+ func (_c *SolanaService_UnregisterLogTracking_Call) Run(run func(ctx context.Context, filterName string)) *SolanaService_UnregisterLogTracking_Call

+ func (_c *SolanaService_UnregisterLogTracking_Call) RunAndReturn(run func(context.Context, string) error) *SolanaService_UnregisterLogTracking_Call

v0.9.6

Sep 26, 2025

v0.9.5

Sep 19, 2025

v0.9.4

Sep 2, 2025

v0.9.3

Aug 21, 2025

v0.9.2

Aug 21, 2025

v0.9.1

Aug 20, 2025

v0.9.0

Aug 8, 2025

Changes in this version

type EVMService

+ func (_m *EVMService) GetFiltersNames(ctx context.Context) ([]string, error)

+ func (_m *EVMService) HeaderByNumber(ctx context.Context, request evm.HeaderByNumberRequest) (*evm.HeaderByNumberReply, error)

type EVMService_Expecter

+ func (_e *EVMService_Expecter) GetFiltersNames(ctx interface{}) *EVMService_GetFiltersNames_Call

+ func (_e *EVMService_Expecter) HeaderByNumber(ctx interface{}, request interface{}) *EVMService_HeaderByNumber_Call

+ type EVMService_GetFiltersNames_Call struct

+ func (_c *EVMService_GetFiltersNames_Call) Return(_a0 []string, _a1 error) *EVMService_GetFiltersNames_Call

+ func (_c *EVMService_GetFiltersNames_Call) Run(run func(ctx context.Context)) *EVMService_GetFiltersNames_Call

+ func (_c *EVMService_GetFiltersNames_Call) RunAndReturn(run func(context.Context) ([]string, error)) *EVMService_GetFiltersNames_Call

+ type EVMService_HeaderByNumber_Call struct

+ func (_c *EVMService_HeaderByNumber_Call) Return(_a0 *evm.HeaderByNumberReply, _a1 error) *EVMService_HeaderByNumber_Call

+ func (_c *EVMService_HeaderByNumber_Call) Run(run func(ctx context.Context, request evm.HeaderByNumberRequest)) *EVMService_HeaderByNumber_Call

+ func (_c *EVMService_HeaderByNumber_Call) RunAndReturn(...) *EVMService_HeaderByNumber_Call

v0.8.0

Jul 14, 2025

Changes in this version

+ type TONService struct

+ func NewTONService(t interface{ ... }) *TONService

+ func (_m *TONService) EXPECT() *TONService_Expecter

+ func (_m *TONService) GetAccountBalance(ctx context.Context, address string, block *ton.BlockIDExt) (*ton.Balance, error)

+ func (_m *TONService) GetBlockData(ctx context.Context, block *ton.BlockIDExt) (*ton.Block, error)

+ func (_m *TONService) GetMasterchainInfo(ctx context.Context) (*ton.BlockIDExt, error)

+ func (_m *TONService) GetTxExecutionFees(ctx context.Context, lt uint64) (*ton.TransactionFee, error)

+ func (_m *TONService) GetTxStatus(ctx context.Context, lt uint64) (types.TransactionStatus, int32, error)

+ func (_m *TONService) HasFilter(ctx context.Context, name string) bool

+ func (_m *TONService) RegisterFilter(ctx context.Context, filter ton.LPFilterQuery) error

+ func (_m *TONService) SendTx(ctx context.Context, msg ton.Message) error

+ func (_m *TONService) UnregisterFilter(ctx context.Context, name string) error

+ type TONService_Expecter struct

+ func (_e *TONService_Expecter) GetAccountBalance(ctx interface{}, address interface{}, block interface{}) *TONService_GetAccountBalance_Call

+ func (_e *TONService_Expecter) GetBlockData(ctx interface{}, block interface{}) *TONService_GetBlockData_Call

+ func (_e *TONService_Expecter) GetMasterchainInfo(ctx interface{}) *TONService_GetMasterchainInfo_Call

+ func (_e *TONService_Expecter) GetTxExecutionFees(ctx interface{}, lt interface{}) *TONService_GetTxExecutionFees_Call

+ func (_e *TONService_Expecter) GetTxStatus(ctx interface{}, lt interface{}) *TONService_GetTxStatus_Call

+ func (_e *TONService_Expecter) HasFilter(ctx interface{}, name interface{}) *TONService_HasFilter_Call

+ func (_e *TONService_Expecter) RegisterFilter(ctx interface{}, filter interface{}) *TONService_RegisterFilter_Call

+ func (_e *TONService_Expecter) SendTx(ctx interface{}, msg interface{}) *TONService_SendTx_Call

+ func (_e *TONService_Expecter) UnregisterFilter(ctx interface{}, name interface{}) *TONService_UnregisterFilter_Call

+ type TONService_GetAccountBalance_Call struct

+ func (_c *TONService_GetAccountBalance_Call) Return(_a0 *ton.Balance, _a1 error) *TONService_GetAccountBalance_Call

+ func (_c *TONService_GetAccountBalance_Call) Run(run func(ctx context.Context, address string, block *ton.BlockIDExt)) *TONService_GetAccountBalance_Call

+ func (_c *TONService_GetAccountBalance_Call) RunAndReturn(run func(context.Context, string, *ton.BlockIDExt) (*ton.Balance, error)) *TONService_GetAccountBalance_Call

+ type TONService_GetBlockData_Call struct

+ func (_c *TONService_GetBlockData_Call) Return(_a0 *ton.Block, _a1 error) *TONService_GetBlockData_Call

+ func (_c *TONService_GetBlockData_Call) Run(run func(ctx context.Context, block *ton.BlockIDExt)) *TONService_GetBlockData_Call

+ func (_c *TONService_GetBlockData_Call) RunAndReturn(run func(context.Context, *ton.BlockIDExt) (*ton.Block, error)) *TONService_GetBlockData_Call

+ type TONService_GetMasterchainInfo_Call struct

+ func (_c *TONService_GetMasterchainInfo_Call) Return(_a0 *ton.BlockIDExt, _a1 error) *TONService_GetMasterchainInfo_Call

+ func (_c *TONService_GetMasterchainInfo_Call) Run(run func(ctx context.Context)) *TONService_GetMasterchainInfo_Call

+ func (_c *TONService_GetMasterchainInfo_Call) RunAndReturn(run func(context.Context) (*ton.BlockIDExt, error)) *TONService_GetMasterchainInfo_Call

+ type TONService_GetTxExecutionFees_Call struct

+ func (_c *TONService_GetTxExecutionFees_Call) Return(_a0 *ton.TransactionFee, _a1 error) *TONService_GetTxExecutionFees_Call

+ func (_c *TONService_GetTxExecutionFees_Call) Run(run func(ctx context.Context, lt uint64)) *TONService_GetTxExecutionFees_Call

+ func (_c *TONService_GetTxExecutionFees_Call) RunAndReturn(run func(context.Context, uint64) (*ton.TransactionFee, error)) *TONService_GetTxExecutionFees_Call

+ type TONService_GetTxStatus_Call struct

+ func (_c *TONService_GetTxStatus_Call) Return(_a0 types.TransactionStatus, _a1 int32, _a2 error) *TONService_GetTxStatus_Call

+ func (_c *TONService_GetTxStatus_Call) Run(run func(ctx context.Context, lt uint64)) *TONService_GetTxStatus_Call

+ func (_c *TONService_GetTxStatus_Call) RunAndReturn(run func(context.Context, uint64) (types.TransactionStatus, int32, error)) *TONService_GetTxStatus_Call

+ type TONService_HasFilter_Call struct

+ func (_c *TONService_HasFilter_Call) Return(_a0 bool) *TONService_HasFilter_Call

+ func (_c *TONService_HasFilter_Call) Run(run func(ctx context.Context, name string)) *TONService_HasFilter_Call

+ func (_c *TONService_HasFilter_Call) RunAndReturn(run func(context.Context, string) bool) *TONService_HasFilter_Call

+ type TONService_RegisterFilter_Call struct

+ func (_c *TONService_RegisterFilter_Call) Return(_a0 error) *TONService_RegisterFilter_Call

+ func (_c *TONService_RegisterFilter_Call) Run(run func(ctx context.Context, filter ton.LPFilterQuery)) *TONService_RegisterFilter_Call

+ func (_c *TONService_RegisterFilter_Call) RunAndReturn(run func(context.Context, ton.LPFilterQuery) error) *TONService_RegisterFilter_Call

+ type TONService_SendTx_Call struct

+ func (_c *TONService_SendTx_Call) Return(_a0 error) *TONService_SendTx_Call

+ func (_c *TONService_SendTx_Call) Run(run func(ctx context.Context, msg ton.Message)) *TONService_SendTx_Call

+ func (_c *TONService_SendTx_Call) RunAndReturn(run func(context.Context, ton.Message) error) *TONService_SendTx_Call

+ type TONService_UnregisterFilter_Call struct

+ func (_c *TONService_UnregisterFilter_Call) Return(_a0 error) *TONService_UnregisterFilter_Call

+ func (_c *TONService_UnregisterFilter_Call) Run(run func(ctx context.Context, name string)) *TONService_UnregisterFilter_Call

+ func (_c *TONService_UnregisterFilter_Call) RunAndReturn(run func(context.Context, string) error) *TONService_UnregisterFilter_Call

v0.7.2

Aug 1, 2025

v0.7.1

Jul 28, 2025

Changes in this version

+ type ContractReader struct

+ func NewContractReader(t interface{ ... }) *ContractReader

+ func (_m *ContractReader) BatchGetLatestValues(ctx context.Context, request types.BatchGetLatestValuesRequest) (types.BatchGetLatestValuesResult, error)

+ func (_m *ContractReader) Bind(ctx context.Context, bindings []types.BoundContract) error

+ func (_m *ContractReader) Close() error

+ func (_m *ContractReader) EXPECT() *ContractReader_Expecter

+ func (_m *ContractReader) GetLatestValue(ctx context.Context, readIdentifier string, ...) error

+ func (_m *ContractReader) GetLatestValueWithHeadData(ctx context.Context, readIdentifier string, ...) (*types.Head, error)

+ func (_m *ContractReader) HealthReport() map[string]error

+ func (_m *ContractReader) Name() string

+ func (_m *ContractReader) QueryKey(ctx context.Context, contract types.BoundContract, filter query.KeyFilter, ...) ([]types.Sequence, error)

+ func (_m *ContractReader) QueryKeys(ctx context.Context, filters []types.ContractKeyFilter, ...) (iter.Seq2[string, types.Sequence], error)

+ func (_m *ContractReader) Ready() error

+ func (_m *ContractReader) Start(_a0 context.Context) error

+ func (_m *ContractReader) Unbind(ctx context.Context, bindings []types.BoundContract) error

+ type ContractReader_BatchGetLatestValues_Call struct

+ func (_c *ContractReader_BatchGetLatestValues_Call) Return(_a0 types.BatchGetLatestValuesResult, _a1 error) *ContractReader_BatchGetLatestValues_Call

+ func (_c *ContractReader_BatchGetLatestValues_Call) Run(run func(ctx context.Context, request types.BatchGetLatestValuesRequest)) *ContractReader_BatchGetLatestValues_Call

+ func (_c *ContractReader_BatchGetLatestValues_Call) RunAndReturn(...) *ContractReader_BatchGetLatestValues_Call

+ type ContractReader_Bind_Call struct

+ func (_c *ContractReader_Bind_Call) Return(_a0 error) *ContractReader_Bind_Call

+ func (_c *ContractReader_Bind_Call) Run(run func(ctx context.Context, bindings []types.BoundContract)) *ContractReader_Bind_Call

+ func (_c *ContractReader_Bind_Call) RunAndReturn(run func(context.Context, []types.BoundContract) error) *ContractReader_Bind_Call

+ type ContractReader_Close_Call struct

+ func (_c *ContractReader_Close_Call) Return(_a0 error) *ContractReader_Close_Call

+ func (_c *ContractReader_Close_Call) Run(run func()) *ContractReader_Close_Call

+ func (_c *ContractReader_Close_Call) RunAndReturn(run func() error) *ContractReader_Close_Call

+ type ContractReader_Expecter struct

+ func (_e *ContractReader_Expecter) BatchGetLatestValues(ctx interface{}, request interface{}) *ContractReader_BatchGetLatestValues_Call

+ func (_e *ContractReader_Expecter) Bind(ctx interface{}, bindings interface{}) *ContractReader_Bind_Call

+ func (_e *ContractReader_Expecter) Close() *ContractReader_Close_Call

+ func (_e *ContractReader_Expecter) GetLatestValue(ctx interface{}, readIdentifier interface{}, confidenceLevel interface{}, ...) *ContractReader_GetLatestValue_Call

+ func (_e *ContractReader_Expecter) GetLatestValueWithHeadData(ctx interface{}, readIdentifier interface{}, confidenceLevel interface{}, ...) *ContractReader_GetLatestValueWithHeadData_Call

+ func (_e *ContractReader_Expecter) HealthReport() *ContractReader_HealthReport_Call

+ func (_e *ContractReader_Expecter) Name() *ContractReader_Name_Call

+ func (_e *ContractReader_Expecter) QueryKey(ctx interface{}, contract interface{}, filter interface{}, ...) *ContractReader_QueryKey_Call

+ func (_e *ContractReader_Expecter) QueryKeys(ctx interface{}, filters interface{}, limitAndSort interface{}) *ContractReader_QueryKeys_Call

+ func (_e *ContractReader_Expecter) Ready() *ContractReader_Ready_Call

+ func (_e *ContractReader_Expecter) Start(_a0 interface{}) *ContractReader_Start_Call

+ func (_e *ContractReader_Expecter) Unbind(ctx interface{}, bindings interface{}) *ContractReader_Unbind_Call

+ type ContractReader_GetLatestValueWithHeadData_Call struct

+ func (_c *ContractReader_GetLatestValueWithHeadData_Call) Return(_a0 *types.Head, _a1 error) *ContractReader_GetLatestValueWithHeadData_Call

+ func (_c *ContractReader_GetLatestValueWithHeadData_Call) Run(run func(ctx context.Context, readIdentifier string, ...)) *ContractReader_GetLatestValueWithHeadData_Call

+ func (_c *ContractReader_GetLatestValueWithHeadData_Call) RunAndReturn(...) *ContractReader_GetLatestValueWithHeadData_Call

+ type ContractReader_GetLatestValue_Call struct

+ func (_c *ContractReader_GetLatestValue_Call) Return(_a0 error) *ContractReader_GetLatestValue_Call

+ func (_c *ContractReader_GetLatestValue_Call) Run(run func(ctx context.Context, readIdentifier string, ...)) *ContractReader_GetLatestValue_Call

+ func (_c *ContractReader_GetLatestValue_Call) RunAndReturn(...) *ContractReader_GetLatestValue_Call

+ type ContractReader_HealthReport_Call struct

+ func (_c *ContractReader_HealthReport_Call) Return(_a0 map[string]error) *ContractReader_HealthReport_Call

+ func (_c *ContractReader_HealthReport_Call) Run(run func()) *ContractReader_HealthReport_Call

+ func (_c *ContractReader_HealthReport_Call) RunAndReturn(run func() map[string]error) *ContractReader_HealthReport_Call

+ type ContractReader_Name_Call struct

+ func (_c *ContractReader_Name_Call) Return(_a0 string) *ContractReader_Name_Call

+ func (_c *ContractReader_Name_Call) Run(run func()) *ContractReader_Name_Call

+ func (_c *ContractReader_Name_Call) RunAndReturn(run func() string) *ContractReader_Name_Call

+ type ContractReader_QueryKey_Call struct

+ func (_c *ContractReader_QueryKey_Call) Return(_a0 []types.Sequence, _a1 error) *ContractReader_QueryKey_Call

+ func (_c *ContractReader_QueryKey_Call) Run(...) *ContractReader_QueryKey_Call

+ func (_c *ContractReader_QueryKey_Call) RunAndReturn(...) *ContractReader_QueryKey_Call

+ type ContractReader_QueryKeys_Call struct

+ func (_c *ContractReader_QueryKeys_Call) Return(_a0 iter.Seq2[string, types.Sequence], _a1 error) *ContractReader_QueryKeys_Call

+ func (_c *ContractReader_QueryKeys_Call) Run(run func(ctx context.Context, filters []types.ContractKeyFilter, ...)) *ContractReader_QueryKeys_Call

+ func (_c *ContractReader_QueryKeys_Call) RunAndReturn(...) *ContractReader_QueryKeys_Call

+ type ContractReader_Ready_Call struct

+ func (_c *ContractReader_Ready_Call) Return(_a0 error) *ContractReader_Ready_Call

+ func (_c *ContractReader_Ready_Call) Run(run func()) *ContractReader_Ready_Call

+ func (_c *ContractReader_Ready_Call) RunAndReturn(run func() error) *ContractReader_Ready_Call

+ type ContractReader_Start_Call struct

+ func (_c *ContractReader_Start_Call) Return(_a0 error) *ContractReader_Start_Call

+ func (_c *ContractReader_Start_Call) Run(run func(_a0 context.Context)) *ContractReader_Start_Call

+ func (_c *ContractReader_Start_Call) RunAndReturn(run func(context.Context) error) *ContractReader_Start_Call

+ type ContractReader_Unbind_Call struct

+ func (_c *ContractReader_Unbind_Call) Return(_a0 error) *ContractReader_Unbind_Call

+ func (_c *ContractReader_Unbind_Call) Run(run func(ctx context.Context, bindings []types.BoundContract)) *ContractReader_Unbind_Call

+ func (_c *ContractReader_Unbind_Call) RunAndReturn(run func(context.Context, []types.BoundContract) error) *ContractReader_Unbind_Call

+ type ContractReader_mustEmbedUnimplementedContractReader_Call struct

+ func (_c *ContractReader_mustEmbedUnimplementedContractReader_Call) Return() *ContractReader_mustEmbedUnimplementedContractReader_Call

+ func (_c *ContractReader_mustEmbedUnimplementedContractReader_Call) Run(run func()) *ContractReader_mustEmbedUnimplementedContractReader_Call

+ func (_c *ContractReader_mustEmbedUnimplementedContractReader_Call) RunAndReturn(run func()) *ContractReader_mustEmbedUnimplementedContractReader_Call

+ type EVMService struct

+ func NewEVMService(t interface{ ... }) *EVMService

+ func (_m *EVMService) BalanceAt(ctx context.Context, account [20]byte, blockNumber *big.Int) (*big.Int, error)

+ func (_m *EVMService) CalculateTransactionFee(ctx context.Context, receiptGasInfo evm.ReceiptGasInfo) (*evm.TransactionFee, error)

+ func (_m *EVMService) CallContract(ctx context.Context, msg *evm.CallMsg, blockNumber *big.Int) ([]byte, error)

+ func (_m *EVMService) EXPECT() *EVMService_Expecter

+ func (_m *EVMService) EstimateGas(ctx context.Context, call *evm.CallMsg) (uint64, error)

+ func (_m *EVMService) FilterLogs(ctx context.Context, filterQuery evm.FilterQuery) ([]*evm.Log, error)

+ func (_m *EVMService) GetForwarderForEOA(ctx context.Context, eoa [20]byte, ocr2AggregatorID [20]byte, ...) ([20]byte, error)

+ func (_m *EVMService) GetTransactionByHash(ctx context.Context, hash [32]byte) (*evm.Transaction, error)

+ func (_m *EVMService) GetTransactionFee(ctx context.Context, transactionID string) (*evm.TransactionFee, error)

+ func (_m *EVMService) GetTransactionReceipt(ctx context.Context, txHash [32]byte) (*evm.Receipt, error)

+ func (_m *EVMService) GetTransactionStatus(ctx context.Context, transactionID string) (types.TransactionStatus, error)

+ func (_m *EVMService) LatestAndFinalizedHead(ctx context.Context) (evm.Head, evm.Head, error)

+ func (_m *EVMService) QueryTrackedLogs(ctx context.Context, filterQuery []query.Expression, ...) ([]*evm.Log, error)

+ func (_m *EVMService) RegisterLogTracking(ctx context.Context, filter evm.LPFilterQuery) error

+ func (_m *EVMService) SubmitTransaction(ctx context.Context, txRequest evm.SubmitTransactionRequest) (*evm.TransactionResult, error)

+ func (_m *EVMService) UnregisterLogTracking(ctx context.Context, filterName string) error

+ type EVMService_BalanceAt_Call struct

+ func (_c *EVMService_BalanceAt_Call) Return(_a0 *big.Int, _a1 error) *EVMService_BalanceAt_Call

+ func (_c *EVMService_BalanceAt_Call) Run(run func(ctx context.Context, account [20]byte, blockNumber *big.Int)) *EVMService_BalanceAt_Call

+ func (_c *EVMService_BalanceAt_Call) RunAndReturn(run func(context.Context, [20]byte, *big.Int) (*big.Int, error)) *EVMService_BalanceAt_Call

+ type EVMService_CalculateTransactionFee_Call struct

+ func (_c *EVMService_CalculateTransactionFee_Call) Return(_a0 *evm.TransactionFee, _a1 error) *EVMService_CalculateTransactionFee_Call

+ func (_c *EVMService_CalculateTransactionFee_Call) Run(run func(ctx context.Context, receiptGasInfo evm.ReceiptGasInfo)) *EVMService_CalculateTransactionFee_Call

+ func (_c *EVMService_CalculateTransactionFee_Call) RunAndReturn(run func(context.Context, evm.ReceiptGasInfo) (*evm.TransactionFee, error)) *EVMService_CalculateTransactionFee_Call

+ type EVMService_CallContract_Call struct

+ func (_c *EVMService_CallContract_Call) Return(_a0 []byte, _a1 error) *EVMService_CallContract_Call

+ func (_c *EVMService_CallContract_Call) Run(run func(ctx context.Context, msg *evm.CallMsg, blockNumber *big.Int)) *EVMService_CallContract_Call

+ func (_c *EVMService_CallContract_Call) RunAndReturn(run func(context.Context, *evm.CallMsg, *big.Int) ([]byte, error)) *EVMService_CallContract_Call

+ type EVMService_EstimateGas_Call struct

+ func (_c *EVMService_EstimateGas_Call) Return(_a0 uint64, _a1 error) *EVMService_EstimateGas_Call

+ func (_c *EVMService_EstimateGas_Call) Run(run func(ctx context.Context, call *evm.CallMsg)) *EVMService_EstimateGas_Call

+ func (_c *EVMService_EstimateGas_Call) RunAndReturn(run func(context.Context, *evm.CallMsg) (uint64, error)) *EVMService_EstimateGas_Call

+ type EVMService_Expecter struct

+ func (_e *EVMService_Expecter) BalanceAt(ctx interface{}, account interface{}, blockNumber interface{}) *EVMService_BalanceAt_Call

+ func (_e *EVMService_Expecter) CalculateTransactionFee(ctx interface{}, receiptGasInfo interface{}) *EVMService_CalculateTransactionFee_Call

+ func (_e *EVMService_Expecter) CallContract(ctx interface{}, msg interface{}, blockNumber interface{}) *EVMService_CallContract_Call

+ func (_e *EVMService_Expecter) EstimateGas(ctx interface{}, call interface{}) *EVMService_EstimateGas_Call

+ func (_e *EVMService_Expecter) FilterLogs(ctx interface{}, filterQuery interface{}) *EVMService_FilterLogs_Call

+ func (_e *EVMService_Expecter) GetForwarderForEOA(ctx interface{}, eoa interface{}, ocr2AggregatorID interface{}, ...) *EVMService_GetForwarderForEOA_Call

+ func (_e *EVMService_Expecter) GetTransactionByHash(ctx interface{}, hash interface{}) *EVMService_GetTransactionByHash_Call

+ func (_e *EVMService_Expecter) GetTransactionFee(ctx interface{}, transactionID interface{}) *EVMService_GetTransactionFee_Call

+ func (_e *EVMService_Expecter) GetTransactionReceipt(ctx interface{}, txHash interface{}) *EVMService_GetTransactionReceipt_Call

+ func (_e *EVMService_Expecter) GetTransactionStatus(ctx interface{}, transactionID interface{}) *EVMService_GetTransactionStatus_Call

+ func (_e *EVMService_Expecter) LatestAndFinalizedHead(ctx interface{}) *EVMService_LatestAndFinalizedHead_Call

+ func (_e *EVMService_Expecter) QueryTrackedLogs(ctx interface{}, filterQuery interface{}, limitAndSort interface{}, ...) *EVMService_QueryTrackedLogs_Call

+ func (_e *EVMService_Expecter) RegisterLogTracking(ctx interface{}, filter interface{}) *EVMService_RegisterLogTracking_Call

+ func (_e *EVMService_Expecter) SubmitTransaction(ctx interface{}, txRequest interface{}) *EVMService_SubmitTransaction_Call

+ func (_e *EVMService_Expecter) UnregisterLogTracking(ctx interface{}, filterName interface{}) *EVMService_UnregisterLogTracking_Call

+ type EVMService_FilterLogs_Call struct

+ func (_c *EVMService_FilterLogs_Call) Return(_a0 []*evm.Log, _a1 error) *EVMService_FilterLogs_Call

+ func (_c *EVMService_FilterLogs_Call) Run(run func(ctx context.Context, filterQuery evm.FilterQuery)) *EVMService_FilterLogs_Call

+ func (_c *EVMService_FilterLogs_Call) RunAndReturn(run func(context.Context, evm.FilterQuery) ([]*evm.Log, error)) *EVMService_FilterLogs_Call

+ type EVMService_GetForwarderForEOA_Call struct

+ func (_c *EVMService_GetForwarderForEOA_Call) Return(forwarder [20]byte, err error) *EVMService_GetForwarderForEOA_Call

+ func (_c *EVMService_GetForwarderForEOA_Call) Run(run func(ctx context.Context, eoa [20]byte, ocr2AggregatorID [20]byte, ...)) *EVMService_GetForwarderForEOA_Call

+ func (_c *EVMService_GetForwarderForEOA_Call) RunAndReturn(run func(context.Context, [20]byte, [20]byte, string) ([20]byte, error)) *EVMService_GetForwarderForEOA_Call

+ type EVMService_GetTransactionByHash_Call struct

+ func (_c *EVMService_GetTransactionByHash_Call) Return(_a0 *evm.Transaction, _a1 error) *EVMService_GetTransactionByHash_Call

+ func (_c *EVMService_GetTransactionByHash_Call) Run(run func(ctx context.Context, hash [32]byte)) *EVMService_GetTransactionByHash_Call

+ func (_c *EVMService_GetTransactionByHash_Call) RunAndReturn(run func(context.Context, [32]byte) (*evm.Transaction, error)) *EVMService_GetTransactionByHash_Call

+ type EVMService_GetTransactionFee_Call struct

+ func (_c *EVMService_GetTransactionFee_Call) Return(_a0 *evm.TransactionFee, _a1 error) *EVMService_GetTransactionFee_Call

+ func (_c *EVMService_GetTransactionFee_Call) Run(run func(ctx context.Context, transactionID string)) *EVMService_GetTransactionFee_Call

+ func (_c *EVMService_GetTransactionFee_Call) RunAndReturn(run func(context.Context, string) (*evm.TransactionFee, error)) *EVMService_GetTransactionFee_Call

+ type EVMService_GetTransactionReceipt_Call struct

+ func (_c *EVMService_GetTransactionReceipt_Call) Return(_a0 *evm.Receipt, _a1 error) *EVMService_GetTransactionReceipt_Call

+ func (_c *EVMService_GetTransactionReceipt_Call) Run(run func(ctx context.Context, txHash [32]byte)) *EVMService_GetTransactionReceipt_Call

+ func (_c *EVMService_GetTransactionReceipt_Call) RunAndReturn(run func(context.Context, [32]byte) (*evm.Receipt, error)) *EVMService_GetTransactionReceipt_Call

+ type EVMService_GetTransactionStatus_Call struct

+ func (_c *EVMService_GetTransactionStatus_Call) Return(_a0 types.TransactionStatus, _a1 error) *EVMService_GetTransactionStatus_Call

+ func (_c *EVMService_GetTransactionStatus_Call) Run(run func(ctx context.Context, transactionID string)) *EVMService_GetTransactionStatus_Call

+ func (_c *EVMService_GetTransactionStatus_Call) RunAndReturn(run func(context.Context, string) (types.TransactionStatus, error)) *EVMService_GetTransactionStatus_Call

+ type EVMService_LatestAndFinalizedHead_Call struct

+ func (_c *EVMService_LatestAndFinalizedHead_Call) Return(latest evm.Head, finalized evm.Head, err error) *EVMService_LatestAndFinalizedHead_Call

+ func (_c *EVMService_LatestAndFinalizedHead_Call) Run(run func(ctx context.Context)) *EVMService_LatestAndFinalizedHead_Call

+ func (_c *EVMService_LatestAndFinalizedHead_Call) RunAndReturn(run func(context.Context) (evm.Head, evm.Head, error)) *EVMService_LatestAndFinalizedHead_Call

+ type EVMService_QueryTrackedLogs_Call struct

+ func (_c *EVMService_QueryTrackedLogs_Call) Return(_a0 []*evm.Log, _a1 error) *EVMService_QueryTrackedLogs_Call

+ func (_c *EVMService_QueryTrackedLogs_Call) Run(run func(ctx context.Context, filterQuery []query.Expression, ...)) *EVMService_QueryTrackedLogs_Call

+ func (_c *EVMService_QueryTrackedLogs_Call) RunAndReturn(...) *EVMService_QueryTrackedLogs_Call

+ type EVMService_RegisterLogTracking_Call struct

+ func (_c *EVMService_RegisterLogTracking_Call) Return(_a0 error) *EVMService_RegisterLogTracking_Call

+ func (_c *EVMService_RegisterLogTracking_Call) Run(run func(ctx context.Context, filter evm.LPFilterQuery)) *EVMService_RegisterLogTracking_Call

+ func (_c *EVMService_RegisterLogTracking_Call) RunAndReturn(run func(context.Context, evm.LPFilterQuery) error) *EVMService_RegisterLogTracking_Call

+ type EVMService_SubmitTransaction_Call struct

+ func (_c *EVMService_SubmitTransaction_Call) Return(_a0 *evm.TransactionResult, _a1 error) *EVMService_SubmitTransaction_Call

+ func (_c *EVMService_SubmitTransaction_Call) Run(run func(ctx context.Context, txRequest evm.SubmitTransactionRequest)) *EVMService_SubmitTransaction_Call

+ func (_c *EVMService_SubmitTransaction_Call) RunAndReturn(...) *EVMService_SubmitTransaction_Call

+ type EVMService_UnregisterLogTracking_Call struct

+ func (_c *EVMService_UnregisterLogTracking_Call) Return(_a0 error) *EVMService_UnregisterLogTracking_Call

+ func (_c *EVMService_UnregisterLogTracking_Call) Run(run func(ctx context.Context, filterName string)) *EVMService_UnregisterLogTracking_Call

+ func (_c *EVMService_UnregisterLogTracking_Call) RunAndReturn(run func(context.Context, string) error) *EVMService_UnregisterLogTracking_Call

v0.7.1-ccip

Aug 7, 2025

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