mocks

package

Go to main page

Versions in this module

v0

v0.0.10

Sep 13, 2024

v0.0.9

Aug 19, 2024

v0.0.8

Jul 22, 2024

Changes in this version

type Client

+ func (_m *Client) GetStatus(ctx context.Context) (*types.DACStatus, error)

+ func (_m *Client) SignSequenceBanana(ctx context.Context, signedSequence types.SignedSequenceBanana) ([]byte, error)

type Client_Expecter

+ func (_e *Client_Expecter) GetStatus(ctx interface{}) *Client_GetStatus_Call

+ func (_e *Client_Expecter) SignSequenceBanana(ctx interface{}, signedSequence interface{}) *Client_SignSequenceBanana_Call

+ type Client_GetStatus_Call struct

+ func (_c *Client_GetStatus_Call) Return(_a0 *types.DACStatus, _a1 error) *Client_GetStatus_Call

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

+ func (_c *Client_GetStatus_Call) RunAndReturn(run func(context.Context) (*types.DACStatus, error)) *Client_GetStatus_Call

+ type Client_SignSequenceBanana_Call struct

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

+ func (_c *Client_SignSequenceBanana_Call) Run(run func(ctx context.Context, signedSequence types.SignedSequenceBanana)) *Client_SignSequenceBanana_Call

+ func (_c *Client_SignSequenceBanana_Call) RunAndReturn(run func(context.Context, types.SignedSequenceBanana) ([]byte, error)) *Client_SignSequenceBanana_Call

type DB

+ func (_m *DB) CountOffchainData(ctx context.Context) (uint64, error)

+ func (_m *DB) DetectOffchainDataGaps(ctx context.Context) (map[uint64]uint64, error)

+ type DB_CountOffchainData_Call struct

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

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

+ func (_c *DB_CountOffchainData_Call) RunAndReturn(run func(context.Context) (uint64, error)) *DB_CountOffchainData_Call

+ type DB_DetectOffchainDataGaps_Call struct

+ func (_c *DB_DetectOffchainDataGaps_Call) Return(_a0 map[uint64]uint64, _a1 error) *DB_DetectOffchainDataGaps_Call

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

+ func (_c *DB_DetectOffchainDataGaps_Call) RunAndReturn(run func(context.Context) (map[uint64]uint64, error)) *DB_DetectOffchainDataGaps_Call

type DB_Expecter

+ func (_e *DB_Expecter) CountOffchainData(ctx interface{}) *DB_CountOffchainData_Call

+ func (_e *DB_Expecter) DetectOffchainDataGaps(ctx interface{}) *DB_DetectOffchainDataGaps_Call

type Etherman

+ func (_m *Etherman) BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error)

+ func (_m *Etherman) CodeAt(ctx context.Context, account common.Address, blockNumber *big.Int) ([]byte, error)

+ type Etherman_BlockByNumber_Call struct

+ func (_c *Etherman_BlockByNumber_Call) Return(_a0 *types.Block, _a1 error) *Etherman_BlockByNumber_Call

+ func (_c *Etherman_BlockByNumber_Call) Run(run func(ctx context.Context, number *big.Int)) *Etherman_BlockByNumber_Call

+ func (_c *Etherman_BlockByNumber_Call) RunAndReturn(run func(context.Context, *big.Int) (*types.Block, error)) *Etherman_BlockByNumber_Call

+ type Etherman_CodeAt_Call struct

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

+ func (_c *Etherman_CodeAt_Call) Run(run func(ctx context.Context, account common.Address, blockNumber *big.Int)) *Etherman_CodeAt_Call

+ func (_c *Etherman_CodeAt_Call) RunAndReturn(run func(context.Context, common.Address, *big.Int) ([]byte, error)) *Etherman_CodeAt_Call

type Etherman_Expecter

+ func (_e *Etherman_Expecter) BlockByNumber(ctx interface{}, number interface{}) *Etherman_BlockByNumber_Call

+ func (_e *Etherman_Expecter) CodeAt(ctx interface{}, account interface{}, blockNumber interface{}) *Etherman_CodeAt_Call

+ type GapsDetector struct

+ func NewGapsDetector(t interface{ ... }) *GapsDetector

+ func (_m *GapsDetector) EXPECT() *GapsDetector_Expecter

+ func (_m *GapsDetector) Gaps() map[uint64]uint64

+ type GapsDetector_Expecter struct

+ func (_e *GapsDetector_Expecter) Gaps() *GapsDetector_Gaps_Call

+ type GapsDetector_Gaps_Call struct

+ func (_c *GapsDetector_Gaps_Call) Return(_a0 map[uint64]uint64) *GapsDetector_Gaps_Call

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

+ func (_c *GapsDetector_Gaps_Call) RunAndReturn(run func() map[uint64]uint64) *GapsDetector_Gaps_Call

v0.0.7

Mar 26, 2024

Changes in this version

type Client

+ func (_m *Client) ListOffChainData(ctx context.Context, hashes []common.Hash) (map[common.Hash][]byte, error)

type Client_Expecter

+ func (_e *Client_Expecter) ListOffChainData(ctx interface{}, hashes interface{}) *Client_ListOffChainData_Call

+ type Client_ListOffChainData_Call struct

+ func (_c *Client_ListOffChainData_Call) Return(_a0 map[common.Hash][]byte, _a1 error) *Client_ListOffChainData_Call

+ func (_c *Client_ListOffChainData_Call) Run(run func(ctx context.Context, hashes []common.Hash)) *Client_ListOffChainData_Call

+ func (_c *Client_ListOffChainData_Call) RunAndReturn(run func(context.Context, []common.Hash) (map[common.Hash][]byte, error)) *Client_ListOffChainData_Call

type DB

+ func (_m *DB) ListOffChainData(ctx context.Context, keys []common.Hash, dbTx sqlx.QueryerContext) (map[common.Hash]types.ArgBytes, error)

type DB_Expecter

+ func (_e *DB_Expecter) ListOffChainData(ctx interface{}, keys interface{}, dbTx interface{}) *DB_ListOffChainData_Call

+ type DB_ListOffChainData_Call struct

+ func (_c *DB_ListOffChainData_Call) Return(_a0 map[common.Hash]types.ArgBytes, _a1 error) *DB_ListOffChainData_Call

+ func (_c *DB_ListOffChainData_Call) Run(run func(ctx context.Context, keys []common.Hash, dbTx sqlx.QueryerContext)) *DB_ListOffChainData_Call

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

v0.0.6

Mar 11, 2024

Changes in this version

type DB

+ func (_m *DB) DeleteUnresolvedBatchKeys(ctx context.Context, bks []types.BatchKey, dbTx sqlx.ExecerContext) error

+ func (_m *DB) GetUnresolvedBatchKeys(ctx context.Context) ([]types.BatchKey, error)

+ func (_m *DB) StoreUnresolvedBatchKeys(ctx context.Context, bks []types.BatchKey, dbTx sqlx.ExecerContext) error

+ type DB_DeleteUnresolvedBatchKeys_Call struct

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

+ func (_c *DB_DeleteUnresolvedBatchKeys_Call) Run(run func(ctx context.Context, bks []types.BatchKey, dbTx sqlx.ExecerContext)) *DB_DeleteUnresolvedBatchKeys_Call

+ func (_c *DB_DeleteUnresolvedBatchKeys_Call) RunAndReturn(run func(context.Context, []types.BatchKey, sqlx.ExecerContext) error) *DB_DeleteUnresolvedBatchKeys_Call

type DB_Expecter

+ func (_e *DB_Expecter) DeleteUnresolvedBatchKeys(ctx interface{}, bks interface{}, dbTx interface{}) *DB_DeleteUnresolvedBatchKeys_Call

+ func (_e *DB_Expecter) GetUnresolvedBatchKeys(ctx interface{}) *DB_GetUnresolvedBatchKeys_Call

+ func (_e *DB_Expecter) StoreUnresolvedBatchKeys(ctx interface{}, bks interface{}, dbTx interface{}) *DB_StoreUnresolvedBatchKeys_Call

+ type DB_GetUnresolvedBatchKeys_Call struct

+ func (_c *DB_GetUnresolvedBatchKeys_Call) Return(_a0 []types.BatchKey, _a1 error) *DB_GetUnresolvedBatchKeys_Call

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

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

+ type DB_StoreUnresolvedBatchKeys_Call struct

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

+ func (_c *DB_StoreUnresolvedBatchKeys_Call) Run(run func(ctx context.Context, bks []types.BatchKey, dbTx sqlx.ExecerContext)) *DB_StoreUnresolvedBatchKeys_Call

+ func (_c *DB_StoreUnresolvedBatchKeys_Call) RunAndReturn(run func(context.Context, []types.BatchKey, sqlx.ExecerContext) error) *DB_StoreUnresolvedBatchKeys_Call

v0.0.6-hotfix1

Apr 17, 2024

v0.0.5

Feb 6, 2024

v0.0.4

Jan 31, 2024

Changes in this version

+ type Client struct

+ func NewClient(t interface{ ... }) *Client

+ func (_m *Client) EXPECT() *Client_Expecter

+ func (_m *Client) GetOffChainData(ctx context.Context, hash common.Hash) ([]byte, error)

+ func (_m *Client) SignSequence(signedSequence types.SignedSequence) ([]byte, error)

+ type ClientFactory struct

+ func NewClientFactory(t interface{ ... }) *ClientFactory

+ func (_m *ClientFactory) EXPECT() *ClientFactory_Expecter

+ func (_m *ClientFactory) New(url string) client.Client

+ type ClientFactory_Expecter struct

+ func (_e *ClientFactory_Expecter) New(url interface{}) *ClientFactory_New_Call

+ type ClientFactory_New_Call struct

+ func (_c *ClientFactory_New_Call) Return(_a0 client.Client) *ClientFactory_New_Call

+ func (_c *ClientFactory_New_Call) Run(run func(url string)) *ClientFactory_New_Call

+ func (_c *ClientFactory_New_Call) RunAndReturn(run func(string) client.Client) *ClientFactory_New_Call

+ type Client_Expecter struct

+ func (_e *Client_Expecter) GetOffChainData(ctx interface{}, hash interface{}) *Client_GetOffChainData_Call

+ func (_e *Client_Expecter) SignSequence(signedSequence interface{}) *Client_SignSequence_Call

+ type Client_GetOffChainData_Call struct

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

+ func (_c *Client_GetOffChainData_Call) Run(run func(ctx context.Context, hash common.Hash)) *Client_GetOffChainData_Call

+ func (_c *Client_GetOffChainData_Call) RunAndReturn(run func(context.Context, common.Hash) ([]byte, error)) *Client_GetOffChainData_Call

+ type Client_SignSequence_Call struct

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

+ func (_c *Client_SignSequence_Call) Run(run func(signedSequence types.SignedSequence)) *Client_SignSequence_Call

+ func (_c *Client_SignSequence_Call) RunAndReturn(run func(types.SignedSequence) ([]byte, error)) *Client_SignSequence_Call

+ type DB struct

+ func NewDB(t interface{ ... }) *DB

+ func (_m *DB) BeginStateTransaction(ctx context.Context) (db.Tx, error)

+ func (_m *DB) EXPECT() *DB_Expecter

+ func (_m *DB) Exists(ctx context.Context, key common.Hash) bool

+ func (_m *DB) GetLastProcessedBlock(ctx context.Context, task string) (uint64, error)

+ func (_m *DB) GetOffChainData(ctx context.Context, key common.Hash, dbTx sqlx.QueryerContext) (types.ArgBytes, error)

+ func (_m *DB) StoreLastProcessedBlock(ctx context.Context, task string, block uint64, dbTx sqlx.ExecerContext) error

+ func (_m *DB) StoreOffChainData(ctx context.Context, od []types.OffChainData, dbTx sqlx.ExecerContext) error

+ type DB_BeginStateTransaction_Call struct

+ func (_c *DB_BeginStateTransaction_Call) Return(_a0 db.Tx, _a1 error) *DB_BeginStateTransaction_Call

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

+ func (_c *DB_BeginStateTransaction_Call) RunAndReturn(run func(context.Context) (db.Tx, error)) *DB_BeginStateTransaction_Call

+ type DB_Exists_Call struct

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

+ func (_c *DB_Exists_Call) Run(run func(ctx context.Context, key common.Hash)) *DB_Exists_Call

+ func (_c *DB_Exists_Call) RunAndReturn(run func(context.Context, common.Hash) bool) *DB_Exists_Call

+ type DB_Expecter struct

+ func (_e *DB_Expecter) BeginStateTransaction(ctx interface{}) *DB_BeginStateTransaction_Call

+ func (_e *DB_Expecter) Exists(ctx interface{}, key interface{}) *DB_Exists_Call

+ func (_e *DB_Expecter) GetLastProcessedBlock(ctx interface{}, task interface{}) *DB_GetLastProcessedBlock_Call

+ func (_e *DB_Expecter) GetOffChainData(ctx interface{}, key interface{}, dbTx interface{}) *DB_GetOffChainData_Call

+ func (_e *DB_Expecter) StoreLastProcessedBlock(ctx interface{}, task interface{}, block interface{}, dbTx interface{}) *DB_StoreLastProcessedBlock_Call

+ func (_e *DB_Expecter) StoreOffChainData(ctx interface{}, od interface{}, dbTx interface{}) *DB_StoreOffChainData_Call

+ type DB_GetLastProcessedBlock_Call struct

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

+ func (_c *DB_GetLastProcessedBlock_Call) Run(run func(ctx context.Context, task string)) *DB_GetLastProcessedBlock_Call

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

+ type DB_GetOffChainData_Call struct

+ func (_c *DB_GetOffChainData_Call) Return(_a0 types.ArgBytes, _a1 error) *DB_GetOffChainData_Call

+ func (_c *DB_GetOffChainData_Call) Run(run func(ctx context.Context, key common.Hash, dbTx sqlx.QueryerContext)) *DB_GetOffChainData_Call

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

+ type DB_StoreLastProcessedBlock_Call struct

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

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

+ func (_c *DB_StoreLastProcessedBlock_Call) RunAndReturn(run func(context.Context, string, uint64, sqlx.ExecerContext) error) *DB_StoreLastProcessedBlock_Call

+ type DB_StoreOffChainData_Call struct

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

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

+ func (_c *DB_StoreOffChainData_Call) RunAndReturn(run func(context.Context, []types.OffChainData, sqlx.ExecerContext) error) *DB_StoreOffChainData_Call

+ type EthClient struct

+ func NewEthClient(t interface{ ... }) *EthClient

+ func (_m *EthClient) BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error)

+ func (_m *EthClient) CodeAt(ctx context.Context, account common.Address, blockNumber *big.Int) ([]byte, error)

+ func (_m *EthClient) EXPECT() *EthClient_Expecter

+ type EthClientFactory struct

+ func NewEthClientFactory(t interface{ ... }) *EthClientFactory

+ func (_m *EthClientFactory) CreateEthClient(ctx context.Context, url string) (types.EthClient, error)

+ func (_m *EthClientFactory) EXPECT() *EthClientFactory_Expecter

+ type EthClientFactory_CreateEthClient_Call struct

+ func (_c *EthClientFactory_CreateEthClient_Call) Return(_a0 types.EthClient, _a1 error) *EthClientFactory_CreateEthClient_Call

+ func (_c *EthClientFactory_CreateEthClient_Call) Run(run func(ctx context.Context, url string)) *EthClientFactory_CreateEthClient_Call

+ func (_c *EthClientFactory_CreateEthClient_Call) RunAndReturn(run func(context.Context, string) (types.EthClient, error)) *EthClientFactory_CreateEthClient_Call

+ type EthClientFactory_Expecter struct

+ func (_e *EthClientFactory_Expecter) CreateEthClient(ctx interface{}, url interface{}) *EthClientFactory_CreateEthClient_Call

+ type EthClient_BlockByNumber_Call struct

+ func (_c *EthClient_BlockByNumber_Call) Return(_a0 *types.Block, _a1 error) *EthClient_BlockByNumber_Call

+ func (_c *EthClient_BlockByNumber_Call) Run(run func(ctx context.Context, number *big.Int)) *EthClient_BlockByNumber_Call

+ func (_c *EthClient_BlockByNumber_Call) RunAndReturn(run func(context.Context, *big.Int) (*types.Block, error)) *EthClient_BlockByNumber_Call

+ type EthClient_CodeAt_Call struct

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

+ func (_c *EthClient_CodeAt_Call) Run(run func(ctx context.Context, account common.Address, blockNumber *big.Int)) *EthClient_CodeAt_Call

+ func (_c *EthClient_CodeAt_Call) RunAndReturn(run func(context.Context, common.Address, *big.Int) ([]byte, error)) *EthClient_CodeAt_Call

+ type EthClient_Expecter struct

+ func (_e *EthClient_Expecter) BlockByNumber(ctx interface{}, number interface{}) *EthClient_BlockByNumber_Call

+ func (_e *EthClient_Expecter) CodeAt(ctx interface{}, account interface{}, blockNumber interface{}) *EthClient_CodeAt_Call

+ type Etherman struct

+ func NewEtherman(t interface{ ... }) *Etherman

+ func (_m *Etherman) EXPECT() *Etherman_Expecter

+ func (_m *Etherman) FilterSequenceBatches(opts *bind.FilterOpts, numBatch []uint64) (*polygonvalidium.PolygonvalidiumSequenceBatchesIterator, error)

+ func (_m *Etherman) GetCurrentDataCommittee() (*etherman.DataCommittee, error)

+ func (_m *Etherman) GetCurrentDataCommitteeMembers() ([]etherman.DataCommitteeMember, error)

+ func (_m *Etherman) GetTx(ctx context.Context, txHash common.Hash) (*types.Transaction, bool, error)

+ func (_m *Etherman) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error)

+ func (_m *Etherman) TrustedSequencer() (common.Address, error)

+ func (_m *Etherman) TrustedSequencerURL() (string, error)

+ func (_m *Etherman) WatchSetTrustedSequencer(ctx context.Context, ...) (event.Subscription, error)

+ func (_m *Etherman) WatchSetTrustedSequencerURL(ctx context.Context, ...) (event.Subscription, error)

+ type Etherman_Expecter struct

+ func (_e *Etherman_Expecter) FilterSequenceBatches(opts interface{}, numBatch interface{}) *Etherman_FilterSequenceBatches_Call

+ func (_e *Etherman_Expecter) GetCurrentDataCommittee() *Etherman_GetCurrentDataCommittee_Call

+ func (_e *Etherman_Expecter) GetCurrentDataCommitteeMembers() *Etherman_GetCurrentDataCommitteeMembers_Call

+ func (_e *Etherman_Expecter) GetTx(ctx interface{}, txHash interface{}) *Etherman_GetTx_Call

+ func (_e *Etherman_Expecter) HeaderByNumber(ctx interface{}, number interface{}) *Etherman_HeaderByNumber_Call

+ func (_e *Etherman_Expecter) TrustedSequencer() *Etherman_TrustedSequencer_Call

+ func (_e *Etherman_Expecter) TrustedSequencerURL() *Etherman_TrustedSequencerURL_Call

+ func (_e *Etherman_Expecter) WatchSetTrustedSequencer(ctx interface{}, events interface{}) *Etherman_WatchSetTrustedSequencer_Call

+ func (_e *Etherman_Expecter) WatchSetTrustedSequencerURL(ctx interface{}, events interface{}) *Etherman_WatchSetTrustedSequencerURL_Call

+ type Etherman_FilterSequenceBatches_Call struct

+ func (_c *Etherman_FilterSequenceBatches_Call) Return(_a0 *polygonvalidium.PolygonvalidiumSequenceBatchesIterator, _a1 error) *Etherman_FilterSequenceBatches_Call

+ func (_c *Etherman_FilterSequenceBatches_Call) Run(run func(opts *bind.FilterOpts, numBatch []uint64)) *Etherman_FilterSequenceBatches_Call

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

+ type Etherman_GetCurrentDataCommitteeMembers_Call struct

+ func (_c *Etherman_GetCurrentDataCommitteeMembers_Call) Return(_a0 []etherman.DataCommitteeMember, _a1 error) *Etherman_GetCurrentDataCommitteeMembers_Call

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

+ func (_c *Etherman_GetCurrentDataCommitteeMembers_Call) RunAndReturn(run func() ([]etherman.DataCommitteeMember, error)) *Etherman_GetCurrentDataCommitteeMembers_Call

+ type Etherman_GetCurrentDataCommittee_Call struct

+ func (_c *Etherman_GetCurrentDataCommittee_Call) Return(_a0 *etherman.DataCommittee, _a1 error) *Etherman_GetCurrentDataCommittee_Call

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

+ func (_c *Etherman_GetCurrentDataCommittee_Call) RunAndReturn(run func() (*etherman.DataCommittee, error)) *Etherman_GetCurrentDataCommittee_Call

+ type Etherman_GetTx_Call struct

+ func (_c *Etherman_GetTx_Call) Return(_a0 *types.Transaction, _a1 bool, _a2 error) *Etherman_GetTx_Call

+ func (_c *Etherman_GetTx_Call) Run(run func(ctx context.Context, txHash common.Hash)) *Etherman_GetTx_Call

+ func (_c *Etherman_GetTx_Call) RunAndReturn(run func(context.Context, common.Hash) (*types.Transaction, bool, error)) *Etherman_GetTx_Call

+ type Etherman_HeaderByNumber_Call struct

+ func (_c *Etherman_HeaderByNumber_Call) Return(_a0 *types.Header, _a1 error) *Etherman_HeaderByNumber_Call

+ func (_c *Etherman_HeaderByNumber_Call) Run(run func(ctx context.Context, number *big.Int)) *Etherman_HeaderByNumber_Call

+ func (_c *Etherman_HeaderByNumber_Call) RunAndReturn(run func(context.Context, *big.Int) (*types.Header, error)) *Etherman_HeaderByNumber_Call

+ type Etherman_TrustedSequencerURL_Call struct

+ func (_c *Etherman_TrustedSequencerURL_Call) Return(_a0 string, _a1 error) *Etherman_TrustedSequencerURL_Call

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

+ func (_c *Etherman_TrustedSequencerURL_Call) RunAndReturn(run func() (string, error)) *Etherman_TrustedSequencerURL_Call

+ type Etherman_TrustedSequencer_Call struct

+ func (_c *Etherman_TrustedSequencer_Call) Return(_a0 common.Address, _a1 error) *Etherman_TrustedSequencer_Call

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

+ func (_c *Etherman_TrustedSequencer_Call) RunAndReturn(run func() (common.Address, error)) *Etherman_TrustedSequencer_Call

+ type Etherman_WatchSetTrustedSequencerURL_Call struct

+ func (_c *Etherman_WatchSetTrustedSequencerURL_Call) Return(_a0 event.Subscription, _a1 error) *Etherman_WatchSetTrustedSequencerURL_Call

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

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

+ type Etherman_WatchSetTrustedSequencer_Call struct

+ func (_c *Etherman_WatchSetTrustedSequencer_Call) Return(_a0 event.Subscription, _a1 error) *Etherman_WatchSetTrustedSequencer_Call

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

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

+ type SequencerTracker struct

+ func NewSequencerTracker(t interface{ ... }) *SequencerTracker

+ func (_m *SequencerTracker) EXPECT() *SequencerTracker_Expecter

+ func (_m *SequencerTracker) GetSequenceBatch(batchNum uint64) (*sequencer.SeqBatch, error)

+ type SequencerTracker_Expecter struct

+ func (_e *SequencerTracker_Expecter) GetSequenceBatch(batchNum interface{}) *SequencerTracker_GetSequenceBatch_Call

+ type SequencerTracker_GetSequenceBatch_Call struct

+ func (_c *SequencerTracker_GetSequenceBatch_Call) Return(_a0 *sequencer.SeqBatch, _a1 error) *SequencerTracker_GetSequenceBatch_Call

+ func (_c *SequencerTracker_GetSequenceBatch_Call) Run(run func(batchNum uint64)) *SequencerTracker_GetSequenceBatch_Call

+ func (_c *SequencerTracker_GetSequenceBatch_Call) RunAndReturn(run func(uint64) (*sequencer.SeqBatch, error)) *SequencerTracker_GetSequenceBatch_Call

+ type Subscription struct

+ func NewSubscription(t interface{ ... }) *Subscription

+ func (_m *Subscription) EXPECT() *Subscription_Expecter

+ func (_m *Subscription) Err() <-chan error

+ func (_m *Subscription) Unsubscribe()

+ type Subscription_Err_Call struct

+ func (_c *Subscription_Err_Call) Return(_a0 <-chan error) *Subscription_Err_Call

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

+ func (_c *Subscription_Err_Call) RunAndReturn(run func() <-chan error) *Subscription_Err_Call

+ type Subscription_Expecter struct

+ func (_e *Subscription_Expecter) Err() *Subscription_Err_Call

+ func (_e *Subscription_Expecter) Unsubscribe() *Subscription_Unsubscribe_Call

+ type Subscription_Unsubscribe_Call struct

+ func (_c *Subscription_Unsubscribe_Call) Return() *Subscription_Unsubscribe_Call

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

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

+ type Tx struct

+ func NewTx(t interface{ ... }) *Tx

+ func (_m *Tx) Commit() error

+ func (_m *Tx) EXPECT() *Tx_Expecter

+ func (_m *Tx) ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error)

+ func (_m *Tx) QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)

+ func (_m *Tx) QueryRowxContext(ctx context.Context, query string, args ...interface{}) *sqlx.Row

+ func (_m *Tx) QueryxContext(ctx context.Context, query string, args ...interface{}) (*sqlx.Rows, error)

+ func (_m *Tx) Rollback() error

+ type Tx_Commit_Call struct

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

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

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

+ type Tx_ExecContext_Call struct

+ func (_c *Tx_ExecContext_Call) Return(_a0 sql.Result, _a1 error) *Tx_ExecContext_Call

+ func (_c *Tx_ExecContext_Call) Run(run func(ctx context.Context, query string, args ...interface{})) *Tx_ExecContext_Call

+ func (_c *Tx_ExecContext_Call) RunAndReturn(run func(context.Context, string, ...interface{}) (sql.Result, error)) *Tx_ExecContext_Call

+ type Tx_Expecter struct

+ func (_e *Tx_Expecter) Commit() *Tx_Commit_Call

+ func (_e *Tx_Expecter) ExecContext(ctx interface{}, query interface{}, args ...interface{}) *Tx_ExecContext_Call

+ func (_e *Tx_Expecter) QueryContext(ctx interface{}, query interface{}, args ...interface{}) *Tx_QueryContext_Call

+ func (_e *Tx_Expecter) QueryRowxContext(ctx interface{}, query interface{}, args ...interface{}) *Tx_QueryRowxContext_Call

+ func (_e *Tx_Expecter) QueryxContext(ctx interface{}, query interface{}, args ...interface{}) *Tx_QueryxContext_Call

+ func (_e *Tx_Expecter) Rollback() *Tx_Rollback_Call

+ type Tx_QueryContext_Call struct

+ func (_c *Tx_QueryContext_Call) Return(_a0 *sql.Rows, _a1 error) *Tx_QueryContext_Call

+ func (_c *Tx_QueryContext_Call) Run(run func(ctx context.Context, query string, args ...interface{})) *Tx_QueryContext_Call

+ func (_c *Tx_QueryContext_Call) RunAndReturn(run func(context.Context, string, ...interface{}) (*sql.Rows, error)) *Tx_QueryContext_Call

+ type Tx_QueryRowxContext_Call struct

+ func (_c *Tx_QueryRowxContext_Call) Return(_a0 *sqlx.Row) *Tx_QueryRowxContext_Call

+ func (_c *Tx_QueryRowxContext_Call) Run(run func(ctx context.Context, query string, args ...interface{})) *Tx_QueryRowxContext_Call

+ func (_c *Tx_QueryRowxContext_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *sqlx.Row) *Tx_QueryRowxContext_Call

+ type Tx_QueryxContext_Call struct

+ func (_c *Tx_QueryxContext_Call) Return(_a0 *sqlx.Rows, _a1 error) *Tx_QueryxContext_Call

+ func (_c *Tx_QueryxContext_Call) Run(run func(ctx context.Context, query string, args ...interface{})) *Tx_QueryxContext_Call

+ func (_c *Tx_QueryxContext_Call) RunAndReturn(run func(context.Context, string, ...interface{}) (*sqlx.Rows, error)) *Tx_QueryxContext_Call

+ type Tx_Rollback_Call struct

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

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

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

v0.0.1-test

Feb 19, 2024

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