mock

Documentation

Overview

Code generated by MockGen. DO NOT EDIT. Source: address.go

Generated by this command:

mockgen -source=address.go -destination=mock/address.go -package=mock -typed

Package mock is a generated GoMock package.

Code generated by MockGen. DO NOT EDIT. Source: block.go

Generated by this command:

mockgen -source=block.go -destination=mock/block.go -package=mock -typed

Package mock is a generated GoMock package.

Code generated by MockGen. DO NOT EDIT. Source: class.go

Generated by this command:

mockgen -source=class.go -destination=mock/class.go -package=mock -typed

Package mock is a generated GoMock package.

Code generated by MockGen. DO NOT EDIT. Source: class_replace.go

Generated by this command:

mockgen -source=class_replace.go -destination=mock/class_replace.go -package=mock -typed

Package mock is a generated GoMock package.

Code generated by MockGen. DO NOT EDIT. Source: declare.go

Generated by this command:

mockgen -source=declare.go -destination=mock/declare.go -package=mock -typed

Package mock is a generated GoMock package.

Code generated by MockGen. DO NOT EDIT. Source: deploy.go

Generated by this command:

mockgen -source=deploy.go -destination=mock/deploy.go -package=mock -typed

Package mock is a generated GoMock package.

Code generated by MockGen. DO NOT EDIT. Source: deploy_account.go

Generated by this command:

mockgen -source=deploy_account.go -destination=mock/deploy_account.go -package=mock -typed

Package mock is a generated GoMock package.

Code generated by MockGen. DO NOT EDIT. Source: event.go

Generated by this command:

mockgen -source=event.go -destination=mock/event.go -package=mock -typed

Package mock is a generated GoMock package.

Code generated by MockGen. DO NOT EDIT. Source: fee.go

Generated by this command:

mockgen -source=fee.go -destination=mock/fee.go -package=mock -typed

Package mock is a generated GoMock package.

Code generated by MockGen. DO NOT EDIT. Source: internal.go

Generated by this command:

mockgen -source=internal.go -destination=mock/internal.go -package=mock -typed

Package mock is a generated GoMock package.

Code generated by MockGen. DO NOT EDIT. Source: invoke.go

Generated by this command:

mockgen -source=invoke.go -destination=mock/invoke.go -package=mock -typed

Package mock is a generated GoMock package.

Code generated by MockGen. DO NOT EDIT. Source: l1_handler.go

Generated by this command:

mockgen -source=l1_handler.go -destination=mock/l1_handler.go -package=mock -typed

Package mock is a generated GoMock package.

Code generated by MockGen. DO NOT EDIT. Source: message.go

Generated by this command:

mockgen -source=message.go -destination=mock/message.go -package=mock -typed

Package mock is a generated GoMock package.

Code generated by MockGen. DO NOT EDIT. Source: proxy.go

Generated by this command:

mockgen -source=proxy.go -destination=mock/proxy.go -package=mock -typed

Package mock is a generated GoMock package.

Code generated by MockGen. DO NOT EDIT. Source: proxy_upgrade.go

Generated by this command:

mockgen -source=proxy_upgrade.go -destination=mock/proxy_upgrade.go -package=mock -typed

Package mock is a generated GoMock package.

Code generated by MockGen. DO NOT EDIT. Source: state.go

Generated by this command:

mockgen -source=state.go -destination=mock/state.go -package=mock -typed

Package mock is a generated GoMock package.

Code generated by MockGen. DO NOT EDIT. Source: storage_diff.go

Generated by this command:

mockgen -source=storage_diff.go -destination=mock/storage_diff.go -package=mock -typed

Package mock is a generated GoMock package.

Code generated by MockGen. DO NOT EDIT. Source: token.go

Generated by this command:

mockgen -source=token.go -destination=mock/token.go -package=mock -typed

Package mock is a generated GoMock package.

Code generated by MockGen. DO NOT EDIT. Source: token_balance.go

Generated by this command:

mockgen -source=token_balance.go -destination=mock/token_balance.go -package=mock -typed

Package mock is a generated GoMock package.

Code generated by MockGen. DO NOT EDIT. Source: transfer.go

Generated by this command:

mockgen -source=transfer.go -destination=mock/transfer.go -package=mock -typed

Package mock is a generated GoMock package.

Index

• type IAddressCursorListCall
  • func (c *IAddressCursorListCall) Do(...) *IAddressCursorListCall
  • func (c *IAddressCursorListCall) DoAndReturn(...) *IAddressCursorListCall
  • func (c *IAddressCursorListCall) Return(arg0 []*storage.Address, arg1 error) *IAddressCursorListCall
• type IAddressFilterCall
  • func (c *IAddressFilterCall) Do(...) *IAddressFilterCall
  • func (c *IAddressFilterCall) DoAndReturn(...) *IAddressFilterCall
  • func (c *IAddressFilterCall) Return(arg0 []storage.Address, arg1 error) *IAddressFilterCall
• type IAddressGetAddressesCall
  • func (c *IAddressGetAddressesCall) Do(f func(context.Context, ...uint64) ([]storage.Address, error)) *IAddressGetAddressesCall
  • func (c *IAddressGetAddressesCall) DoAndReturn(f func(context.Context, ...uint64) ([]storage.Address, error)) *IAddressGetAddressesCall
  • func (c *IAddressGetAddressesCall) Return(arg0 []storage.Address, arg1 error) *IAddressGetAddressesCall
• type IAddressGetByHashCall
  • func (c *IAddressGetByHashCall) Do(f func(context.Context, []byte) (storage.Address, error)) *IAddressGetByHashCall
  • func (c *IAddressGetByHashCall) DoAndReturn(f func(context.Context, []byte) (storage.Address, error)) *IAddressGetByHashCall
  • func (c *IAddressGetByHashCall) Return(arg0 storage.Address, arg1 error) *IAddressGetByHashCall
• type IAddressGetByHashesCall
  • func (c *IAddressGetByHashesCall) Do(f func(context.Context, [][]byte) ([]storage.Address, error)) *IAddressGetByHashesCall
  • func (c *IAddressGetByHashesCall) DoAndReturn(f func(context.Context, [][]byte) ([]storage.Address, error)) *IAddressGetByHashesCall
  • func (c *IAddressGetByHashesCall) Return(arg0 []storage.Address, arg1 error) *IAddressGetByHashesCall
• type IAddressGetByIDCall
  • func (c *IAddressGetByIDCall) Do(f func(context.Context, uint64) (*storage.Address, error)) *IAddressGetByIDCall
  • func (c *IAddressGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Address, error)) *IAddressGetByIDCall
  • func (c *IAddressGetByIDCall) Return(arg0 *storage.Address, arg1 error) *IAddressGetByIDCall
• type IAddressIsNoRowsCall
  • func (c *IAddressIsNoRowsCall) Do(f func(error) bool) *IAddressIsNoRowsCall
  • func (c *IAddressIsNoRowsCall) DoAndReturn(f func(error) bool) *IAddressIsNoRowsCall
  • func (c *IAddressIsNoRowsCall) Return(arg0 bool) *IAddressIsNoRowsCall
• type IAddressLastIDCall
  • func (c *IAddressLastIDCall) Do(f func(context.Context) (uint64, error)) *IAddressLastIDCall
  • func (c *IAddressLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IAddressLastIDCall
  • func (c *IAddressLastIDCall) Return(arg0 uint64, arg1 error) *IAddressLastIDCall
• type IAddressListCall
  • func (c *IAddressListCall) Do(...) *IAddressListCall
  • func (c *IAddressListCall) DoAndReturn(...) *IAddressListCall
  • func (c *IAddressListCall) Return(arg0 []*storage.Address, arg1 error) *IAddressListCall
• type IAddressSaveCall
  • func (c *IAddressSaveCall) Do(f func(context.Context, *storage.Address) error) *IAddressSaveCall
  • func (c *IAddressSaveCall) DoAndReturn(f func(context.Context, *storage.Address) error) *IAddressSaveCall
  • func (c *IAddressSaveCall) Return(arg0 error) *IAddressSaveCall
• type IAddressUpdateCall
  • func (c *IAddressUpdateCall) Do(f func(context.Context, *storage.Address) error) *IAddressUpdateCall
  • func (c *IAddressUpdateCall) DoAndReturn(f func(context.Context, *storage.Address) error) *IAddressUpdateCall
  • func (c *IAddressUpdateCall) Return(arg0 error) *IAddressUpdateCall
• type IBlockByHeightCall
  • func (c *IBlockByHeightCall) Do(f func(context.Context, uint64) (storage.Block, error)) *IBlockByHeightCall
  • func (c *IBlockByHeightCall) DoAndReturn(f func(context.Context, uint64) (storage.Block, error)) *IBlockByHeightCall
  • func (c *IBlockByHeightCall) Return(arg0 storage.Block, arg1 error) *IBlockByHeightCall
• type IBlockByStatusCall
  • func (c *IBlockByStatusCall) Do(...) *IBlockByStatusCall
  • func (c *IBlockByStatusCall) DoAndReturn(...) *IBlockByStatusCall
  • func (c *IBlockByStatusCall) Return(arg0 []storage.Block, arg1 error) *IBlockByStatusCall
• type IBlockCursorListCall
  • func (c *IBlockCursorListCall) Do(...) *IBlockCursorListCall
  • func (c *IBlockCursorListCall) DoAndReturn(...) *IBlockCursorListCall
  • func (c *IBlockCursorListCall) Return(arg0 []*storage.Block, arg1 error) *IBlockCursorListCall
• type IBlockGetByIDCall
  • func (c *IBlockGetByIDCall) Do(f func(context.Context, uint64) (*storage.Block, error)) *IBlockGetByIDCall
  • func (c *IBlockGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Block, error)) *IBlockGetByIDCall
  • func (c *IBlockGetByIDCall) Return(arg0 *storage.Block, arg1 error) *IBlockGetByIDCall
• type IBlockIsNoRowsCall
  • func (c *IBlockIsNoRowsCall) Do(f func(error) bool) *IBlockIsNoRowsCall
  • func (c *IBlockIsNoRowsCall) DoAndReturn(f func(error) bool) *IBlockIsNoRowsCall
  • func (c *IBlockIsNoRowsCall) Return(arg0 bool) *IBlockIsNoRowsCall
• type IBlockLastCall
  • func (c *IBlockLastCall) Do(f func(context.Context) (storage.Block, error)) *IBlockLastCall
  • func (c *IBlockLastCall) DoAndReturn(f func(context.Context) (storage.Block, error)) *IBlockLastCall
  • func (c *IBlockLastCall) Return(arg0 storage.Block, arg1 error) *IBlockLastCall
• type IBlockLastIDCall
  • func (c *IBlockLastIDCall) Do(f func(context.Context) (uint64, error)) *IBlockLastIDCall
  • func (c *IBlockLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IBlockLastIDCall
  • func (c *IBlockLastIDCall) Return(arg0 uint64, arg1 error) *IBlockLastIDCall
• type IBlockListCall
  • func (c *IBlockListCall) Do(...) *IBlockListCall
  • func (c *IBlockListCall) DoAndReturn(...) *IBlockListCall
  • func (c *IBlockListCall) Return(arg0 []*storage.Block, arg1 error) *IBlockListCall
• type IBlockSaveCall
  • func (c *IBlockSaveCall) Do(f func(context.Context, *storage.Block) error) *IBlockSaveCall
  • func (c *IBlockSaveCall) DoAndReturn(f func(context.Context, *storage.Block) error) *IBlockSaveCall
  • func (c *IBlockSaveCall) Return(arg0 error) *IBlockSaveCall
• type IBlockUpdateCall
  • func (c *IBlockUpdateCall) Do(f func(context.Context, *storage.Block) error) *IBlockUpdateCall
  • func (c *IBlockUpdateCall) DoAndReturn(f func(context.Context, *storage.Block) error) *IBlockUpdateCall
  • func (c *IBlockUpdateCall) Return(arg0 error) *IBlockUpdateCall
• type IClassCursorListCall
  • func (c *IClassCursorListCall) Do(...) *IClassCursorListCall
  • func (c *IClassCursorListCall) DoAndReturn(...) *IClassCursorListCall
  • func (c *IClassCursorListCall) Return(arg0 []*storage.Class, arg1 error) *IClassCursorListCall
• type IClassGetByHashCall
  • func (c *IClassGetByHashCall) Do(f func(context.Context, []byte) (storage.Class, error)) *IClassGetByHashCall
  • func (c *IClassGetByHashCall) DoAndReturn(f func(context.Context, []byte) (storage.Class, error)) *IClassGetByHashCall
  • func (c *IClassGetByHashCall) Return(arg0 storage.Class, arg1 error) *IClassGetByHashCall
• type IClassGetByIDCall
  • func (c *IClassGetByIDCall) Do(f func(context.Context, uint64) (*storage.Class, error)) *IClassGetByIDCall
  • func (c *IClassGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Class, error)) *IClassGetByIDCall
  • func (c *IClassGetByIDCall) Return(arg0 *storage.Class, arg1 error) *IClassGetByIDCall
• type IClassGetUnresolvedCall
  • func (c *IClassGetUnresolvedCall) Do(f func(context.Context) ([]storage.Class, error)) *IClassGetUnresolvedCall
  • func (c *IClassGetUnresolvedCall) DoAndReturn(f func(context.Context) ([]storage.Class, error)) *IClassGetUnresolvedCall
  • func (c *IClassGetUnresolvedCall) Return(arg0 []storage.Class, arg1 error) *IClassGetUnresolvedCall
• type IClassIsNoRowsCall
  • func (c *IClassIsNoRowsCall) Do(f func(error) bool) *IClassIsNoRowsCall
  • func (c *IClassIsNoRowsCall) DoAndReturn(f func(error) bool) *IClassIsNoRowsCall
  • func (c *IClassIsNoRowsCall) Return(arg0 bool) *IClassIsNoRowsCall
• type IClassLastIDCall
  • func (c *IClassLastIDCall) Do(f func(context.Context) (uint64, error)) *IClassLastIDCall
  • func (c *IClassLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IClassLastIDCall
  • func (c *IClassLastIDCall) Return(arg0 uint64, arg1 error) *IClassLastIDCall
• type IClassListCall
  • func (c *IClassListCall) Do(...) *IClassListCall
  • func (c *IClassListCall) DoAndReturn(...) *IClassListCall
  • func (c *IClassListCall) Return(arg0 []*storage.Class, arg1 error) *IClassListCall
• type IClassReplaceByHeightCall
  • func (c *IClassReplaceByHeightCall) Do(f func(context.Context, uint64) ([]storage.ClassReplace, error)) *IClassReplaceByHeightCall
  • func (c *IClassReplaceByHeightCall) DoAndReturn(f func(context.Context, uint64) ([]storage.ClassReplace, error)) *IClassReplaceByHeightCall
  • func (c *IClassReplaceByHeightCall) Return(arg0 []storage.ClassReplace, arg1 error) *IClassReplaceByHeightCall
• type IClassReplaceCursorListCall
  • func (c *IClassReplaceCursorListCall) Do(...) *IClassReplaceCursorListCall
  • func (c *IClassReplaceCursorListCall) DoAndReturn(...) *IClassReplaceCursorListCall
  • func (c *IClassReplaceCursorListCall) Return(arg0 []*storage.ClassReplace, arg1 error) *IClassReplaceCursorListCall
• type IClassReplaceGetByIDCall
  • func (c *IClassReplaceGetByIDCall) Do(f func(context.Context, uint64) (*storage.ClassReplace, error)) *IClassReplaceGetByIDCall
  • func (c *IClassReplaceGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.ClassReplace, error)) *IClassReplaceGetByIDCall
  • func (c *IClassReplaceGetByIDCall) Return(arg0 *storage.ClassReplace, arg1 error) *IClassReplaceGetByIDCall
• type IClassReplaceIsNoRowsCall
  • func (c *IClassReplaceIsNoRowsCall) Do(f func(error) bool) *IClassReplaceIsNoRowsCall
  • func (c *IClassReplaceIsNoRowsCall) DoAndReturn(f func(error) bool) *IClassReplaceIsNoRowsCall
  • func (c *IClassReplaceIsNoRowsCall) Return(arg0 bool) *IClassReplaceIsNoRowsCall
• type IClassReplaceLastIDCall
  • func (c *IClassReplaceLastIDCall) Do(f func(context.Context) (uint64, error)) *IClassReplaceLastIDCall
  • func (c *IClassReplaceLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IClassReplaceLastIDCall
  • func (c *IClassReplaceLastIDCall) Return(arg0 uint64, arg1 error) *IClassReplaceLastIDCall
• type IClassReplaceListCall
  • func (c *IClassReplaceListCall) Do(...) *IClassReplaceListCall
  • func (c *IClassReplaceListCall) DoAndReturn(...) *IClassReplaceListCall
  • func (c *IClassReplaceListCall) Return(arg0 []*storage.ClassReplace, arg1 error) *IClassReplaceListCall
• type IClassReplaceSaveCall
  • func (c *IClassReplaceSaveCall) Do(f func(context.Context, *storage.ClassReplace) error) *IClassReplaceSaveCall
  • func (c *IClassReplaceSaveCall) DoAndReturn(f func(context.Context, *storage.ClassReplace) error) *IClassReplaceSaveCall
  • func (c *IClassReplaceSaveCall) Return(arg0 error) *IClassReplaceSaveCall
• type IClassReplaceUpdateCall
  • func (c *IClassReplaceUpdateCall) Do(f func(context.Context, *storage.ClassReplace) error) *IClassReplaceUpdateCall
  • func (c *IClassReplaceUpdateCall) DoAndReturn(f func(context.Context, *storage.ClassReplace) error) *IClassReplaceUpdateCall
  • func (c *IClassReplaceUpdateCall) Return(arg0 error) *IClassReplaceUpdateCall
• type IClassSaveCall
  • func (c *IClassSaveCall) Do(f func(context.Context, *storage.Class) error) *IClassSaveCall
  • func (c *IClassSaveCall) DoAndReturn(f func(context.Context, *storage.Class) error) *IClassSaveCall
  • func (c *IClassSaveCall) Return(arg0 error) *IClassSaveCall
• type IClassUpdateCall
  • func (c *IClassUpdateCall) Do(f func(context.Context, *storage.Class) error) *IClassUpdateCall
  • func (c *IClassUpdateCall) DoAndReturn(f func(context.Context, *storage.Class) error) *IClassUpdateCall
  • func (c *IClassUpdateCall) Return(arg0 error) *IClassUpdateCall
• type IDeclareCursorListCall
  • func (c *IDeclareCursorListCall) Do(...) *IDeclareCursorListCall
  • func (c *IDeclareCursorListCall) DoAndReturn(...) *IDeclareCursorListCall
  • func (c *IDeclareCursorListCall) Return(arg0 []*storage.Declare, arg1 error) *IDeclareCursorListCall
• type IDeclareFilterCall
  • func (c *IDeclareFilterCall) Do(...) *IDeclareFilterCall
  • func (c *IDeclareFilterCall) DoAndReturn(...) *IDeclareFilterCall
  • func (c *IDeclareFilterCall) Return(arg0 []storage.Declare, arg1 error) *IDeclareFilterCall
• type IDeclareGetByIDCall
  • func (c *IDeclareGetByIDCall) Do(f func(context.Context, uint64) (*storage.Declare, error)) *IDeclareGetByIDCall
  • func (c *IDeclareGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Declare, error)) *IDeclareGetByIDCall
  • func (c *IDeclareGetByIDCall) Return(arg0 *storage.Declare, arg1 error) *IDeclareGetByIDCall
• type IDeclareIsNoRowsCall
  • func (c *IDeclareIsNoRowsCall) Do(f func(error) bool) *IDeclareIsNoRowsCall
  • func (c *IDeclareIsNoRowsCall) DoAndReturn(f func(error) bool) *IDeclareIsNoRowsCall
  • func (c *IDeclareIsNoRowsCall) Return(arg0 bool) *IDeclareIsNoRowsCall
• type IDeclareLastIDCall
  • func (c *IDeclareLastIDCall) Do(f func(context.Context) (uint64, error)) *IDeclareLastIDCall
  • func (c *IDeclareLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IDeclareLastIDCall
  • func (c *IDeclareLastIDCall) Return(arg0 uint64, arg1 error) *IDeclareLastIDCall
• type IDeclareListCall
  • func (c *IDeclareListCall) Do(...) *IDeclareListCall
  • func (c *IDeclareListCall) DoAndReturn(...) *IDeclareListCall
  • func (c *IDeclareListCall) Return(arg0 []*storage.Declare, arg1 error) *IDeclareListCall
• type IDeclareSaveCall
  • func (c *IDeclareSaveCall) Do(f func(context.Context, *storage.Declare) error) *IDeclareSaveCall
  • func (c *IDeclareSaveCall) DoAndReturn(f func(context.Context, *storage.Declare) error) *IDeclareSaveCall
  • func (c *IDeclareSaveCall) Return(arg0 error) *IDeclareSaveCall
• type IDeclareUpdateCall
  • func (c *IDeclareUpdateCall) Do(f func(context.Context, *storage.Declare) error) *IDeclareUpdateCall
  • func (c *IDeclareUpdateCall) DoAndReturn(f func(context.Context, *storage.Declare) error) *IDeclareUpdateCall
  • func (c *IDeclareUpdateCall) Return(arg0 error) *IDeclareUpdateCall
• type IDeployAccountCursorListCall
  • func (c *IDeployAccountCursorListCall) Do(...) *IDeployAccountCursorListCall
  • func (c *IDeployAccountCursorListCall) DoAndReturn(...) *IDeployAccountCursorListCall
  • func (c *IDeployAccountCursorListCall) Return(arg0 []*storage.DeployAccount, arg1 error) *IDeployAccountCursorListCall
• type IDeployAccountFilterCall
  • func (c *IDeployAccountFilterCall) Do(...) *IDeployAccountFilterCall
  • func (c *IDeployAccountFilterCall) DoAndReturn(...) *IDeployAccountFilterCall
  • func (c *IDeployAccountFilterCall) Return(arg0 []storage.DeployAccount, arg1 error) *IDeployAccountFilterCall
• type IDeployAccountGetByIDCall
  • func (c *IDeployAccountGetByIDCall) Do(f func(context.Context, uint64) (*storage.DeployAccount, error)) *IDeployAccountGetByIDCall
  • func (c *IDeployAccountGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.DeployAccount, error)) *IDeployAccountGetByIDCall
  • func (c *IDeployAccountGetByIDCall) Return(arg0 *storage.DeployAccount, arg1 error) *IDeployAccountGetByIDCall
• type IDeployAccountIsNoRowsCall
  • func (c *IDeployAccountIsNoRowsCall) Do(f func(error) bool) *IDeployAccountIsNoRowsCall
  • func (c *IDeployAccountIsNoRowsCall) DoAndReturn(f func(error) bool) *IDeployAccountIsNoRowsCall
  • func (c *IDeployAccountIsNoRowsCall) Return(arg0 bool) *IDeployAccountIsNoRowsCall
• type IDeployAccountLastIDCall
  • func (c *IDeployAccountLastIDCall) Do(f func(context.Context) (uint64, error)) *IDeployAccountLastIDCall
  • func (c *IDeployAccountLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IDeployAccountLastIDCall
  • func (c *IDeployAccountLastIDCall) Return(arg0 uint64, arg1 error) *IDeployAccountLastIDCall
• type IDeployAccountListCall
  • func (c *IDeployAccountListCall) Do(...) *IDeployAccountListCall
  • func (c *IDeployAccountListCall) DoAndReturn(...) *IDeployAccountListCall
  • func (c *IDeployAccountListCall) Return(arg0 []*storage.DeployAccount, arg1 error) *IDeployAccountListCall
• type IDeployAccountSaveCall
  • func (c *IDeployAccountSaveCall) Do(f func(context.Context, *storage.DeployAccount) error) *IDeployAccountSaveCall
  • func (c *IDeployAccountSaveCall) DoAndReturn(f func(context.Context, *storage.DeployAccount) error) *IDeployAccountSaveCall
  • func (c *IDeployAccountSaveCall) Return(arg0 error) *IDeployAccountSaveCall
• type IDeployAccountUpdateCall
  • func (c *IDeployAccountUpdateCall) Do(f func(context.Context, *storage.DeployAccount) error) *IDeployAccountUpdateCall
  • func (c *IDeployAccountUpdateCall) DoAndReturn(f func(context.Context, *storage.DeployAccount) error) *IDeployAccountUpdateCall
  • func (c *IDeployAccountUpdateCall) Return(arg0 error) *IDeployAccountUpdateCall
• type IDeployCursorListCall
  • func (c *IDeployCursorListCall) Do(...) *IDeployCursorListCall
  • func (c *IDeployCursorListCall) DoAndReturn(...) *IDeployCursorListCall
  • func (c *IDeployCursorListCall) Return(arg0 []*storage.Deploy, arg1 error) *IDeployCursorListCall
• type IDeployFilterCall
  • func (c *IDeployFilterCall) Do(...) *IDeployFilterCall
  • func (c *IDeployFilterCall) DoAndReturn(...) *IDeployFilterCall
  • func (c *IDeployFilterCall) Return(arg0 []storage.Deploy, arg1 error) *IDeployFilterCall
• type IDeployGetByIDCall
  • func (c *IDeployGetByIDCall) Do(f func(context.Context, uint64) (*storage.Deploy, error)) *IDeployGetByIDCall
  • func (c *IDeployGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Deploy, error)) *IDeployGetByIDCall
  • func (c *IDeployGetByIDCall) Return(arg0 *storage.Deploy, arg1 error) *IDeployGetByIDCall
• type IDeployIsNoRowsCall
  • func (c *IDeployIsNoRowsCall) Do(f func(error) bool) *IDeployIsNoRowsCall
  • func (c *IDeployIsNoRowsCall) DoAndReturn(f func(error) bool) *IDeployIsNoRowsCall
  • func (c *IDeployIsNoRowsCall) Return(arg0 bool) *IDeployIsNoRowsCall
• type IDeployLastIDCall
  • func (c *IDeployLastIDCall) Do(f func(context.Context) (uint64, error)) *IDeployLastIDCall
  • func (c *IDeployLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IDeployLastIDCall
  • func (c *IDeployLastIDCall) Return(arg0 uint64, arg1 error) *IDeployLastIDCall
• type IDeployListCall
  • func (c *IDeployListCall) Do(...) *IDeployListCall
  • func (c *IDeployListCall) DoAndReturn(...) *IDeployListCall
  • func (c *IDeployListCall) Return(arg0 []*storage.Deploy, arg1 error) *IDeployListCall
• type IDeploySaveCall
  • func (c *IDeploySaveCall) Do(f func(context.Context, *storage.Deploy) error) *IDeploySaveCall
  • func (c *IDeploySaveCall) DoAndReturn(f func(context.Context, *storage.Deploy) error) *IDeploySaveCall
  • func (c *IDeploySaveCall) Return(arg0 error) *IDeploySaveCall
• type IDeployUpdateCall
  • func (c *IDeployUpdateCall) Do(f func(context.Context, *storage.Deploy) error) *IDeployUpdateCall
  • func (c *IDeployUpdateCall) DoAndReturn(f func(context.Context, *storage.Deploy) error) *IDeployUpdateCall
  • func (c *IDeployUpdateCall) Return(arg0 error) *IDeployUpdateCall
• type IEventCursorListCall
  • func (c *IEventCursorListCall) Do(...) *IEventCursorListCall
  • func (c *IEventCursorListCall) DoAndReturn(...) *IEventCursorListCall
  • func (c *IEventCursorListCall) Return(arg0 []*storage.Event, arg1 error) *IEventCursorListCall
• type IEventFilterCall
  • func (c *IEventFilterCall) Do(...) *IEventFilterCall
  • func (c *IEventFilterCall) DoAndReturn(...) *IEventFilterCall
  • func (c *IEventFilterCall) Return(arg0 []storage.Event, arg1 error) *IEventFilterCall
• type IEventGetByIDCall
  • func (c *IEventGetByIDCall) Do(f func(context.Context, uint64) (*storage.Event, error)) *IEventGetByIDCall
  • func (c *IEventGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Event, error)) *IEventGetByIDCall
  • func (c *IEventGetByIDCall) Return(arg0 *storage.Event, arg1 error) *IEventGetByIDCall
• type IEventIsNoRowsCall
  • func (c *IEventIsNoRowsCall) Do(f func(error) bool) *IEventIsNoRowsCall
  • func (c *IEventIsNoRowsCall) DoAndReturn(f func(error) bool) *IEventIsNoRowsCall
  • func (c *IEventIsNoRowsCall) Return(arg0 bool) *IEventIsNoRowsCall
• type IEventLastIDCall
  • func (c *IEventLastIDCall) Do(f func(context.Context) (uint64, error)) *IEventLastIDCall
  • func (c *IEventLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IEventLastIDCall
  • func (c *IEventLastIDCall) Return(arg0 uint64, arg1 error) *IEventLastIDCall
• type IEventListCall
  • func (c *IEventListCall) Do(...) *IEventListCall
  • func (c *IEventListCall) DoAndReturn(...) *IEventListCall
  • func (c *IEventListCall) Return(arg0 []*storage.Event, arg1 error) *IEventListCall
• type IEventSaveCall
  • func (c *IEventSaveCall) Do(f func(context.Context, *storage.Event) error) *IEventSaveCall
  • func (c *IEventSaveCall) DoAndReturn(f func(context.Context, *storage.Event) error) *IEventSaveCall
  • func (c *IEventSaveCall) Return(arg0 error) *IEventSaveCall
• type IEventUpdateCall
  • func (c *IEventUpdateCall) Do(f func(context.Context, *storage.Event) error) *IEventUpdateCall
  • func (c *IEventUpdateCall) DoAndReturn(f func(context.Context, *storage.Event) error) *IEventUpdateCall
  • func (c *IEventUpdateCall) Return(arg0 error) *IEventUpdateCall
• type IFeeCursorListCall
  • func (c *IFeeCursorListCall) Do(...) *IFeeCursorListCall
  • func (c *IFeeCursorListCall) DoAndReturn(...) *IFeeCursorListCall
  • func (c *IFeeCursorListCall) Return(arg0 []*storage.Fee, arg1 error) *IFeeCursorListCall
• type IFeeFilterCall
  • func (c *IFeeFilterCall) Do(...) *IFeeFilterCall
  • func (c *IFeeFilterCall) DoAndReturn(...) *IFeeFilterCall
  • func (c *IFeeFilterCall) Return(arg0 []storage.Fee, arg1 error) *IFeeFilterCall
• type IFeeGetByIDCall
  • func (c *IFeeGetByIDCall) Do(f func(context.Context, uint64) (*storage.Fee, error)) *IFeeGetByIDCall
  • func (c *IFeeGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Fee, error)) *IFeeGetByIDCall
  • func (c *IFeeGetByIDCall) Return(arg0 *storage.Fee, arg1 error) *IFeeGetByIDCall
• type IFeeIsNoRowsCall
  • func (c *IFeeIsNoRowsCall) Do(f func(error) bool) *IFeeIsNoRowsCall
  • func (c *IFeeIsNoRowsCall) DoAndReturn(f func(error) bool) *IFeeIsNoRowsCall
  • func (c *IFeeIsNoRowsCall) Return(arg0 bool) *IFeeIsNoRowsCall
• type IFeeLastIDCall
  • func (c *IFeeLastIDCall) Do(f func(context.Context) (uint64, error)) *IFeeLastIDCall
  • func (c *IFeeLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IFeeLastIDCall
  • func (c *IFeeLastIDCall) Return(arg0 uint64, arg1 error) *IFeeLastIDCall
• type IFeeListCall
  • func (c *IFeeListCall) Do(...) *IFeeListCall
  • func (c *IFeeListCall) DoAndReturn(...) *IFeeListCall
  • func (c *IFeeListCall) Return(arg0 []*storage.Fee, arg1 error) *IFeeListCall
• type IFeeSaveCall
  • func (c *IFeeSaveCall) Do(f func(context.Context, *storage.Fee) error) *IFeeSaveCall
  • func (c *IFeeSaveCall) DoAndReturn(f func(context.Context, *storage.Fee) error) *IFeeSaveCall
  • func (c *IFeeSaveCall) Return(arg0 error) *IFeeSaveCall
• type IFeeUpdateCall
  • func (c *IFeeUpdateCall) Do(f func(context.Context, *storage.Fee) error) *IFeeUpdateCall
  • func (c *IFeeUpdateCall) DoAndReturn(f func(context.Context, *storage.Fee) error) *IFeeUpdateCall
  • func (c *IFeeUpdateCall) Return(arg0 error) *IFeeUpdateCall
• type IInternalCursorListCall
  • func (c *IInternalCursorListCall) Do(...) *IInternalCursorListCall
  • func (c *IInternalCursorListCall) DoAndReturn(...) *IInternalCursorListCall
  • func (c *IInternalCursorListCall) Return(arg0 []*storage.Internal, arg1 error) *IInternalCursorListCall
• type IInternalFilterCall
  • func (c *IInternalFilterCall) Do(...) *IInternalFilterCall
  • func (c *IInternalFilterCall) DoAndReturn(...) *IInternalFilterCall
  • func (c *IInternalFilterCall) Return(arg0 []storage.Internal, arg1 error) *IInternalFilterCall
• type IInternalGetByIDCall
  • func (c *IInternalGetByIDCall) Do(f func(context.Context, uint64) (*storage.Internal, error)) *IInternalGetByIDCall
  • func (c *IInternalGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Internal, error)) *IInternalGetByIDCall
  • func (c *IInternalGetByIDCall) Return(arg0 *storage.Internal, arg1 error) *IInternalGetByIDCall
• type IInternalIsNoRowsCall
  • func (c *IInternalIsNoRowsCall) Do(f func(error) bool) *IInternalIsNoRowsCall
  • func (c *IInternalIsNoRowsCall) DoAndReturn(f func(error) bool) *IInternalIsNoRowsCall
  • func (c *IInternalIsNoRowsCall) Return(arg0 bool) *IInternalIsNoRowsCall
• type IInternalLastIDCall
  • func (c *IInternalLastIDCall) Do(f func(context.Context) (uint64, error)) *IInternalLastIDCall
  • func (c *IInternalLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IInternalLastIDCall
  • func (c *IInternalLastIDCall) Return(arg0 uint64, arg1 error) *IInternalLastIDCall
• type IInternalListCall
  • func (c *IInternalListCall) Do(...) *IInternalListCall
  • func (c *IInternalListCall) DoAndReturn(...) *IInternalListCall
  • func (c *IInternalListCall) Return(arg0 []*storage.Internal, arg1 error) *IInternalListCall
• type IInternalSaveCall
  • func (c *IInternalSaveCall) Do(f func(context.Context, *storage.Internal) error) *IInternalSaveCall
  • func (c *IInternalSaveCall) DoAndReturn(f func(context.Context, *storage.Internal) error) *IInternalSaveCall
  • func (c *IInternalSaveCall) Return(arg0 error) *IInternalSaveCall
• type IInternalUpdateCall
  • func (c *IInternalUpdateCall) Do(f func(context.Context, *storage.Internal) error) *IInternalUpdateCall
  • func (c *IInternalUpdateCall) DoAndReturn(f func(context.Context, *storage.Internal) error) *IInternalUpdateCall
  • func (c *IInternalUpdateCall) Return(arg0 error) *IInternalUpdateCall
• type IInvokeCursorListCall
  • func (c *IInvokeCursorListCall) Do(...) *IInvokeCursorListCall
  • func (c *IInvokeCursorListCall) DoAndReturn(...) *IInvokeCursorListCall
  • func (c *IInvokeCursorListCall) Return(arg0 []*storage.Invoke, arg1 error) *IInvokeCursorListCall
• type IInvokeFilterCall
  • func (c *IInvokeFilterCall) Do(...) *IInvokeFilterCall
  • func (c *IInvokeFilterCall) DoAndReturn(...) *IInvokeFilterCall
  • func (c *IInvokeFilterCall) Return(arg0 []storage.Invoke, arg1 error) *IInvokeFilterCall
• type IInvokeGetByIDCall
  • func (c *IInvokeGetByIDCall) Do(f func(context.Context, uint64) (*storage.Invoke, error)) *IInvokeGetByIDCall
  • func (c *IInvokeGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Invoke, error)) *IInvokeGetByIDCall
  • func (c *IInvokeGetByIDCall) Return(arg0 *storage.Invoke, arg1 error) *IInvokeGetByIDCall
• type IInvokeHashByHeightCall
  • func (c *IInvokeHashByHeightCall) Do(f func(context.Context, uint64) ([]byte, error)) *IInvokeHashByHeightCall
  • func (c *IInvokeHashByHeightCall) DoAndReturn(f func(context.Context, uint64) ([]byte, error)) *IInvokeHashByHeightCall
  • func (c *IInvokeHashByHeightCall) Return(arg0 []byte, arg1 error) *IInvokeHashByHeightCall
• type IInvokeIsNoRowsCall
  • func (c *IInvokeIsNoRowsCall) Do(f func(error) bool) *IInvokeIsNoRowsCall
  • func (c *IInvokeIsNoRowsCall) DoAndReturn(f func(error) bool) *IInvokeIsNoRowsCall
  • func (c *IInvokeIsNoRowsCall) Return(arg0 bool) *IInvokeIsNoRowsCall
• type IInvokeLastIDCall
  • func (c *IInvokeLastIDCall) Do(f func(context.Context) (uint64, error)) *IInvokeLastIDCall
  • func (c *IInvokeLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IInvokeLastIDCall
  • func (c *IInvokeLastIDCall) Return(arg0 uint64, arg1 error) *IInvokeLastIDCall
• type IInvokeListCall
  • func (c *IInvokeListCall) Do(...) *IInvokeListCall
  • func (c *IInvokeListCall) DoAndReturn(...) *IInvokeListCall
  • func (c *IInvokeListCall) Return(arg0 []*storage.Invoke, arg1 error) *IInvokeListCall
• type IInvokeSaveCall
  • func (c *IInvokeSaveCall) Do(f func(context.Context, *storage.Invoke) error) *IInvokeSaveCall
  • func (c *IInvokeSaveCall) DoAndReturn(f func(context.Context, *storage.Invoke) error) *IInvokeSaveCall
  • func (c *IInvokeSaveCall) Return(arg0 error) *IInvokeSaveCall
• type IInvokeUpdateCall
  • func (c *IInvokeUpdateCall) Do(f func(context.Context, *storage.Invoke) error) *IInvokeUpdateCall
  • func (c *IInvokeUpdateCall) DoAndReturn(f func(context.Context, *storage.Invoke) error) *IInvokeUpdateCall
  • func (c *IInvokeUpdateCall) Return(arg0 error) *IInvokeUpdateCall
• type IL1HandlerCursorListCall
  • func (c *IL1HandlerCursorListCall) Do(...) *IL1HandlerCursorListCall
  • func (c *IL1HandlerCursorListCall) DoAndReturn(...) *IL1HandlerCursorListCall
  • func (c *IL1HandlerCursorListCall) Return(arg0 []*storage.L1Handler, arg1 error) *IL1HandlerCursorListCall
• type IL1HandlerFilterCall
  • func (c *IL1HandlerFilterCall) Do(...) *IL1HandlerFilterCall
  • func (c *IL1HandlerFilterCall) DoAndReturn(...) *IL1HandlerFilterCall
  • func (c *IL1HandlerFilterCall) Return(arg0 []storage.L1Handler, arg1 error) *IL1HandlerFilterCall
• type IL1HandlerGetByIDCall
  • func (c *IL1HandlerGetByIDCall) Do(f func(context.Context, uint64) (*storage.L1Handler, error)) *IL1HandlerGetByIDCall
  • func (c *IL1HandlerGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.L1Handler, error)) *IL1HandlerGetByIDCall
  • func (c *IL1HandlerGetByIDCall) Return(arg0 *storage.L1Handler, arg1 error) *IL1HandlerGetByIDCall
• type IL1HandlerIsNoRowsCall
  • func (c *IL1HandlerIsNoRowsCall) Do(f func(error) bool) *IL1HandlerIsNoRowsCall
  • func (c *IL1HandlerIsNoRowsCall) DoAndReturn(f func(error) bool) *IL1HandlerIsNoRowsCall
  • func (c *IL1HandlerIsNoRowsCall) Return(arg0 bool) *IL1HandlerIsNoRowsCall
• type IL1HandlerLastIDCall
  • func (c *IL1HandlerLastIDCall) Do(f func(context.Context) (uint64, error)) *IL1HandlerLastIDCall
  • func (c *IL1HandlerLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IL1HandlerLastIDCall
  • func (c *IL1HandlerLastIDCall) Return(arg0 uint64, arg1 error) *IL1HandlerLastIDCall
• type IL1HandlerListCall
  • func (c *IL1HandlerListCall) Do(...) *IL1HandlerListCall
  • func (c *IL1HandlerListCall) DoAndReturn(...) *IL1HandlerListCall
  • func (c *IL1HandlerListCall) Return(arg0 []*storage.L1Handler, arg1 error) *IL1HandlerListCall
• type IL1HandlerSaveCall
  • func (c *IL1HandlerSaveCall) Do(f func(context.Context, *storage.L1Handler) error) *IL1HandlerSaveCall
  • func (c *IL1HandlerSaveCall) DoAndReturn(f func(context.Context, *storage.L1Handler) error) *IL1HandlerSaveCall
  • func (c *IL1HandlerSaveCall) Return(arg0 error) *IL1HandlerSaveCall
• type IL1HandlerUpdateCall
  • func (c *IL1HandlerUpdateCall) Do(f func(context.Context, *storage.L1Handler) error) *IL1HandlerUpdateCall
  • func (c *IL1HandlerUpdateCall) DoAndReturn(f func(context.Context, *storage.L1Handler) error) *IL1HandlerUpdateCall
  • func (c *IL1HandlerUpdateCall) Return(arg0 error) *IL1HandlerUpdateCall
• type IMessageCursorListCall
  • func (c *IMessageCursorListCall) Do(...) *IMessageCursorListCall
  • func (c *IMessageCursorListCall) DoAndReturn(...) *IMessageCursorListCall
  • func (c *IMessageCursorListCall) Return(arg0 []*storage.Message, arg1 error) *IMessageCursorListCall
• type IMessageFilterCall
  • func (c *IMessageFilterCall) Do(...) *IMessageFilterCall
  • func (c *IMessageFilterCall) DoAndReturn(...) *IMessageFilterCall
  • func (c *IMessageFilterCall) Return(arg0 []storage.Message, arg1 error) *IMessageFilterCall
• type IMessageGetByIDCall
  • func (c *IMessageGetByIDCall) Do(f func(context.Context, uint64) (*storage.Message, error)) *IMessageGetByIDCall
  • func (c *IMessageGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Message, error)) *IMessageGetByIDCall
  • func (c *IMessageGetByIDCall) Return(arg0 *storage.Message, arg1 error) *IMessageGetByIDCall
• type IMessageIsNoRowsCall
  • func (c *IMessageIsNoRowsCall) Do(f func(error) bool) *IMessageIsNoRowsCall
  • func (c *IMessageIsNoRowsCall) DoAndReturn(f func(error) bool) *IMessageIsNoRowsCall
  • func (c *IMessageIsNoRowsCall) Return(arg0 bool) *IMessageIsNoRowsCall
• type IMessageLastIDCall
  • func (c *IMessageLastIDCall) Do(f func(context.Context) (uint64, error)) *IMessageLastIDCall
  • func (c *IMessageLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IMessageLastIDCall
  • func (c *IMessageLastIDCall) Return(arg0 uint64, arg1 error) *IMessageLastIDCall
• type IMessageListCall
  • func (c *IMessageListCall) Do(...) *IMessageListCall
  • func (c *IMessageListCall) DoAndReturn(...) *IMessageListCall
  • func (c *IMessageListCall) Return(arg0 []*storage.Message, arg1 error) *IMessageListCall
• type IMessageSaveCall
  • func (c *IMessageSaveCall) Do(f func(context.Context, *storage.Message) error) *IMessageSaveCall
  • func (c *IMessageSaveCall) DoAndReturn(f func(context.Context, *storage.Message) error) *IMessageSaveCall
  • func (c *IMessageSaveCall) Return(arg0 error) *IMessageSaveCall
• type IMessageUpdateCall
  • func (c *IMessageUpdateCall) Do(f func(context.Context, *storage.Message) error) *IMessageUpdateCall
  • func (c *IMessageUpdateCall) DoAndReturn(f func(context.Context, *storage.Message) error) *IMessageUpdateCall
  • func (c *IMessageUpdateCall) Return(arg0 error) *IMessageUpdateCall
• type IProxyCursorListCall
  • func (c *IProxyCursorListCall) Do(...) *IProxyCursorListCall
  • func (c *IProxyCursorListCall) DoAndReturn(...) *IProxyCursorListCall
  • func (c *IProxyCursorListCall) Return(arg0 []*storage.Proxy, arg1 error) *IProxyCursorListCall
• type IProxyGetByHashCall
  • func (c *IProxyGetByHashCall) Do(f func(context.Context, []byte, []byte) (storage.Proxy, error)) *IProxyGetByHashCall
  • func (c *IProxyGetByHashCall) DoAndReturn(f func(context.Context, []byte, []byte) (storage.Proxy, error)) *IProxyGetByHashCall
  • func (c *IProxyGetByHashCall) Return(arg0 storage.Proxy, arg1 error) *IProxyGetByHashCall
• type IProxyGetByIDCall
  • func (c *IProxyGetByIDCall) Do(f func(context.Context, uint64) (*storage.Proxy, error)) *IProxyGetByIDCall
  • func (c *IProxyGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Proxy, error)) *IProxyGetByIDCall
  • func (c *IProxyGetByIDCall) Return(arg0 *storage.Proxy, arg1 error) *IProxyGetByIDCall
• type IProxyIsNoRowsCall
  • func (c *IProxyIsNoRowsCall) Do(f func(error) bool) *IProxyIsNoRowsCall
  • func (c *IProxyIsNoRowsCall) DoAndReturn(f func(error) bool) *IProxyIsNoRowsCall
  • func (c *IProxyIsNoRowsCall) Return(arg0 bool) *IProxyIsNoRowsCall
• type IProxyLastIDCall
  • func (c *IProxyLastIDCall) Do(f func(context.Context) (uint64, error)) *IProxyLastIDCall
  • func (c *IProxyLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IProxyLastIDCall
  • func (c *IProxyLastIDCall) Return(arg0 uint64, arg1 error) *IProxyLastIDCall
• type IProxyListCall
  • func (c *IProxyListCall) Do(...) *IProxyListCall
  • func (c *IProxyListCall) DoAndReturn(...) *IProxyListCall
  • func (c *IProxyListCall) Return(arg0 []*storage.Proxy, arg1 error) *IProxyListCall
• type IProxySaveCall
  • func (c *IProxySaveCall) Do(f func(context.Context, *storage.Proxy) error) *IProxySaveCall
  • func (c *IProxySaveCall) DoAndReturn(f func(context.Context, *storage.Proxy) error) *IProxySaveCall
  • func (c *IProxySaveCall) Return(arg0 error) *IProxySaveCall
• type IProxyUpdateCall
  • func (c *IProxyUpdateCall) Do(f func(context.Context, *storage.Proxy) error) *IProxyUpdateCall
  • func (c *IProxyUpdateCall) DoAndReturn(f func(context.Context, *storage.Proxy) error) *IProxyUpdateCall
  • func (c *IProxyUpdateCall) Return(arg0 error) *IProxyUpdateCall
• type IProxyUpgradeCursorListCall
  • func (c *IProxyUpgradeCursorListCall) Do(...) *IProxyUpgradeCursorListCall
  • func (c *IProxyUpgradeCursorListCall) DoAndReturn(...) *IProxyUpgradeCursorListCall
  • func (c *IProxyUpgradeCursorListCall) Return(arg0 []*storage.ProxyUpgrade, arg1 error) *IProxyUpgradeCursorListCall
• type IProxyUpgradeGetByIDCall
  • func (c *IProxyUpgradeGetByIDCall) Do(f func(context.Context, uint64) (*storage.ProxyUpgrade, error)) *IProxyUpgradeGetByIDCall
  • func (c *IProxyUpgradeGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.ProxyUpgrade, error)) *IProxyUpgradeGetByIDCall
  • func (c *IProxyUpgradeGetByIDCall) Return(arg0 *storage.ProxyUpgrade, arg1 error) *IProxyUpgradeGetByIDCall
• type IProxyUpgradeIsNoRowsCall
  • func (c *IProxyUpgradeIsNoRowsCall) Do(f func(error) bool) *IProxyUpgradeIsNoRowsCall
  • func (c *IProxyUpgradeIsNoRowsCall) DoAndReturn(f func(error) bool) *IProxyUpgradeIsNoRowsCall
  • func (c *IProxyUpgradeIsNoRowsCall) Return(arg0 bool) *IProxyUpgradeIsNoRowsCall
• type IProxyUpgradeLastBeforeCall
  • func (c *IProxyUpgradeLastBeforeCall) Do(f func(context.Context, []byte, []byte, uint64) (storage.ProxyUpgrade, error)) *IProxyUpgradeLastBeforeCall
  • func (c *IProxyUpgradeLastBeforeCall) DoAndReturn(f func(context.Context, []byte, []byte, uint64) (storage.ProxyUpgrade, error)) *IProxyUpgradeLastBeforeCall
  • func (c *IProxyUpgradeLastBeforeCall) Return(arg0 storage.ProxyUpgrade, arg1 error) *IProxyUpgradeLastBeforeCall
• type IProxyUpgradeLastIDCall
  • func (c *IProxyUpgradeLastIDCall) Do(f func(context.Context) (uint64, error)) *IProxyUpgradeLastIDCall
  • func (c *IProxyUpgradeLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IProxyUpgradeLastIDCall
  • func (c *IProxyUpgradeLastIDCall) Return(arg0 uint64, arg1 error) *IProxyUpgradeLastIDCall
• type IProxyUpgradeListCall
  • func (c *IProxyUpgradeListCall) Do(...) *IProxyUpgradeListCall
  • func (c *IProxyUpgradeListCall) DoAndReturn(...) *IProxyUpgradeListCall
  • func (c *IProxyUpgradeListCall) Return(arg0 []*storage.ProxyUpgrade, arg1 error) *IProxyUpgradeListCall
• type IProxyUpgradeListWithHeightCall
  • func (c *IProxyUpgradeListWithHeightCall) Do(f func(context.Context, uint64, int, int) ([]storage.ProxyUpgrade, error)) *IProxyUpgradeListWithHeightCall
  • func (c *IProxyUpgradeListWithHeightCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.ProxyUpgrade, error)) *IProxyUpgradeListWithHeightCall
  • func (c *IProxyUpgradeListWithHeightCall) Return(arg0 []storage.ProxyUpgrade, arg1 error) *IProxyUpgradeListWithHeightCall
• type IProxyUpgradeSaveCall
  • func (c *IProxyUpgradeSaveCall) Do(f func(context.Context, *storage.ProxyUpgrade) error) *IProxyUpgradeSaveCall
  • func (c *IProxyUpgradeSaveCall) DoAndReturn(f func(context.Context, *storage.ProxyUpgrade) error) *IProxyUpgradeSaveCall
  • func (c *IProxyUpgradeSaveCall) Return(arg0 error) *IProxyUpgradeSaveCall
• type IProxyUpgradeUpdateCall
  • func (c *IProxyUpgradeUpdateCall) Do(f func(context.Context, *storage.ProxyUpgrade) error) *IProxyUpgradeUpdateCall
  • func (c *IProxyUpgradeUpdateCall) DoAndReturn(f func(context.Context, *storage.ProxyUpgrade) error) *IProxyUpgradeUpdateCall
  • func (c *IProxyUpgradeUpdateCall) Return(arg0 error) *IProxyUpgradeUpdateCall
• type IStateByNameCall
  • func (c *IStateByNameCall) Do(f func(context.Context, string) (storage.State, error)) *IStateByNameCall
  • func (c *IStateByNameCall) DoAndReturn(f func(context.Context, string) (storage.State, error)) *IStateByNameCall
  • func (c *IStateByNameCall) Return(arg0 storage.State, arg1 error) *IStateByNameCall
• type IStateCursorListCall
  • func (c *IStateCursorListCall) Do(...) *IStateCursorListCall
  • func (c *IStateCursorListCall) DoAndReturn(...) *IStateCursorListCall
  • func (c *IStateCursorListCall) Return(arg0 []*storage.State, arg1 error) *IStateCursorListCall
• type IStateGetByIDCall
  • func (c *IStateGetByIDCall) Do(f func(context.Context, uint64) (*storage.State, error)) *IStateGetByIDCall
  • func (c *IStateGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.State, error)) *IStateGetByIDCall
  • func (c *IStateGetByIDCall) Return(arg0 *storage.State, arg1 error) *IStateGetByIDCall
• type IStateIsNoRowsCall
  • func (c *IStateIsNoRowsCall) Do(f func(error) bool) *IStateIsNoRowsCall
  • func (c *IStateIsNoRowsCall) DoAndReturn(f func(error) bool) *IStateIsNoRowsCall
  • func (c *IStateIsNoRowsCall) Return(arg0 bool) *IStateIsNoRowsCall
• type IStateLastIDCall
  • func (c *IStateLastIDCall) Do(f func(context.Context) (uint64, error)) *IStateLastIDCall
  • func (c *IStateLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IStateLastIDCall
  • func (c *IStateLastIDCall) Return(arg0 uint64, arg1 error) *IStateLastIDCall
• type IStateListCall
  • func (c *IStateListCall) Do(...) *IStateListCall
  • func (c *IStateListCall) DoAndReturn(...) *IStateListCall
  • func (c *IStateListCall) Return(arg0 []*storage.State, arg1 error) *IStateListCall
• type IStateSaveCall
  • func (c *IStateSaveCall) Do(f func(context.Context, *storage.State) error) *IStateSaveCall
  • func (c *IStateSaveCall) DoAndReturn(f func(context.Context, *storage.State) error) *IStateSaveCall
  • func (c *IStateSaveCall) Return(arg0 error) *IStateSaveCall
• type IStateUpdateCall
  • func (c *IStateUpdateCall) Do(f func(context.Context, *storage.State) error) *IStateUpdateCall
  • func (c *IStateUpdateCall) DoAndReturn(f func(context.Context, *storage.State) error) *IStateUpdateCall
  • func (c *IStateUpdateCall) Return(arg0 error) *IStateUpdateCall
• type IStorageDiffCursorListCall
  • func (c *IStorageDiffCursorListCall) Do(...) *IStorageDiffCursorListCall
  • func (c *IStorageDiffCursorListCall) DoAndReturn(...) *IStorageDiffCursorListCall
  • func (c *IStorageDiffCursorListCall) Return(arg0 []*storage.StorageDiff, arg1 error) *IStorageDiffCursorListCall
• type IStorageDiffFilterCall
  • func (c *IStorageDiffFilterCall) Do(...) *IStorageDiffFilterCall
  • func (c *IStorageDiffFilterCall) DoAndReturn(...) *IStorageDiffFilterCall
  • func (c *IStorageDiffFilterCall) Return(arg0 []storage.StorageDiff, arg1 error) *IStorageDiffFilterCall
• type IStorageDiffGetByIDCall
  • func (c *IStorageDiffGetByIDCall) Do(f func(context.Context, uint64) (*storage.StorageDiff, error)) *IStorageDiffGetByIDCall
  • func (c *IStorageDiffGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.StorageDiff, error)) *IStorageDiffGetByIDCall
  • func (c *IStorageDiffGetByIDCall) Return(arg0 *storage.StorageDiff, arg1 error) *IStorageDiffGetByIDCall
• type IStorageDiffGetOnBlockCall
  • func (c *IStorageDiffGetOnBlockCall) Do(f func(context.Context, uint64, uint64, []byte) (storage.StorageDiff, error)) *IStorageDiffGetOnBlockCall
  • func (c *IStorageDiffGetOnBlockCall) DoAndReturn(f func(context.Context, uint64, uint64, []byte) (storage.StorageDiff, error)) *IStorageDiffGetOnBlockCall
  • func (c *IStorageDiffGetOnBlockCall) Return(arg0 storage.StorageDiff, arg1 error) *IStorageDiffGetOnBlockCall
• type IStorageDiffIsNoRowsCall
  • func (c *IStorageDiffIsNoRowsCall) Do(f func(error) bool) *IStorageDiffIsNoRowsCall
  • func (c *IStorageDiffIsNoRowsCall) DoAndReturn(f func(error) bool) *IStorageDiffIsNoRowsCall
  • func (c *IStorageDiffIsNoRowsCall) Return(arg0 bool) *IStorageDiffIsNoRowsCall
• type IStorageDiffLastIDCall
  • func (c *IStorageDiffLastIDCall) Do(f func(context.Context) (uint64, error)) *IStorageDiffLastIDCall
  • func (c *IStorageDiffLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IStorageDiffLastIDCall
  • func (c *IStorageDiffLastIDCall) Return(arg0 uint64, arg1 error) *IStorageDiffLastIDCall
• type IStorageDiffListCall
  • func (c *IStorageDiffListCall) Do(...) *IStorageDiffListCall
  • func (c *IStorageDiffListCall) DoAndReturn(...) *IStorageDiffListCall
  • func (c *IStorageDiffListCall) Return(arg0 []*storage.StorageDiff, arg1 error) *IStorageDiffListCall
• type IStorageDiffSaveCall
  • func (c *IStorageDiffSaveCall) Do(f func(context.Context, *storage.StorageDiff) error) *IStorageDiffSaveCall
  • func (c *IStorageDiffSaveCall) DoAndReturn(f func(context.Context, *storage.StorageDiff) error) *IStorageDiffSaveCall
  • func (c *IStorageDiffSaveCall) Return(arg0 error) *IStorageDiffSaveCall
• type IStorageDiffUpdateCall
  • func (c *IStorageDiffUpdateCall) Do(f func(context.Context, *storage.StorageDiff) error) *IStorageDiffUpdateCall
  • func (c *IStorageDiffUpdateCall) DoAndReturn(f func(context.Context, *storage.StorageDiff) error) *IStorageDiffUpdateCall
  • func (c *IStorageDiffUpdateCall) Return(arg0 error) *IStorageDiffUpdateCall
• type ITokenBalanceBalancesCall
  • func (c *ITokenBalanceBalancesCall) Do(...) *ITokenBalanceBalancesCall
  • func (c *ITokenBalanceBalancesCall) DoAndReturn(...) *ITokenBalanceBalancesCall
  • func (c *ITokenBalanceBalancesCall) Return(arg0 []storage.TokenBalance, arg1 error) *ITokenBalanceBalancesCall
• type ITokenBalanceCursorListCall
  • func (c *ITokenBalanceCursorListCall) Do(...) *ITokenBalanceCursorListCall
  • func (c *ITokenBalanceCursorListCall) DoAndReturn(...) *ITokenBalanceCursorListCall
  • func (c *ITokenBalanceCursorListCall) Return(arg0 []*storage.TokenBalance, arg1 error) *ITokenBalanceCursorListCall
• type ITokenBalanceFilterCall
  • func (c *ITokenBalanceFilterCall) Do(...) *ITokenBalanceFilterCall
  • func (c *ITokenBalanceFilterCall) DoAndReturn(...) *ITokenBalanceFilterCall
  • func (c *ITokenBalanceFilterCall) Return(arg0 []storage.TokenBalance, arg1 error) *ITokenBalanceFilterCall
• type ITokenBalanceGetByIDCall
  • func (c *ITokenBalanceGetByIDCall) Do(f func(context.Context, uint64) (*storage.TokenBalance, error)) *ITokenBalanceGetByIDCall
  • func (c *ITokenBalanceGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.TokenBalance, error)) *ITokenBalanceGetByIDCall
  • func (c *ITokenBalanceGetByIDCall) Return(arg0 *storage.TokenBalance, arg1 error) *ITokenBalanceGetByIDCall
• type ITokenBalanceIsNoRowsCall
  • func (c *ITokenBalanceIsNoRowsCall) Do(f func(error) bool) *ITokenBalanceIsNoRowsCall
  • func (c *ITokenBalanceIsNoRowsCall) DoAndReturn(f func(error) bool) *ITokenBalanceIsNoRowsCall
  • func (c *ITokenBalanceIsNoRowsCall) Return(arg0 bool) *ITokenBalanceIsNoRowsCall
• type ITokenBalanceLastIDCall
  • func (c *ITokenBalanceLastIDCall) Do(f func(context.Context) (uint64, error)) *ITokenBalanceLastIDCall
  • func (c *ITokenBalanceLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *ITokenBalanceLastIDCall
  • func (c *ITokenBalanceLastIDCall) Return(arg0 uint64, arg1 error) *ITokenBalanceLastIDCall
• type ITokenBalanceListCall
  • func (c *ITokenBalanceListCall) Do(...) *ITokenBalanceListCall
  • func (c *ITokenBalanceListCall) DoAndReturn(...) *ITokenBalanceListCall
  • func (c *ITokenBalanceListCall) Return(arg0 []*storage.TokenBalance, arg1 error) *ITokenBalanceListCall
• type ITokenBalanceSaveCall
  • func (c *ITokenBalanceSaveCall) Do(f func(context.Context, *storage.TokenBalance) error) *ITokenBalanceSaveCall
  • func (c *ITokenBalanceSaveCall) DoAndReturn(f func(context.Context, *storage.TokenBalance) error) *ITokenBalanceSaveCall
  • func (c *ITokenBalanceSaveCall) Return(arg0 error) *ITokenBalanceSaveCall
• type ITokenBalanceUpdateCall
  • func (c *ITokenBalanceUpdateCall) Do(f func(context.Context, *storage.TokenBalance) error) *ITokenBalanceUpdateCall
  • func (c *ITokenBalanceUpdateCall) DoAndReturn(f func(context.Context, *storage.TokenBalance) error) *ITokenBalanceUpdateCall
  • func (c *ITokenBalanceUpdateCall) Return(arg0 error) *ITokenBalanceUpdateCall
• type ITokenCursorListCall
  • func (c *ITokenCursorListCall) Do(...) *ITokenCursorListCall
  • func (c *ITokenCursorListCall) DoAndReturn(...) *ITokenCursorListCall
  • func (c *ITokenCursorListCall) Return(arg0 []*storage.Token, arg1 error) *ITokenCursorListCall
• type ITokenFilterCall
  • func (c *ITokenFilterCall) Do(...) *ITokenFilterCall
  • func (c *ITokenFilterCall) DoAndReturn(...) *ITokenFilterCall
  • func (c *ITokenFilterCall) Return(arg0 []storage.Token, arg1 error) *ITokenFilterCall
• type ITokenFindCall
  • func (c *ITokenFindCall) Do(f func(context.Context, uint64, string) (storage.Token, error)) *ITokenFindCall
  • func (c *ITokenFindCall) DoAndReturn(f func(context.Context, uint64, string) (storage.Token, error)) *ITokenFindCall
  • func (c *ITokenFindCall) Return(arg0 storage.Token, arg1 error) *ITokenFindCall
• type ITokenGetByIDCall
  • func (c *ITokenGetByIDCall) Do(f func(context.Context, uint64) (*storage.Token, error)) *ITokenGetByIDCall
  • func (c *ITokenGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Token, error)) *ITokenGetByIDCall
  • func (c *ITokenGetByIDCall) Return(arg0 *storage.Token, arg1 error) *ITokenGetByIDCall
• type ITokenIsNoRowsCall
  • func (c *ITokenIsNoRowsCall) Do(f func(error) bool) *ITokenIsNoRowsCall
  • func (c *ITokenIsNoRowsCall) DoAndReturn(f func(error) bool) *ITokenIsNoRowsCall
  • func (c *ITokenIsNoRowsCall) Return(arg0 bool) *ITokenIsNoRowsCall
• type ITokenLastIDCall
  • func (c *ITokenLastIDCall) Do(f func(context.Context) (uint64, error)) *ITokenLastIDCall
  • func (c *ITokenLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *ITokenLastIDCall
  • func (c *ITokenLastIDCall) Return(arg0 uint64, arg1 error) *ITokenLastIDCall
• type ITokenListByTypeCall
  • func (c *ITokenListByTypeCall) Do(...) *ITokenListByTypeCall
  • func (c *ITokenListByTypeCall) DoAndReturn(...) *ITokenListByTypeCall
  • func (c *ITokenListByTypeCall) Return(arg0 []storage.Token, arg1 error) *ITokenListByTypeCall
• type ITokenListCall
  • func (c *ITokenListCall) Do(...) *ITokenListCall
  • func (c *ITokenListCall) DoAndReturn(...) *ITokenListCall
  • func (c *ITokenListCall) Return(arg0 []*storage.Token, arg1 error) *ITokenListCall
• type ITokenSaveCall
  • func (c *ITokenSaveCall) Do(f func(context.Context, *storage.Token) error) *ITokenSaveCall
  • func (c *ITokenSaveCall) DoAndReturn(f func(context.Context, *storage.Token) error) *ITokenSaveCall
  • func (c *ITokenSaveCall) Return(arg0 error) *ITokenSaveCall
• type ITokenUpdateCall
  • func (c *ITokenUpdateCall) Do(f func(context.Context, *storage.Token) error) *ITokenUpdateCall
  • func (c *ITokenUpdateCall) DoAndReturn(f func(context.Context, *storage.Token) error) *ITokenUpdateCall
  • func (c *ITokenUpdateCall) Return(arg0 error) *ITokenUpdateCall
• type ITransferCursorListCall
  • func (c *ITransferCursorListCall) Do(...) *ITransferCursorListCall
  • func (c *ITransferCursorListCall) DoAndReturn(...) *ITransferCursorListCall
  • func (c *ITransferCursorListCall) Return(arg0 []*storage.Transfer, arg1 error) *ITransferCursorListCall
• type ITransferFilterCall
  • func (c *ITransferFilterCall) Do(...) *ITransferFilterCall
  • func (c *ITransferFilterCall) DoAndReturn(...) *ITransferFilterCall
  • func (c *ITransferFilterCall) Return(arg0 []storage.Transfer, arg1 error) *ITransferFilterCall
• type ITransferGetByIDCall
  • func (c *ITransferGetByIDCall) Do(f func(context.Context, uint64) (*storage.Transfer, error)) *ITransferGetByIDCall
  • func (c *ITransferGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Transfer, error)) *ITransferGetByIDCall
  • func (c *ITransferGetByIDCall) Return(arg0 *storage.Transfer, arg1 error) *ITransferGetByIDCall
• type ITransferIsNoRowsCall
  • func (c *ITransferIsNoRowsCall) Do(f func(error) bool) *ITransferIsNoRowsCall
  • func (c *ITransferIsNoRowsCall) DoAndReturn(f func(error) bool) *ITransferIsNoRowsCall
  • func (c *ITransferIsNoRowsCall) Return(arg0 bool) *ITransferIsNoRowsCall
• type ITransferLastIDCall
  • func (c *ITransferLastIDCall) Do(f func(context.Context) (uint64, error)) *ITransferLastIDCall
  • func (c *ITransferLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *ITransferLastIDCall
  • func (c *ITransferLastIDCall) Return(arg0 uint64, arg1 error) *ITransferLastIDCall
• type ITransferListCall
  • func (c *ITransferListCall) Do(...) *ITransferListCall
  • func (c *ITransferListCall) DoAndReturn(...) *ITransferListCall
  • func (c *ITransferListCall) Return(arg0 []*storage.Transfer, arg1 error) *ITransferListCall
• type ITransferSaveCall
  • func (c *ITransferSaveCall) Do(f func(context.Context, *storage.Transfer) error) *ITransferSaveCall
  • func (c *ITransferSaveCall) DoAndReturn(f func(context.Context, *storage.Transfer) error) *ITransferSaveCall
  • func (c *ITransferSaveCall) Return(arg0 error) *ITransferSaveCall
• type ITransferUpdateCall
  • func (c *ITransferUpdateCall) Do(f func(context.Context, *storage.Transfer) error) *ITransferUpdateCall
  • func (c *ITransferUpdateCall) DoAndReturn(f func(context.Context, *storage.Transfer) error) *ITransferUpdateCall
  • func (c *ITransferUpdateCall) Return(arg0 error) *ITransferUpdateCall
• type MockIAddress
  • func NewMockIAddress(ctrl *gomock.Controller) *MockIAddress
  • func (m *MockIAddress) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Address, error)
  • func (m *MockIAddress) EXPECT() *MockIAddressMockRecorder
  • func (m *MockIAddress) Filter(ctx context.Context, flt []storage.AddressFilter, opts ...storage.FilterOption) ([]storage.Address, error)
  • func (m *MockIAddress) GetAddresses(ctx context.Context, ids ...uint64) ([]storage.Address, error)
  • func (m *MockIAddress) GetByHash(ctx context.Context, hash []byte) (storage.Address, error)
  • func (m *MockIAddress) GetByHashes(ctx context.Context, hash [][]byte) ([]storage.Address, error)
  • func (m *MockIAddress) GetByID(ctx context.Context, id uint64) (*storage.Address, error)
  • func (m *MockIAddress) IsNoRows(err error) bool
  • func (m *MockIAddress) LastID(ctx context.Context) (uint64, error)
  • func (m *MockIAddress) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Address, error)
  • func (m_2 *MockIAddress) Save(ctx context.Context, m *storage.Address) error
  • func (m_2 *MockIAddress) Update(ctx context.Context, m *storage.Address) error
• type MockIAddressMockRecorder
  • func (mr *MockIAddressMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IAddressCursorListCall
  • func (mr *MockIAddressMockRecorder) Filter(ctx, flt any, opts ...any) *IAddressFilterCall
  • func (mr *MockIAddressMockRecorder) GetAddresses(ctx any, ids ...any) *IAddressGetAddressesCall
  • func (mr *MockIAddressMockRecorder) GetByHash(ctx, hash any) *IAddressGetByHashCall
  • func (mr *MockIAddressMockRecorder) GetByHashes(ctx, hash any) *IAddressGetByHashesCall
  • func (mr *MockIAddressMockRecorder) GetByID(ctx, id any) *IAddressGetByIDCall
  • func (mr *MockIAddressMockRecorder) IsNoRows(err any) *IAddressIsNoRowsCall
  • func (mr *MockIAddressMockRecorder) LastID(ctx any) *IAddressLastIDCall
  • func (mr *MockIAddressMockRecorder) List(ctx, limit, offset, order any) *IAddressListCall
  • func (mr *MockIAddressMockRecorder) Save(ctx, m any) *IAddressSaveCall
  • func (mr *MockIAddressMockRecorder) Update(ctx, m any) *IAddressUpdateCall
• type MockIBlock
  • func NewMockIBlock(ctrl *gomock.Controller) *MockIBlock
  • func (m *MockIBlock) ByHeight(ctx context.Context, height uint64) (storage.Block, error)
  • func (m *MockIBlock) ByStatus(ctx context.Context, status storage.Status, limit, offset uint64, ...) ([]storage.Block, error)
  • func (m *MockIBlock) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Block, error)
  • func (m *MockIBlock) EXPECT() *MockIBlockMockRecorder
  • func (m *MockIBlock) GetByID(ctx context.Context, id uint64) (*storage.Block, error)
  • func (m *MockIBlock) IsNoRows(err error) bool
  • func (m *MockIBlock) Last(ctx context.Context) (storage.Block, error)
  • func (m *MockIBlock) LastID(ctx context.Context) (uint64, error)
  • func (m *MockIBlock) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Block, error)
  • func (m_2 *MockIBlock) Save(ctx context.Context, m *storage.Block) error
  • func (m_2 *MockIBlock) Update(ctx context.Context, m *storage.Block) error
• type MockIBlockMockRecorder
  • func (mr *MockIBlockMockRecorder) ByHeight(ctx, height any) *IBlockByHeightCall
  • func (mr *MockIBlockMockRecorder) ByStatus(ctx, status, limit, offset, order any) *IBlockByStatusCall
  • func (mr *MockIBlockMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IBlockCursorListCall
  • func (mr *MockIBlockMockRecorder) GetByID(ctx, id any) *IBlockGetByIDCall
  • func (mr *MockIBlockMockRecorder) IsNoRows(err any) *IBlockIsNoRowsCall
  • func (mr *MockIBlockMockRecorder) Last(ctx any) *IBlockLastCall
  • func (mr *MockIBlockMockRecorder) LastID(ctx any) *IBlockLastIDCall
  • func (mr *MockIBlockMockRecorder) List(ctx, limit, offset, order any) *IBlockListCall
  • func (mr *MockIBlockMockRecorder) Save(ctx, m any) *IBlockSaveCall
  • func (mr *MockIBlockMockRecorder) Update(ctx, m any) *IBlockUpdateCall
• type MockIClass
  • func NewMockIClass(ctrl *gomock.Controller) *MockIClass
  • func (m *MockIClass) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Class, error)
  • func (m *MockIClass) EXPECT() *MockIClassMockRecorder
  • func (m *MockIClass) GetByHash(ctx context.Context, hash []byte) (storage.Class, error)
  • func (m *MockIClass) GetByID(ctx context.Context, id uint64) (*storage.Class, error)
  • func (m *MockIClass) GetUnresolved(ctx context.Context) ([]storage.Class, error)
  • func (m *MockIClass) IsNoRows(err error) bool
  • func (m *MockIClass) LastID(ctx context.Context) (uint64, error)
  • func (m *MockIClass) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Class, error)
  • func (m_2 *MockIClass) Save(ctx context.Context, m *storage.Class) error
  • func (m_2 *MockIClass) Update(ctx context.Context, m *storage.Class) error
• type MockIClassMockRecorder
  • func (mr *MockIClassMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IClassCursorListCall
  • func (mr *MockIClassMockRecorder) GetByHash(ctx, hash any) *IClassGetByHashCall
  • func (mr *MockIClassMockRecorder) GetByID(ctx, id any) *IClassGetByIDCall
  • func (mr *MockIClassMockRecorder) GetUnresolved(ctx any) *IClassGetUnresolvedCall
  • func (mr *MockIClassMockRecorder) IsNoRows(err any) *IClassIsNoRowsCall
  • func (mr *MockIClassMockRecorder) LastID(ctx any) *IClassLastIDCall
  • func (mr *MockIClassMockRecorder) List(ctx, limit, offset, order any) *IClassListCall
  • func (mr *MockIClassMockRecorder) Save(ctx, m any) *IClassSaveCall
  • func (mr *MockIClassMockRecorder) Update(ctx, m any) *IClassUpdateCall
• type MockIClassReplace
  • func NewMockIClassReplace(ctrl *gomock.Controller) *MockIClassReplace
  • func (m *MockIClassReplace) ByHeight(ctx context.Context, height uint64) ([]storage.ClassReplace, error)
  • func (m *MockIClassReplace) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.ClassReplace, error)
  • func (m *MockIClassReplace) EXPECT() *MockIClassReplaceMockRecorder
  • func (m *MockIClassReplace) GetByID(ctx context.Context, id uint64) (*storage.ClassReplace, error)
  • func (m *MockIClassReplace) IsNoRows(err error) bool
  • func (m *MockIClassReplace) LastID(ctx context.Context) (uint64, error)
  • func (m *MockIClassReplace) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.ClassReplace, error)
  • func (m_2 *MockIClassReplace) Save(ctx context.Context, m *storage.ClassReplace) error
  • func (m_2 *MockIClassReplace) Update(ctx context.Context, m *storage.ClassReplace) error
• type MockIClassReplaceMockRecorder
  • func (mr *MockIClassReplaceMockRecorder) ByHeight(ctx, height any) *IClassReplaceByHeightCall
  • func (mr *MockIClassReplaceMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IClassReplaceCursorListCall
  • func (mr *MockIClassReplaceMockRecorder) GetByID(ctx, id any) *IClassReplaceGetByIDCall
  • func (mr *MockIClassReplaceMockRecorder) IsNoRows(err any) *IClassReplaceIsNoRowsCall
  • func (mr *MockIClassReplaceMockRecorder) LastID(ctx any) *IClassReplaceLastIDCall
  • func (mr *MockIClassReplaceMockRecorder) List(ctx, limit, offset, order any) *IClassReplaceListCall
  • func (mr *MockIClassReplaceMockRecorder) Save(ctx, m any) *IClassReplaceSaveCall
  • func (mr *MockIClassReplaceMockRecorder) Update(ctx, m any) *IClassReplaceUpdateCall
• type MockIDeclare
  • func NewMockIDeclare(ctrl *gomock.Controller) *MockIDeclare
  • func (m *MockIDeclare) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Declare, error)
  • func (m *MockIDeclare) EXPECT() *MockIDeclareMockRecorder
  • func (m *MockIDeclare) Filter(ctx context.Context, flt []storage.DeclareFilter, opts ...storage.FilterOption) ([]storage.Declare, error)
  • func (m *MockIDeclare) GetByID(ctx context.Context, id uint64) (*storage.Declare, error)
  • func (m *MockIDeclare) IsNoRows(err error) bool
  • func (m *MockIDeclare) LastID(ctx context.Context) (uint64, error)
  • func (m *MockIDeclare) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Declare, error)
  • func (m_2 *MockIDeclare) Save(ctx context.Context, m *storage.Declare) error
  • func (m_2 *MockIDeclare) Update(ctx context.Context, m *storage.Declare) error
• type MockIDeclareMockRecorder
  • func (mr *MockIDeclareMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IDeclareCursorListCall
  • func (mr *MockIDeclareMockRecorder) Filter(ctx, flt any, opts ...any) *IDeclareFilterCall
  • func (mr *MockIDeclareMockRecorder) GetByID(ctx, id any) *IDeclareGetByIDCall
  • func (mr *MockIDeclareMockRecorder) IsNoRows(err any) *IDeclareIsNoRowsCall
  • func (mr *MockIDeclareMockRecorder) LastID(ctx any) *IDeclareLastIDCall
  • func (mr *MockIDeclareMockRecorder) List(ctx, limit, offset, order any) *IDeclareListCall
  • func (mr *MockIDeclareMockRecorder) Save(ctx, m any) *IDeclareSaveCall
  • func (mr *MockIDeclareMockRecorder) Update(ctx, m any) *IDeclareUpdateCall
• type MockIDeploy
  • func NewMockIDeploy(ctrl *gomock.Controller) *MockIDeploy
  • func (m *MockIDeploy) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Deploy, error)
  • func (m *MockIDeploy) EXPECT() *MockIDeployMockRecorder
  • func (m *MockIDeploy) Filter(ctx context.Context, flt []storage.DeployFilter, opts ...storage.FilterOption) ([]storage.Deploy, error)
  • func (m *MockIDeploy) GetByID(ctx context.Context, id uint64) (*storage.Deploy, error)
  • func (m *MockIDeploy) IsNoRows(err error) bool
  • func (m *MockIDeploy) LastID(ctx context.Context) (uint64, error)
  • func (m *MockIDeploy) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Deploy, error)
  • func (m_2 *MockIDeploy) Save(ctx context.Context, m *storage.Deploy) error
  • func (m_2 *MockIDeploy) Update(ctx context.Context, m *storage.Deploy) error
• type MockIDeployAccount
  • func NewMockIDeployAccount(ctrl *gomock.Controller) *MockIDeployAccount
  • func (m *MockIDeployAccount) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.DeployAccount, error)
  • func (m *MockIDeployAccount) EXPECT() *MockIDeployAccountMockRecorder
  • func (m *MockIDeployAccount) Filter(ctx context.Context, flt []storage.DeployAccountFilter, ...) ([]storage.DeployAccount, error)
  • func (m *MockIDeployAccount) GetByID(ctx context.Context, id uint64) (*storage.DeployAccount, error)
  • func (m *MockIDeployAccount) IsNoRows(err error) bool
  • func (m *MockIDeployAccount) LastID(ctx context.Context) (uint64, error)
  • func (m *MockIDeployAccount) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.DeployAccount, error)
  • func (m_2 *MockIDeployAccount) Save(ctx context.Context, m *storage.DeployAccount) error
  • func (m_2 *MockIDeployAccount) Update(ctx context.Context, m *storage.DeployAccount) error
• type MockIDeployAccountMockRecorder
  • func (mr *MockIDeployAccountMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IDeployAccountCursorListCall
  • func (mr *MockIDeployAccountMockRecorder) Filter(ctx, flt any, opts ...any) *IDeployAccountFilterCall
  • func (mr *MockIDeployAccountMockRecorder) GetByID(ctx, id any) *IDeployAccountGetByIDCall
  • func (mr *MockIDeployAccountMockRecorder) IsNoRows(err any) *IDeployAccountIsNoRowsCall
  • func (mr *MockIDeployAccountMockRecorder) LastID(ctx any) *IDeployAccountLastIDCall
  • func (mr *MockIDeployAccountMockRecorder) List(ctx, limit, offset, order any) *IDeployAccountListCall
  • func (mr *MockIDeployAccountMockRecorder) Save(ctx, m any) *IDeployAccountSaveCall
  • func (mr *MockIDeployAccountMockRecorder) Update(ctx, m any) *IDeployAccountUpdateCall
• type MockIDeployMockRecorder
  • func (mr *MockIDeployMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IDeployCursorListCall
  • func (mr *MockIDeployMockRecorder) Filter(ctx, flt any, opts ...any) *IDeployFilterCall
  • func (mr *MockIDeployMockRecorder) GetByID(ctx, id any) *IDeployGetByIDCall
  • func (mr *MockIDeployMockRecorder) IsNoRows(err any) *IDeployIsNoRowsCall
  • func (mr *MockIDeployMockRecorder) LastID(ctx any) *IDeployLastIDCall
  • func (mr *MockIDeployMockRecorder) List(ctx, limit, offset, order any) *IDeployListCall
  • func (mr *MockIDeployMockRecorder) Save(ctx, m any) *IDeploySaveCall
  • func (mr *MockIDeployMockRecorder) Update(ctx, m any) *IDeployUpdateCall
• type MockIEvent
  • func NewMockIEvent(ctrl *gomock.Controller) *MockIEvent
  • func (m *MockIEvent) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Event, error)
  • func (m *MockIEvent) EXPECT() *MockIEventMockRecorder
  • func (m *MockIEvent) Filter(ctx context.Context, flt []storage.EventFilter, opts ...storage.FilterOption) ([]storage.Event, error)
  • func (m *MockIEvent) GetByID(ctx context.Context, id uint64) (*storage.Event, error)
  • func (m *MockIEvent) IsNoRows(err error) bool
  • func (m *MockIEvent) LastID(ctx context.Context) (uint64, error)
  • func (m *MockIEvent) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Event, error)
  • func (m_2 *MockIEvent) Save(ctx context.Context, m *storage.Event) error
  • func (m_2 *MockIEvent) Update(ctx context.Context, m *storage.Event) error
• type MockIEventMockRecorder
  • func (mr *MockIEventMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IEventCursorListCall
  • func (mr *MockIEventMockRecorder) Filter(ctx, flt any, opts ...any) *IEventFilterCall
  • func (mr *MockIEventMockRecorder) GetByID(ctx, id any) *IEventGetByIDCall
  • func (mr *MockIEventMockRecorder) IsNoRows(err any) *IEventIsNoRowsCall
  • func (mr *MockIEventMockRecorder) LastID(ctx any) *IEventLastIDCall
  • func (mr *MockIEventMockRecorder) List(ctx, limit, offset, order any) *IEventListCall
  • func (mr *MockIEventMockRecorder) Save(ctx, m any) *IEventSaveCall
  • func (mr *MockIEventMockRecorder) Update(ctx, m any) *IEventUpdateCall
• type MockIFee
  • func NewMockIFee(ctrl *gomock.Controller) *MockIFee
  • func (m *MockIFee) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Fee, error)
  • func (m *MockIFee) EXPECT() *MockIFeeMockRecorder
  • func (m *MockIFee) Filter(ctx context.Context, flt []storage.FeeFilter, opts ...storage.FilterOption) ([]storage.Fee, error)
  • func (m *MockIFee) GetByID(ctx context.Context, id uint64) (*storage.Fee, error)
  • func (m *MockIFee) IsNoRows(err error) bool
  • func (m *MockIFee) LastID(ctx context.Context) (uint64, error)
  • func (m *MockIFee) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Fee, error)
  • func (m_2 *MockIFee) Save(ctx context.Context, m *storage.Fee) error
  • func (m_2 *MockIFee) Update(ctx context.Context, m *storage.Fee) error
• type MockIFeeMockRecorder
  • func (mr *MockIFeeMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IFeeCursorListCall
  • func (mr *MockIFeeMockRecorder) Filter(ctx, flt any, opts ...any) *IFeeFilterCall
  • func (mr *MockIFeeMockRecorder) GetByID(ctx, id any) *IFeeGetByIDCall
  • func (mr *MockIFeeMockRecorder) IsNoRows(err any) *IFeeIsNoRowsCall
  • func (mr *MockIFeeMockRecorder) LastID(ctx any) *IFeeLastIDCall
  • func (mr *MockIFeeMockRecorder) List(ctx, limit, offset, order any) *IFeeListCall
  • func (mr *MockIFeeMockRecorder) Save(ctx, m any) *IFeeSaveCall
  • func (mr *MockIFeeMockRecorder) Update(ctx, m any) *IFeeUpdateCall
• type MockIInternal
  • func NewMockIInternal(ctrl *gomock.Controller) *MockIInternal
  • func (m *MockIInternal) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Internal, error)
  • func (m *MockIInternal) EXPECT() *MockIInternalMockRecorder
  • func (m *MockIInternal) Filter(ctx context.Context, flt []storage.InternalFilter, ...) ([]storage.Internal, error)
  • func (m *MockIInternal) GetByID(ctx context.Context, id uint64) (*storage.Internal, error)
  • func (m *MockIInternal) IsNoRows(err error) bool
  • func (m *MockIInternal) LastID(ctx context.Context) (uint64, error)
  • func (m *MockIInternal) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Internal, error)
  • func (m_2 *MockIInternal) Save(ctx context.Context, m *storage.Internal) error
  • func (m_2 *MockIInternal) Update(ctx context.Context, m *storage.Internal) error
• type MockIInternalMockRecorder
  • func (mr *MockIInternalMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IInternalCursorListCall
  • func (mr *MockIInternalMockRecorder) Filter(ctx, flt any, opts ...any) *IInternalFilterCall
  • func (mr *MockIInternalMockRecorder) GetByID(ctx, id any) *IInternalGetByIDCall
  • func (mr *MockIInternalMockRecorder) IsNoRows(err any) *IInternalIsNoRowsCall
  • func (mr *MockIInternalMockRecorder) LastID(ctx any) *IInternalLastIDCall
  • func (mr *MockIInternalMockRecorder) List(ctx, limit, offset, order any) *IInternalListCall
  • func (mr *MockIInternalMockRecorder) Save(ctx, m any) *IInternalSaveCall
  • func (mr *MockIInternalMockRecorder) Update(ctx, m any) *IInternalUpdateCall
• type MockIInvoke
  • func NewMockIInvoke(ctrl *gomock.Controller) *MockIInvoke
  • func (m *MockIInvoke) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Invoke, error)
  • func (m *MockIInvoke) EXPECT() *MockIInvokeMockRecorder
  • func (m *MockIInvoke) Filter(ctx context.Context, flt []storage.InvokeFilter, opts ...storage.FilterOption) ([]storage.Invoke, error)
  • func (m *MockIInvoke) GetByID(ctx context.Context, id uint64) (*storage.Invoke, error)
  • func (m *MockIInvoke) HashByHeight(ctx context.Context, height uint64) ([]byte, error)
  • func (m *MockIInvoke) IsNoRows(err error) bool
  • func (m *MockIInvoke) LastID(ctx context.Context) (uint64, error)
  • func (m *MockIInvoke) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Invoke, error)
  • func (m_2 *MockIInvoke) Save(ctx context.Context, m *storage.Invoke) error
  • func (m_2 *MockIInvoke) Update(ctx context.Context, m *storage.Invoke) error
• type MockIInvokeMockRecorder
  • func (mr *MockIInvokeMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IInvokeCursorListCall
  • func (mr *MockIInvokeMockRecorder) Filter(ctx, flt any, opts ...any) *IInvokeFilterCall
  • func (mr *MockIInvokeMockRecorder) GetByID(ctx, id any) *IInvokeGetByIDCall
  • func (mr *MockIInvokeMockRecorder) HashByHeight(ctx, height any) *IInvokeHashByHeightCall
  • func (mr *MockIInvokeMockRecorder) IsNoRows(err any) *IInvokeIsNoRowsCall
  • func (mr *MockIInvokeMockRecorder) LastID(ctx any) *IInvokeLastIDCall
  • func (mr *MockIInvokeMockRecorder) List(ctx, limit, offset, order any) *IInvokeListCall
  • func (mr *MockIInvokeMockRecorder) Save(ctx, m any) *IInvokeSaveCall
  • func (mr *MockIInvokeMockRecorder) Update(ctx, m any) *IInvokeUpdateCall
• type MockIL1Handler
  • func NewMockIL1Handler(ctrl *gomock.Controller) *MockIL1Handler
  • func (m *MockIL1Handler) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.L1Handler, error)
  • func (m *MockIL1Handler) EXPECT() *MockIL1HandlerMockRecorder
  • func (m *MockIL1Handler) Filter(ctx context.Context, flt []storage.L1HandlerFilter, ...) ([]storage.L1Handler, error)
  • func (m *MockIL1Handler) GetByID(ctx context.Context, id uint64) (*storage.L1Handler, error)
  • func (m *MockIL1Handler) IsNoRows(err error) bool
  • func (m *MockIL1Handler) LastID(ctx context.Context) (uint64, error)
  • func (m *MockIL1Handler) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.L1Handler, error)
  • func (m_2 *MockIL1Handler) Save(ctx context.Context, m *storage.L1Handler) error
  • func (m_2 *MockIL1Handler) Update(ctx context.Context, m *storage.L1Handler) error
• type MockIL1HandlerMockRecorder
  • func (mr *MockIL1HandlerMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IL1HandlerCursorListCall
  • func (mr *MockIL1HandlerMockRecorder) Filter(ctx, flt any, opts ...any) *IL1HandlerFilterCall
  • func (mr *MockIL1HandlerMockRecorder) GetByID(ctx, id any) *IL1HandlerGetByIDCall
  • func (mr *MockIL1HandlerMockRecorder) IsNoRows(err any) *IL1HandlerIsNoRowsCall
  • func (mr *MockIL1HandlerMockRecorder) LastID(ctx any) *IL1HandlerLastIDCall
  • func (mr *MockIL1HandlerMockRecorder) List(ctx, limit, offset, order any) *IL1HandlerListCall
  • func (mr *MockIL1HandlerMockRecorder) Save(ctx, m any) *IL1HandlerSaveCall
  • func (mr *MockIL1HandlerMockRecorder) Update(ctx, m any) *IL1HandlerUpdateCall
• type MockIMessage
  • func NewMockIMessage(ctrl *gomock.Controller) *MockIMessage
  • func (m *MockIMessage) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Message, error)
  • func (m *MockIMessage) EXPECT() *MockIMessageMockRecorder
  • func (m *MockIMessage) Filter(ctx context.Context, flt []storage.MessageFilter, opts ...storage.FilterOption) ([]storage.Message, error)
  • func (m *MockIMessage) GetByID(ctx context.Context, id uint64) (*storage.Message, error)
  • func (m *MockIMessage) IsNoRows(err error) bool
  • func (m *MockIMessage) LastID(ctx context.Context) (uint64, error)
  • func (m *MockIMessage) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Message, error)
  • func (m_2 *MockIMessage) Save(ctx context.Context, m *storage.Message) error
  • func (m_2 *MockIMessage) Update(ctx context.Context, m *storage.Message) error
• type MockIMessageMockRecorder
  • func (mr *MockIMessageMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IMessageCursorListCall
  • func (mr *MockIMessageMockRecorder) Filter(ctx, flt any, opts ...any) *IMessageFilterCall
  • func (mr *MockIMessageMockRecorder) GetByID(ctx, id any) *IMessageGetByIDCall
  • func (mr *MockIMessageMockRecorder) IsNoRows(err any) *IMessageIsNoRowsCall
  • func (mr *MockIMessageMockRecorder) LastID(ctx any) *IMessageLastIDCall
  • func (mr *MockIMessageMockRecorder) List(ctx, limit, offset, order any) *IMessageListCall
  • func (mr *MockIMessageMockRecorder) Save(ctx, m any) *IMessageSaveCall
  • func (mr *MockIMessageMockRecorder) Update(ctx, m any) *IMessageUpdateCall
• type MockIProxy
  • func NewMockIProxy(ctrl *gomock.Controller) *MockIProxy
  • func (m *MockIProxy) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Proxy, error)
  • func (m *MockIProxy) EXPECT() *MockIProxyMockRecorder
  • func (m *MockIProxy) GetByHash(ctx context.Context, address, selector []byte) (storage.Proxy, error)
  • func (m *MockIProxy) GetByID(ctx context.Context, id uint64) (*storage.Proxy, error)
  • func (m *MockIProxy) IsNoRows(err error) bool
  • func (m *MockIProxy) LastID(ctx context.Context) (uint64, error)
  • func (m *MockIProxy) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Proxy, error)
  • func (m_2 *MockIProxy) Save(ctx context.Context, m *storage.Proxy) error
  • func (m_2 *MockIProxy) Update(ctx context.Context, m *storage.Proxy) error
• type MockIProxyMockRecorder
  • func (mr *MockIProxyMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IProxyCursorListCall
  • func (mr *MockIProxyMockRecorder) GetByHash(ctx, address, selector any) *IProxyGetByHashCall
  • func (mr *MockIProxyMockRecorder) GetByID(ctx, id any) *IProxyGetByIDCall
  • func (mr *MockIProxyMockRecorder) IsNoRows(err any) *IProxyIsNoRowsCall
  • func (mr *MockIProxyMockRecorder) LastID(ctx any) *IProxyLastIDCall
  • func (mr *MockIProxyMockRecorder) List(ctx, limit, offset, order any) *IProxyListCall
  • func (mr *MockIProxyMockRecorder) Save(ctx, m any) *IProxySaveCall
  • func (mr *MockIProxyMockRecorder) Update(ctx, m any) *IProxyUpdateCall
• type MockIProxyUpgrade
  • func NewMockIProxyUpgrade(ctrl *gomock.Controller) *MockIProxyUpgrade
  • func (m *MockIProxyUpgrade) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.ProxyUpgrade, error)
  • func (m *MockIProxyUpgrade) EXPECT() *MockIProxyUpgradeMockRecorder
  • func (m *MockIProxyUpgrade) GetByID(ctx context.Context, id uint64) (*storage.ProxyUpgrade, error)
  • func (m *MockIProxyUpgrade) IsNoRows(err error) bool
  • func (m *MockIProxyUpgrade) LastBefore(ctx context.Context, hash, selector []byte, height uint64) (storage.ProxyUpgrade, error)
  • func (m *MockIProxyUpgrade) LastID(ctx context.Context) (uint64, error)
  • func (m *MockIProxyUpgrade) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.ProxyUpgrade, error)
  • func (m *MockIProxyUpgrade) ListWithHeight(ctx context.Context, height uint64, limit, offset int) ([]storage.ProxyUpgrade, error)
  • func (m_2 *MockIProxyUpgrade) Save(ctx context.Context, m *storage.ProxyUpgrade) error
  • func (m_2 *MockIProxyUpgrade) Update(ctx context.Context, m *storage.ProxyUpgrade) error
• type MockIProxyUpgradeMockRecorder
  • func (mr *MockIProxyUpgradeMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IProxyUpgradeCursorListCall
  • func (mr *MockIProxyUpgradeMockRecorder) GetByID(ctx, id any) *IProxyUpgradeGetByIDCall
  • func (mr *MockIProxyUpgradeMockRecorder) IsNoRows(err any) *IProxyUpgradeIsNoRowsCall
  • func (mr *MockIProxyUpgradeMockRecorder) LastBefore(ctx, hash, selector, height any) *IProxyUpgradeLastBeforeCall
  • func (mr *MockIProxyUpgradeMockRecorder) LastID(ctx any) *IProxyUpgradeLastIDCall
  • func (mr *MockIProxyUpgradeMockRecorder) List(ctx, limit, offset, order any) *IProxyUpgradeListCall
  • func (mr *MockIProxyUpgradeMockRecorder) ListWithHeight(ctx, height, limit, offset any) *IProxyUpgradeListWithHeightCall
  • func (mr *MockIProxyUpgradeMockRecorder) Save(ctx, m any) *IProxyUpgradeSaveCall
  • func (mr *MockIProxyUpgradeMockRecorder) Update(ctx, m any) *IProxyUpgradeUpdateCall
• type MockIState
  • func NewMockIState(ctrl *gomock.Controller) *MockIState
  • func (m *MockIState) ByName(ctx context.Context, name string) (storage.State, error)
  • func (m *MockIState) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.State, error)
  • func (m *MockIState) EXPECT() *MockIStateMockRecorder
  • func (m *MockIState) GetByID(ctx context.Context, id uint64) (*storage.State, error)
  • func (m *MockIState) IsNoRows(err error) bool
  • func (m *MockIState) LastID(ctx context.Context) (uint64, error)
  • func (m *MockIState) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.State, error)
  • func (m_2 *MockIState) Save(ctx context.Context, m *storage.State) error
  • func (m_2 *MockIState) Update(ctx context.Context, m *storage.State) error
• type MockIStateMockRecorder
  • func (mr *MockIStateMockRecorder) ByName(ctx, name any) *IStateByNameCall
  • func (mr *MockIStateMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IStateCursorListCall
  • func (mr *MockIStateMockRecorder) GetByID(ctx, id any) *IStateGetByIDCall
  • func (mr *MockIStateMockRecorder) IsNoRows(err any) *IStateIsNoRowsCall
  • func (mr *MockIStateMockRecorder) LastID(ctx any) *IStateLastIDCall
  • func (mr *MockIStateMockRecorder) List(ctx, limit, offset, order any) *IStateListCall
  • func (mr *MockIStateMockRecorder) Save(ctx, m any) *IStateSaveCall
  • func (mr *MockIStateMockRecorder) Update(ctx, m any) *IStateUpdateCall
• type MockIStorageDiff
  • func NewMockIStorageDiff(ctrl *gomock.Controller) *MockIStorageDiff
  • func (m *MockIStorageDiff) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.StorageDiff, error)
  • func (m *MockIStorageDiff) EXPECT() *MockIStorageDiffMockRecorder
  • func (m *MockIStorageDiff) Filter(ctx context.Context, flt []storage.StorageDiffFilter, ...) ([]storage.StorageDiff, error)
  • func (m *MockIStorageDiff) GetByID(ctx context.Context, id uint64) (*storage.StorageDiff, error)
  • func (m *MockIStorageDiff) GetOnBlock(ctx context.Context, height, contractId uint64, key []byte) (storage.StorageDiff, error)
  • func (m *MockIStorageDiff) IsNoRows(err error) bool
  • func (m *MockIStorageDiff) LastID(ctx context.Context) (uint64, error)
  • func (m *MockIStorageDiff) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.StorageDiff, error)
  • func (m_2 *MockIStorageDiff) Save(ctx context.Context, m *storage.StorageDiff) error
  • func (m_2 *MockIStorageDiff) Update(ctx context.Context, m *storage.StorageDiff) error
• type MockIStorageDiffMockRecorder
  • func (mr *MockIStorageDiffMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IStorageDiffCursorListCall
  • func (mr *MockIStorageDiffMockRecorder) Filter(ctx, flt any, opts ...any) *IStorageDiffFilterCall
  • func (mr *MockIStorageDiffMockRecorder) GetByID(ctx, id any) *IStorageDiffGetByIDCall
  • func (mr *MockIStorageDiffMockRecorder) GetOnBlock(ctx, height, contractId, key any) *IStorageDiffGetOnBlockCall
  • func (mr *MockIStorageDiffMockRecorder) IsNoRows(err any) *IStorageDiffIsNoRowsCall
  • func (mr *MockIStorageDiffMockRecorder) LastID(ctx any) *IStorageDiffLastIDCall
  • func (mr *MockIStorageDiffMockRecorder) List(ctx, limit, offset, order any) *IStorageDiffListCall
  • func (mr *MockIStorageDiffMockRecorder) Save(ctx, m any) *IStorageDiffSaveCall
  • func (mr *MockIStorageDiffMockRecorder) Update(ctx, m any) *IStorageDiffUpdateCall
• type MockIToken
  • func NewMockIToken(ctrl *gomock.Controller) *MockIToken
  • func (m *MockIToken) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Token, error)
  • func (m *MockIToken) EXPECT() *MockITokenMockRecorder
  • func (m *MockIToken) Filter(ctx context.Context, flt []storage.TokenFilter, opts ...storage.FilterOption) ([]storage.Token, error)
  • func (m *MockIToken) Find(ctx context.Context, contractId uint64, tokenId string) (storage.Token, error)
  • func (m *MockIToken) GetByID(ctx context.Context, id uint64) (*storage.Token, error)
  • func (m *MockIToken) IsNoRows(err error) bool
  • func (m *MockIToken) LastID(ctx context.Context) (uint64, error)
  • func (m *MockIToken) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Token, error)
  • func (m *MockIToken) ListByType(ctx context.Context, typ storage.TokenType, limit, offset uint64, ...) ([]storage.Token, error)
  • func (m_2 *MockIToken) Save(ctx context.Context, m *storage.Token) error
  • func (m_2 *MockIToken) Update(ctx context.Context, m *storage.Token) error
• type MockITokenBalance
  • func NewMockITokenBalance(ctrl *gomock.Controller) *MockITokenBalance
  • func (m *MockITokenBalance) Balances(ctx context.Context, contractId uint64, tokenId int64, limit, offset int) ([]storage.TokenBalance, error)
  • func (m *MockITokenBalance) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.TokenBalance, error)
  • func (m *MockITokenBalance) EXPECT() *MockITokenBalanceMockRecorder
  • func (m *MockITokenBalance) Filter(ctx context.Context, flt []storage.TokenBalanceFilter, ...) ([]storage.TokenBalance, error)
  • func (m *MockITokenBalance) GetByID(ctx context.Context, id uint64) (*storage.TokenBalance, error)
  • func (m *MockITokenBalance) IsNoRows(err error) bool
  • func (m *MockITokenBalance) LastID(ctx context.Context) (uint64, error)
  • func (m *MockITokenBalance) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.TokenBalance, error)
  • func (m_2 *MockITokenBalance) Save(ctx context.Context, m *storage.TokenBalance) error
  • func (m_2 *MockITokenBalance) Update(ctx context.Context, m *storage.TokenBalance) error
• type MockITokenBalanceMockRecorder
  • func (mr *MockITokenBalanceMockRecorder) Balances(ctx, contractId, tokenId, limit, offset any) *ITokenBalanceBalancesCall
  • func (mr *MockITokenBalanceMockRecorder) CursorList(ctx, id, limit, order, cmp any) *ITokenBalanceCursorListCall
  • func (mr *MockITokenBalanceMockRecorder) Filter(ctx, flt any, opts ...any) *ITokenBalanceFilterCall
  • func (mr *MockITokenBalanceMockRecorder) GetByID(ctx, id any) *ITokenBalanceGetByIDCall
  • func (mr *MockITokenBalanceMockRecorder) IsNoRows(err any) *ITokenBalanceIsNoRowsCall
  • func (mr *MockITokenBalanceMockRecorder) LastID(ctx any) *ITokenBalanceLastIDCall
  • func (mr *MockITokenBalanceMockRecorder) List(ctx, limit, offset, order any) *ITokenBalanceListCall
  • func (mr *MockITokenBalanceMockRecorder) Save(ctx, m any) *ITokenBalanceSaveCall
  • func (mr *MockITokenBalanceMockRecorder) Update(ctx, m any) *ITokenBalanceUpdateCall
• type MockITokenMockRecorder
  • func (mr *MockITokenMockRecorder) CursorList(ctx, id, limit, order, cmp any) *ITokenCursorListCall
  • func (mr *MockITokenMockRecorder) Filter(ctx, flt any, opts ...any) *ITokenFilterCall
  • func (mr *MockITokenMockRecorder) Find(ctx, contractId, tokenId any) *ITokenFindCall
  • func (mr *MockITokenMockRecorder) GetByID(ctx, id any) *ITokenGetByIDCall
  • func (mr *MockITokenMockRecorder) IsNoRows(err any) *ITokenIsNoRowsCall
  • func (mr *MockITokenMockRecorder) LastID(ctx any) *ITokenLastIDCall
  • func (mr *MockITokenMockRecorder) List(ctx, limit, offset, order any) *ITokenListCall
  • func (mr *MockITokenMockRecorder) ListByType(ctx, typ, limit, offset, order any) *ITokenListByTypeCall
  • func (mr *MockITokenMockRecorder) Save(ctx, m any) *ITokenSaveCall
  • func (mr *MockITokenMockRecorder) Update(ctx, m any) *ITokenUpdateCall
• type MockITransfer
  • func NewMockITransfer(ctrl *gomock.Controller) *MockITransfer
  • func (m *MockITransfer) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, ...) ([]*storage.Transfer, error)
  • func (m *MockITransfer) EXPECT() *MockITransferMockRecorder
  • func (m *MockITransfer) Filter(ctx context.Context, flt []storage.TransferFilter, ...) ([]storage.Transfer, error)
  • func (m *MockITransfer) GetByID(ctx context.Context, id uint64) (*storage.Transfer, error)
  • func (m *MockITransfer) IsNoRows(err error) bool
  • func (m *MockITransfer) LastID(ctx context.Context) (uint64, error)
  • func (m *MockITransfer) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Transfer, error)
  • func (m_2 *MockITransfer) Save(ctx context.Context, m *storage.Transfer) error
  • func (m_2 *MockITransfer) Update(ctx context.Context, m *storage.Transfer) error
• type MockITransferMockRecorder
  • func (mr *MockITransferMockRecorder) CursorList(ctx, id, limit, order, cmp any) *ITransferCursorListCall
  • func (mr *MockITransferMockRecorder) Filter(ctx, flt any, opts ...any) *ITransferFilterCall
  • func (mr *MockITransferMockRecorder) GetByID(ctx, id any) *ITransferGetByIDCall
  • func (mr *MockITransferMockRecorder) IsNoRows(err any) *ITransferIsNoRowsCall
  • func (mr *MockITransferMockRecorder) LastID(ctx any) *ITransferLastIDCall
  • func (mr *MockITransferMockRecorder) List(ctx, limit, offset, order any) *ITransferListCall
  • func (mr *MockITransferMockRecorder) Save(ctx, m any) *ITransferSaveCall
  • func (mr *MockITransferMockRecorder) Update(ctx, m any) *ITransferUpdateCall

Types

type IAddressCursorListCall

type IAddressCursorListCall struct {
	*gomock.Call
}

IAddressCursorListCall wrap *gomock.Call

func (*IAddressCursorListCall) Do

func (c *IAddressCursorListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Address, error)) *IAddressCursorListCall

Do rewrite *gomock.Call.Do

func (*IAddressCursorListCall) DoAndReturn

func (c *IAddressCursorListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Address, error)) *IAddressCursorListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IAddressCursorListCall) Return

func (c *IAddressCursorListCall) Return(arg0 []*storage.Address, arg1 error) *IAddressCursorListCall

Return rewrite *gomock.Call.Return

type IAddressFilterCall

type IAddressFilterCall struct {
	*gomock.Call
}

IAddressFilterCall wrap *gomock.Call

func (*IAddressFilterCall) Do

func (c *IAddressFilterCall) Do(f func(context.Context, []storage.AddressFilter, ...storage.FilterOption) ([]storage.Address, error)) *IAddressFilterCall

Do rewrite *gomock.Call.Do

func (*IAddressFilterCall) DoAndReturn

func (c *IAddressFilterCall) DoAndReturn(f func(context.Context, []storage.AddressFilter, ...storage.FilterOption) ([]storage.Address, error)) *IAddressFilterCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IAddressFilterCall) Return

func (c *IAddressFilterCall) Return(arg0 []storage.Address, arg1 error) *IAddressFilterCall

Return rewrite *gomock.Call.Return

type IAddressGetAddressesCall

type IAddressGetAddressesCall struct {
	*gomock.Call
}

IAddressGetAddressesCall wrap *gomock.Call

func (*IAddressGetAddressesCall) Do

func (c *IAddressGetAddressesCall) Do(f func(context.Context, ...uint64) ([]storage.Address, error)) *IAddressGetAddressesCall

Do rewrite *gomock.Call.Do

func (*IAddressGetAddressesCall) DoAndReturn

func (c *IAddressGetAddressesCall) DoAndReturn(f func(context.Context, ...uint64) ([]storage.Address, error)) *IAddressGetAddressesCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IAddressGetAddressesCall) Return

func (c *IAddressGetAddressesCall) Return(arg0 []storage.Address, arg1 error) *IAddressGetAddressesCall

Return rewrite *gomock.Call.Return

type IAddressGetByHashCall

type IAddressGetByHashCall struct {
	*gomock.Call
}

IAddressGetByHashCall wrap *gomock.Call

func (*IAddressGetByHashCall) Do

func (c *IAddressGetByHashCall) Do(f func(context.Context, []byte) (storage.Address, error)) *IAddressGetByHashCall

Do rewrite *gomock.Call.Do

func (*IAddressGetByHashCall) DoAndReturn

func (c *IAddressGetByHashCall) DoAndReturn(f func(context.Context, []byte) (storage.Address, error)) *IAddressGetByHashCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IAddressGetByHashCall) Return

func (c *IAddressGetByHashCall) Return(arg0 storage.Address, arg1 error) *IAddressGetByHashCall

Return rewrite *gomock.Call.Return

type IAddressGetByHashesCall

type IAddressGetByHashesCall struct {
	*gomock.Call
}

IAddressGetByHashesCall wrap *gomock.Call

func (*IAddressGetByHashesCall) Do

func (c *IAddressGetByHashesCall) Do(f func(context.Context, [][]byte) ([]storage.Address, error)) *IAddressGetByHashesCall

Do rewrite *gomock.Call.Do

func (*IAddressGetByHashesCall) DoAndReturn

func (c *IAddressGetByHashesCall) DoAndReturn(f func(context.Context, [][]byte) ([]storage.Address, error)) *IAddressGetByHashesCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IAddressGetByHashesCall) Return

func (c *IAddressGetByHashesCall) Return(arg0 []storage.Address, arg1 error) *IAddressGetByHashesCall

Return rewrite *gomock.Call.Return

type IAddressGetByIDCall

type IAddressGetByIDCall struct {
	*gomock.Call
}

IAddressGetByIDCall wrap *gomock.Call

func (*IAddressGetByIDCall) Do

func (c *IAddressGetByIDCall) Do(f func(context.Context, uint64) (*storage.Address, error)) *IAddressGetByIDCall

Do rewrite *gomock.Call.Do

func (*IAddressGetByIDCall) DoAndReturn

func (c *IAddressGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Address, error)) *IAddressGetByIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IAddressGetByIDCall) Return

func (c *IAddressGetByIDCall) Return(arg0 *storage.Address, arg1 error) *IAddressGetByIDCall

Return rewrite *gomock.Call.Return

type IAddressIsNoRowsCall

type IAddressIsNoRowsCall struct {
	*gomock.Call
}

IAddressIsNoRowsCall wrap *gomock.Call

func (*IAddressIsNoRowsCall) Do

func (c *IAddressIsNoRowsCall) Do(f func(error) bool) *IAddressIsNoRowsCall

Do rewrite *gomock.Call.Do

func (*IAddressIsNoRowsCall) DoAndReturn

func (c *IAddressIsNoRowsCall) DoAndReturn(f func(error) bool) *IAddressIsNoRowsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IAddressIsNoRowsCall) Return

func (c *IAddressIsNoRowsCall) Return(arg0 bool) *IAddressIsNoRowsCall

Return rewrite *gomock.Call.Return

type IAddressLastIDCall

type IAddressLastIDCall struct {
	*gomock.Call
}

IAddressLastIDCall wrap *gomock.Call

func (*IAddressLastIDCall) Do

func (c *IAddressLastIDCall) Do(f func(context.Context) (uint64, error)) *IAddressLastIDCall

Do rewrite *gomock.Call.Do

func (*IAddressLastIDCall) DoAndReturn

func (c *IAddressLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IAddressLastIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IAddressLastIDCall) Return

func (c *IAddressLastIDCall) Return(arg0 uint64, arg1 error) *IAddressLastIDCall

Return rewrite *gomock.Call.Return

type IAddressListCall

type IAddressListCall struct {
	*gomock.Call
}

IAddressListCall wrap *gomock.Call

func (*IAddressListCall) Do

func (c *IAddressListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Address, error)) *IAddressListCall

Do rewrite *gomock.Call.Do

func (*IAddressListCall) DoAndReturn

func (c *IAddressListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Address, error)) *IAddressListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IAddressListCall) Return

func (c *IAddressListCall) Return(arg0 []*storage.Address, arg1 error) *IAddressListCall

Return rewrite *gomock.Call.Return

type IAddressSaveCall

type IAddressSaveCall struct {
	*gomock.Call
}

IAddressSaveCall wrap *gomock.Call

func (*IAddressSaveCall) Do

func (c *IAddressSaveCall) Do(f func(context.Context, *storage.Address) error) *IAddressSaveCall

Do rewrite *gomock.Call.Do

func (*IAddressSaveCall) DoAndReturn

func (c *IAddressSaveCall) DoAndReturn(f func(context.Context, *storage.Address) error) *IAddressSaveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IAddressSaveCall) Return

func (c *IAddressSaveCall) Return(arg0 error) *IAddressSaveCall

Return rewrite *gomock.Call.Return

type IAddressUpdateCall

type IAddressUpdateCall struct {
	*gomock.Call
}

IAddressUpdateCall wrap *gomock.Call

func (*IAddressUpdateCall) Do

func (c *IAddressUpdateCall) Do(f func(context.Context, *storage.Address) error) *IAddressUpdateCall

Do rewrite *gomock.Call.Do

func (*IAddressUpdateCall) DoAndReturn

func (c *IAddressUpdateCall) DoAndReturn(f func(context.Context, *storage.Address) error) *IAddressUpdateCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IAddressUpdateCall) Return

func (c *IAddressUpdateCall) Return(arg0 error) *IAddressUpdateCall

Return rewrite *gomock.Call.Return

type IBlockByHeightCall

type IBlockByHeightCall struct {
	*gomock.Call
}

IBlockByHeightCall wrap *gomock.Call

func (*IBlockByHeightCall) Do

func (c *IBlockByHeightCall) Do(f func(context.Context, uint64) (storage.Block, error)) *IBlockByHeightCall

Do rewrite *gomock.Call.Do

func (*IBlockByHeightCall) DoAndReturn

func (c *IBlockByHeightCall) DoAndReturn(f func(context.Context, uint64) (storage.Block, error)) *IBlockByHeightCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IBlockByHeightCall) Return

func (c *IBlockByHeightCall) Return(arg0 storage.Block, arg1 error) *IBlockByHeightCall

Return rewrite *gomock.Call.Return

type IBlockByStatusCall

type IBlockByStatusCall struct {
	*gomock.Call
}

IBlockByStatusCall wrap *gomock.Call

func (*IBlockByStatusCall) Do

func (c *IBlockByStatusCall) Do(f func(context.Context, storage.Status, uint64, uint64, storage0.SortOrder) ([]storage.Block, error)) *IBlockByStatusCall

Do rewrite *gomock.Call.Do

func (*IBlockByStatusCall) DoAndReturn

func (c *IBlockByStatusCall) DoAndReturn(f func(context.Context, storage.Status, uint64, uint64, storage0.SortOrder) ([]storage.Block, error)) *IBlockByStatusCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IBlockByStatusCall) Return

func (c *IBlockByStatusCall) Return(arg0 []storage.Block, arg1 error) *IBlockByStatusCall

Return rewrite *gomock.Call.Return

type IBlockCursorListCall

type IBlockCursorListCall struct {
	*gomock.Call
}

IBlockCursorListCall wrap *gomock.Call

func (*IBlockCursorListCall) Do

func (c *IBlockCursorListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Block, error)) *IBlockCursorListCall

Do rewrite *gomock.Call.Do

func (*IBlockCursorListCall) DoAndReturn

func (c *IBlockCursorListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Block, error)) *IBlockCursorListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IBlockCursorListCall) Return

func (c *IBlockCursorListCall) Return(arg0 []*storage.Block, arg1 error) *IBlockCursorListCall

Return rewrite *gomock.Call.Return

type IBlockGetByIDCall

type IBlockGetByIDCall struct {
	*gomock.Call
}

IBlockGetByIDCall wrap *gomock.Call

func (*IBlockGetByIDCall) Do

func (c *IBlockGetByIDCall) Do(f func(context.Context, uint64) (*storage.Block, error)) *IBlockGetByIDCall

Do rewrite *gomock.Call.Do

func (*IBlockGetByIDCall) DoAndReturn

func (c *IBlockGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Block, error)) *IBlockGetByIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IBlockGetByIDCall) Return

func (c *IBlockGetByIDCall) Return(arg0 *storage.Block, arg1 error) *IBlockGetByIDCall

Return rewrite *gomock.Call.Return

type IBlockIsNoRowsCall

type IBlockIsNoRowsCall struct {
	*gomock.Call
}

IBlockIsNoRowsCall wrap *gomock.Call

func (*IBlockIsNoRowsCall) Do

func (c *IBlockIsNoRowsCall) Do(f func(error) bool) *IBlockIsNoRowsCall

Do rewrite *gomock.Call.Do

func (*IBlockIsNoRowsCall) DoAndReturn

func (c *IBlockIsNoRowsCall) DoAndReturn(f func(error) bool) *IBlockIsNoRowsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IBlockIsNoRowsCall) Return

func (c *IBlockIsNoRowsCall) Return(arg0 bool) *IBlockIsNoRowsCall

Return rewrite *gomock.Call.Return

type IBlockLastCall

type IBlockLastCall struct {
	*gomock.Call
}

IBlockLastCall wrap *gomock.Call

func (*IBlockLastCall) Do

func (c *IBlockLastCall) Do(f func(context.Context) (storage.Block, error)) *IBlockLastCall

Do rewrite *gomock.Call.Do

func (*IBlockLastCall) DoAndReturn

func (c *IBlockLastCall) DoAndReturn(f func(context.Context) (storage.Block, error)) *IBlockLastCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IBlockLastCall) Return

func (c *IBlockLastCall) Return(arg0 storage.Block, arg1 error) *IBlockLastCall

Return rewrite *gomock.Call.Return

type IBlockLastIDCall

type IBlockLastIDCall struct {
	*gomock.Call
}

IBlockLastIDCall wrap *gomock.Call

func (*IBlockLastIDCall) Do

func (c *IBlockLastIDCall) Do(f func(context.Context) (uint64, error)) *IBlockLastIDCall

Do rewrite *gomock.Call.Do

func (*IBlockLastIDCall) DoAndReturn

func (c *IBlockLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IBlockLastIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IBlockLastIDCall) Return

func (c *IBlockLastIDCall) Return(arg0 uint64, arg1 error) *IBlockLastIDCall

Return rewrite *gomock.Call.Return

type IBlockListCall

type IBlockListCall struct {
	*gomock.Call
}

IBlockListCall wrap *gomock.Call

func (*IBlockListCall) Do

func (c *IBlockListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Block, error)) *IBlockListCall

Do rewrite *gomock.Call.Do

func (*IBlockListCall) DoAndReturn

func (c *IBlockListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Block, error)) *IBlockListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IBlockListCall) Return

func (c *IBlockListCall) Return(arg0 []*storage.Block, arg1 error) *IBlockListCall

Return rewrite *gomock.Call.Return

type IBlockSaveCall

type IBlockSaveCall struct {
	*gomock.Call
}

IBlockSaveCall wrap *gomock.Call

func (*IBlockSaveCall) Do

func (c *IBlockSaveCall) Do(f func(context.Context, *storage.Block) error) *IBlockSaveCall

Do rewrite *gomock.Call.Do

func (*IBlockSaveCall) DoAndReturn

func (c *IBlockSaveCall) DoAndReturn(f func(context.Context, *storage.Block) error) *IBlockSaveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IBlockSaveCall) Return

func (c *IBlockSaveCall) Return(arg0 error) *IBlockSaveCall

Return rewrite *gomock.Call.Return

type IBlockUpdateCall

type IBlockUpdateCall struct {
	*gomock.Call
}

IBlockUpdateCall wrap *gomock.Call

func (*IBlockUpdateCall) Do

func (c *IBlockUpdateCall) Do(f func(context.Context, *storage.Block) error) *IBlockUpdateCall

Do rewrite *gomock.Call.Do

func (*IBlockUpdateCall) DoAndReturn

func (c *IBlockUpdateCall) DoAndReturn(f func(context.Context, *storage.Block) error) *IBlockUpdateCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IBlockUpdateCall) Return

func (c *IBlockUpdateCall) Return(arg0 error) *IBlockUpdateCall

Return rewrite *gomock.Call.Return

type IClassCursorListCall

type IClassCursorListCall struct {
	*gomock.Call
}

IClassCursorListCall wrap *gomock.Call

func (*IClassCursorListCall) Do

func (c *IClassCursorListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Class, error)) *IClassCursorListCall

Do rewrite *gomock.Call.Do

func (*IClassCursorListCall) DoAndReturn

func (c *IClassCursorListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Class, error)) *IClassCursorListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IClassCursorListCall) Return

func (c *IClassCursorListCall) Return(arg0 []*storage.Class, arg1 error) *IClassCursorListCall

Return rewrite *gomock.Call.Return

type IClassGetByHashCall

type IClassGetByHashCall struct {
	*gomock.Call
}

IClassGetByHashCall wrap *gomock.Call

func (*IClassGetByHashCall) Do

func (c *IClassGetByHashCall) Do(f func(context.Context, []byte) (storage.Class, error)) *IClassGetByHashCall

Do rewrite *gomock.Call.Do

func (*IClassGetByHashCall) DoAndReturn

func (c *IClassGetByHashCall) DoAndReturn(f func(context.Context, []byte) (storage.Class, error)) *IClassGetByHashCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IClassGetByHashCall) Return

func (c *IClassGetByHashCall) Return(arg0 storage.Class, arg1 error) *IClassGetByHashCall

Return rewrite *gomock.Call.Return

type IClassGetByIDCall

type IClassGetByIDCall struct {
	*gomock.Call
}

IClassGetByIDCall wrap *gomock.Call

func (*IClassGetByIDCall) Do

func (c *IClassGetByIDCall) Do(f func(context.Context, uint64) (*storage.Class, error)) *IClassGetByIDCall

Do rewrite *gomock.Call.Do

func (*IClassGetByIDCall) DoAndReturn

func (c *IClassGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Class, error)) *IClassGetByIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IClassGetByIDCall) Return

func (c *IClassGetByIDCall) Return(arg0 *storage.Class, arg1 error) *IClassGetByIDCall

Return rewrite *gomock.Call.Return

type IClassGetUnresolvedCall

type IClassGetUnresolvedCall struct {
	*gomock.Call
}

IClassGetUnresolvedCall wrap *gomock.Call

func (*IClassGetUnresolvedCall) Do

func (c *IClassGetUnresolvedCall) Do(f func(context.Context) ([]storage.Class, error)) *IClassGetUnresolvedCall

Do rewrite *gomock.Call.Do

func (*IClassGetUnresolvedCall) DoAndReturn

func (c *IClassGetUnresolvedCall) DoAndReturn(f func(context.Context) ([]storage.Class, error)) *IClassGetUnresolvedCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IClassGetUnresolvedCall) Return

func (c *IClassGetUnresolvedCall) Return(arg0 []storage.Class, arg1 error) *IClassGetUnresolvedCall

Return rewrite *gomock.Call.Return

type IClassIsNoRowsCall

type IClassIsNoRowsCall struct {
	*gomock.Call
}

IClassIsNoRowsCall wrap *gomock.Call

func (*IClassIsNoRowsCall) Do

func (c *IClassIsNoRowsCall) Do(f func(error) bool) *IClassIsNoRowsCall

Do rewrite *gomock.Call.Do

func (*IClassIsNoRowsCall) DoAndReturn

func (c *IClassIsNoRowsCall) DoAndReturn(f func(error) bool) *IClassIsNoRowsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IClassIsNoRowsCall) Return

func (c *IClassIsNoRowsCall) Return(arg0 bool) *IClassIsNoRowsCall

Return rewrite *gomock.Call.Return

type IClassLastIDCall

type IClassLastIDCall struct {
	*gomock.Call
}

IClassLastIDCall wrap *gomock.Call

func (*IClassLastIDCall) Do

func (c *IClassLastIDCall) Do(f func(context.Context) (uint64, error)) *IClassLastIDCall

Do rewrite *gomock.Call.Do

func (*IClassLastIDCall) DoAndReturn

func (c *IClassLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IClassLastIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IClassLastIDCall) Return

func (c *IClassLastIDCall) Return(arg0 uint64, arg1 error) *IClassLastIDCall

Return rewrite *gomock.Call.Return

type IClassListCall

type IClassListCall struct {
	*gomock.Call
}

IClassListCall wrap *gomock.Call

func (*IClassListCall) Do

func (c *IClassListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Class, error)) *IClassListCall

Do rewrite *gomock.Call.Do

func (*IClassListCall) DoAndReturn

func (c *IClassListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Class, error)) *IClassListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IClassListCall) Return

func (c *IClassListCall) Return(arg0 []*storage.Class, arg1 error) *IClassListCall

Return rewrite *gomock.Call.Return

type IClassReplaceByHeightCall

type IClassReplaceByHeightCall struct {
	*gomock.Call
}

IClassReplaceByHeightCall wrap *gomock.Call

func (*IClassReplaceByHeightCall) Do

func (c *IClassReplaceByHeightCall) Do(f func(context.Context, uint64) ([]storage.ClassReplace, error)) *IClassReplaceByHeightCall

Do rewrite *gomock.Call.Do

func (*IClassReplaceByHeightCall) DoAndReturn

func (c *IClassReplaceByHeightCall) DoAndReturn(f func(context.Context, uint64) ([]storage.ClassReplace, error)) *IClassReplaceByHeightCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IClassReplaceByHeightCall) Return

func (c *IClassReplaceByHeightCall) Return(arg0 []storage.ClassReplace, arg1 error) *IClassReplaceByHeightCall

Return rewrite *gomock.Call.Return

type IClassReplaceCursorListCall

type IClassReplaceCursorListCall struct {
	*gomock.Call
}

IClassReplaceCursorListCall wrap *gomock.Call

func (*IClassReplaceCursorListCall) Do

func (c *IClassReplaceCursorListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.ClassReplace, error)) *IClassReplaceCursorListCall

Do rewrite *gomock.Call.Do

func (*IClassReplaceCursorListCall) DoAndReturn

func (c *IClassReplaceCursorListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.ClassReplace, error)) *IClassReplaceCursorListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IClassReplaceCursorListCall) Return

func (c *IClassReplaceCursorListCall) Return(arg0 []*storage.ClassReplace, arg1 error) *IClassReplaceCursorListCall

Return rewrite *gomock.Call.Return

type IClassReplaceGetByIDCall

type IClassReplaceGetByIDCall struct {
	*gomock.Call
}

IClassReplaceGetByIDCall wrap *gomock.Call

func (*IClassReplaceGetByIDCall) Do

func (c *IClassReplaceGetByIDCall) Do(f func(context.Context, uint64) (*storage.ClassReplace, error)) *IClassReplaceGetByIDCall

Do rewrite *gomock.Call.Do

func (*IClassReplaceGetByIDCall) DoAndReturn

func (c *IClassReplaceGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.ClassReplace, error)) *IClassReplaceGetByIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IClassReplaceGetByIDCall) Return

func (c *IClassReplaceGetByIDCall) Return(arg0 *storage.ClassReplace, arg1 error) *IClassReplaceGetByIDCall

Return rewrite *gomock.Call.Return

type IClassReplaceIsNoRowsCall

type IClassReplaceIsNoRowsCall struct {
	*gomock.Call
}

IClassReplaceIsNoRowsCall wrap *gomock.Call

func (*IClassReplaceIsNoRowsCall) Do

func (c *IClassReplaceIsNoRowsCall) Do(f func(error) bool) *IClassReplaceIsNoRowsCall

Do rewrite *gomock.Call.Do

func (*IClassReplaceIsNoRowsCall) DoAndReturn

func (c *IClassReplaceIsNoRowsCall) DoAndReturn(f func(error) bool) *IClassReplaceIsNoRowsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IClassReplaceIsNoRowsCall) Return

func (c *IClassReplaceIsNoRowsCall) Return(arg0 bool) *IClassReplaceIsNoRowsCall

Return rewrite *gomock.Call.Return

type IClassReplaceLastIDCall

type IClassReplaceLastIDCall struct {
	*gomock.Call
}

IClassReplaceLastIDCall wrap *gomock.Call

func (*IClassReplaceLastIDCall) Do

func (c *IClassReplaceLastIDCall) Do(f func(context.Context) (uint64, error)) *IClassReplaceLastIDCall

Do rewrite *gomock.Call.Do

func (*IClassReplaceLastIDCall) DoAndReturn

func (c *IClassReplaceLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IClassReplaceLastIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IClassReplaceLastIDCall) Return

func (c *IClassReplaceLastIDCall) Return(arg0 uint64, arg1 error) *IClassReplaceLastIDCall

Return rewrite *gomock.Call.Return

type IClassReplaceListCall

type IClassReplaceListCall struct {
	*gomock.Call
}

IClassReplaceListCall wrap *gomock.Call

func (*IClassReplaceListCall) Do

func (c *IClassReplaceListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.ClassReplace, error)) *IClassReplaceListCall

Do rewrite *gomock.Call.Do

func (*IClassReplaceListCall) DoAndReturn

func (c *IClassReplaceListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.ClassReplace, error)) *IClassReplaceListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IClassReplaceListCall) Return

func (c *IClassReplaceListCall) Return(arg0 []*storage.ClassReplace, arg1 error) *IClassReplaceListCall

Return rewrite *gomock.Call.Return

type IClassReplaceSaveCall

type IClassReplaceSaveCall struct {
	*gomock.Call
}

IClassReplaceSaveCall wrap *gomock.Call

func (*IClassReplaceSaveCall) Do

func (c *IClassReplaceSaveCall) Do(f func(context.Context, *storage.ClassReplace) error) *IClassReplaceSaveCall

Do rewrite *gomock.Call.Do

func (*IClassReplaceSaveCall) DoAndReturn

func (c *IClassReplaceSaveCall) DoAndReturn(f func(context.Context, *storage.ClassReplace) error) *IClassReplaceSaveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IClassReplaceSaveCall) Return

func (c *IClassReplaceSaveCall) Return(arg0 error) *IClassReplaceSaveCall

Return rewrite *gomock.Call.Return

type IClassReplaceUpdateCall

type IClassReplaceUpdateCall struct {
	*gomock.Call
}

IClassReplaceUpdateCall wrap *gomock.Call

func (*IClassReplaceUpdateCall) Do

func (c *IClassReplaceUpdateCall) Do(f func(context.Context, *storage.ClassReplace) error) *IClassReplaceUpdateCall

Do rewrite *gomock.Call.Do

func (*IClassReplaceUpdateCall) DoAndReturn

func (c *IClassReplaceUpdateCall) DoAndReturn(f func(context.Context, *storage.ClassReplace) error) *IClassReplaceUpdateCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IClassReplaceUpdateCall) Return

func (c *IClassReplaceUpdateCall) Return(arg0 error) *IClassReplaceUpdateCall

Return rewrite *gomock.Call.Return

type IClassSaveCall

type IClassSaveCall struct {
	*gomock.Call
}

IClassSaveCall wrap *gomock.Call

func (*IClassSaveCall) Do

func (c *IClassSaveCall) Do(f func(context.Context, *storage.Class) error) *IClassSaveCall

Do rewrite *gomock.Call.Do

func (*IClassSaveCall) DoAndReturn

func (c *IClassSaveCall) DoAndReturn(f func(context.Context, *storage.Class) error) *IClassSaveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IClassSaveCall) Return

func (c *IClassSaveCall) Return(arg0 error) *IClassSaveCall

Return rewrite *gomock.Call.Return

type IClassUpdateCall

type IClassUpdateCall struct {
	*gomock.Call
}

IClassUpdateCall wrap *gomock.Call

func (*IClassUpdateCall) Do

func (c *IClassUpdateCall) Do(f func(context.Context, *storage.Class) error) *IClassUpdateCall

Do rewrite *gomock.Call.Do

func (*IClassUpdateCall) DoAndReturn

func (c *IClassUpdateCall) DoAndReturn(f func(context.Context, *storage.Class) error) *IClassUpdateCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IClassUpdateCall) Return

func (c *IClassUpdateCall) Return(arg0 error) *IClassUpdateCall

Return rewrite *gomock.Call.Return

type IDeclareCursorListCall

type IDeclareCursorListCall struct {
	*gomock.Call
}

IDeclareCursorListCall wrap *gomock.Call

func (*IDeclareCursorListCall) Do

func (c *IDeclareCursorListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Declare, error)) *IDeclareCursorListCall

Do rewrite *gomock.Call.Do

func (*IDeclareCursorListCall) DoAndReturn

func (c *IDeclareCursorListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Declare, error)) *IDeclareCursorListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeclareCursorListCall) Return

func (c *IDeclareCursorListCall) Return(arg0 []*storage.Declare, arg1 error) *IDeclareCursorListCall

Return rewrite *gomock.Call.Return

type IDeclareFilterCall

type IDeclareFilterCall struct {
	*gomock.Call
}

IDeclareFilterCall wrap *gomock.Call

func (*IDeclareFilterCall) Do

func (c *IDeclareFilterCall) Do(f func(context.Context, []storage.DeclareFilter, ...storage.FilterOption) ([]storage.Declare, error)) *IDeclareFilterCall

Do rewrite *gomock.Call.Do

func (*IDeclareFilterCall) DoAndReturn

func (c *IDeclareFilterCall) DoAndReturn(f func(context.Context, []storage.DeclareFilter, ...storage.FilterOption) ([]storage.Declare, error)) *IDeclareFilterCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeclareFilterCall) Return

func (c *IDeclareFilterCall) Return(arg0 []storage.Declare, arg1 error) *IDeclareFilterCall

Return rewrite *gomock.Call.Return

type IDeclareGetByIDCall

type IDeclareGetByIDCall struct {
	*gomock.Call
}

IDeclareGetByIDCall wrap *gomock.Call

func (*IDeclareGetByIDCall) Do

func (c *IDeclareGetByIDCall) Do(f func(context.Context, uint64) (*storage.Declare, error)) *IDeclareGetByIDCall

Do rewrite *gomock.Call.Do

func (*IDeclareGetByIDCall) DoAndReturn

func (c *IDeclareGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Declare, error)) *IDeclareGetByIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeclareGetByIDCall) Return

func (c *IDeclareGetByIDCall) Return(arg0 *storage.Declare, arg1 error) *IDeclareGetByIDCall

Return rewrite *gomock.Call.Return

type IDeclareIsNoRowsCall

type IDeclareIsNoRowsCall struct {
	*gomock.Call
}

IDeclareIsNoRowsCall wrap *gomock.Call

func (*IDeclareIsNoRowsCall) Do

func (c *IDeclareIsNoRowsCall) Do(f func(error) bool) *IDeclareIsNoRowsCall

Do rewrite *gomock.Call.Do

func (*IDeclareIsNoRowsCall) DoAndReturn

func (c *IDeclareIsNoRowsCall) DoAndReturn(f func(error) bool) *IDeclareIsNoRowsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeclareIsNoRowsCall) Return

func (c *IDeclareIsNoRowsCall) Return(arg0 bool) *IDeclareIsNoRowsCall

Return rewrite *gomock.Call.Return

type IDeclareLastIDCall

type IDeclareLastIDCall struct {
	*gomock.Call
}

IDeclareLastIDCall wrap *gomock.Call

func (*IDeclareLastIDCall) Do

func (c *IDeclareLastIDCall) Do(f func(context.Context) (uint64, error)) *IDeclareLastIDCall

Do rewrite *gomock.Call.Do

func (*IDeclareLastIDCall) DoAndReturn

func (c *IDeclareLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IDeclareLastIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeclareLastIDCall) Return

func (c *IDeclareLastIDCall) Return(arg0 uint64, arg1 error) *IDeclareLastIDCall

Return rewrite *gomock.Call.Return

type IDeclareListCall

type IDeclareListCall struct {
	*gomock.Call
}

IDeclareListCall wrap *gomock.Call

func (*IDeclareListCall) Do

func (c *IDeclareListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Declare, error)) *IDeclareListCall

Do rewrite *gomock.Call.Do

func (*IDeclareListCall) DoAndReturn

func (c *IDeclareListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Declare, error)) *IDeclareListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeclareListCall) Return

func (c *IDeclareListCall) Return(arg0 []*storage.Declare, arg1 error) *IDeclareListCall

Return rewrite *gomock.Call.Return

type IDeclareSaveCall

type IDeclareSaveCall struct {
	*gomock.Call
}

IDeclareSaveCall wrap *gomock.Call

func (*IDeclareSaveCall) Do

func (c *IDeclareSaveCall) Do(f func(context.Context, *storage.Declare) error) *IDeclareSaveCall

Do rewrite *gomock.Call.Do

func (*IDeclareSaveCall) DoAndReturn

func (c *IDeclareSaveCall) DoAndReturn(f func(context.Context, *storage.Declare) error) *IDeclareSaveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeclareSaveCall) Return

func (c *IDeclareSaveCall) Return(arg0 error) *IDeclareSaveCall

Return rewrite *gomock.Call.Return

type IDeclareUpdateCall

type IDeclareUpdateCall struct {
	*gomock.Call
}

IDeclareUpdateCall wrap *gomock.Call

func (*IDeclareUpdateCall) Do

func (c *IDeclareUpdateCall) Do(f func(context.Context, *storage.Declare) error) *IDeclareUpdateCall

Do rewrite *gomock.Call.Do

func (*IDeclareUpdateCall) DoAndReturn

func (c *IDeclareUpdateCall) DoAndReturn(f func(context.Context, *storage.Declare) error) *IDeclareUpdateCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeclareUpdateCall) Return

func (c *IDeclareUpdateCall) Return(arg0 error) *IDeclareUpdateCall

Return rewrite *gomock.Call.Return

type IDeployAccountCursorListCall

type IDeployAccountCursorListCall struct {
	*gomock.Call
}

IDeployAccountCursorListCall wrap *gomock.Call

func (*IDeployAccountCursorListCall) Do

func (c *IDeployAccountCursorListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.DeployAccount, error)) *IDeployAccountCursorListCall

Do rewrite *gomock.Call.Do

func (*IDeployAccountCursorListCall) DoAndReturn

func (c *IDeployAccountCursorListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.DeployAccount, error)) *IDeployAccountCursorListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeployAccountCursorListCall) Return

func (c *IDeployAccountCursorListCall) Return(arg0 []*storage.DeployAccount, arg1 error) *IDeployAccountCursorListCall

Return rewrite *gomock.Call.Return

type IDeployAccountFilterCall

type IDeployAccountFilterCall struct {
	*gomock.Call
}

IDeployAccountFilterCall wrap *gomock.Call

func (*IDeployAccountFilterCall) Do

func (c *IDeployAccountFilterCall) Do(f func(context.Context, []storage.DeployAccountFilter, ...storage.FilterOption) ([]storage.DeployAccount, error)) *IDeployAccountFilterCall

Do rewrite *gomock.Call.Do

func (*IDeployAccountFilterCall) DoAndReturn

func (c *IDeployAccountFilterCall) DoAndReturn(f func(context.Context, []storage.DeployAccountFilter, ...storage.FilterOption) ([]storage.DeployAccount, error)) *IDeployAccountFilterCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeployAccountFilterCall) Return

func (c *IDeployAccountFilterCall) Return(arg0 []storage.DeployAccount, arg1 error) *IDeployAccountFilterCall

Return rewrite *gomock.Call.Return

type IDeployAccountGetByIDCall

type IDeployAccountGetByIDCall struct {
	*gomock.Call
}

IDeployAccountGetByIDCall wrap *gomock.Call

func (*IDeployAccountGetByIDCall) Do

func (c *IDeployAccountGetByIDCall) Do(f func(context.Context, uint64) (*storage.DeployAccount, error)) *IDeployAccountGetByIDCall

Do rewrite *gomock.Call.Do

func (*IDeployAccountGetByIDCall) DoAndReturn

func (c *IDeployAccountGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.DeployAccount, error)) *IDeployAccountGetByIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeployAccountGetByIDCall) Return

func (c *IDeployAccountGetByIDCall) Return(arg0 *storage.DeployAccount, arg1 error) *IDeployAccountGetByIDCall

Return rewrite *gomock.Call.Return

type IDeployAccountIsNoRowsCall

type IDeployAccountIsNoRowsCall struct {
	*gomock.Call
}

IDeployAccountIsNoRowsCall wrap *gomock.Call

func (*IDeployAccountIsNoRowsCall) Do

func (c *IDeployAccountIsNoRowsCall) Do(f func(error) bool) *IDeployAccountIsNoRowsCall

Do rewrite *gomock.Call.Do

func (*IDeployAccountIsNoRowsCall) DoAndReturn

func (c *IDeployAccountIsNoRowsCall) DoAndReturn(f func(error) bool) *IDeployAccountIsNoRowsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeployAccountIsNoRowsCall) Return

func (c *IDeployAccountIsNoRowsCall) Return(arg0 bool) *IDeployAccountIsNoRowsCall

Return rewrite *gomock.Call.Return

type IDeployAccountLastIDCall

type IDeployAccountLastIDCall struct {
	*gomock.Call
}

IDeployAccountLastIDCall wrap *gomock.Call

func (*IDeployAccountLastIDCall) Do

func (c *IDeployAccountLastIDCall) Do(f func(context.Context) (uint64, error)) *IDeployAccountLastIDCall

Do rewrite *gomock.Call.Do

func (*IDeployAccountLastIDCall) DoAndReturn

func (c *IDeployAccountLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IDeployAccountLastIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeployAccountLastIDCall) Return

func (c *IDeployAccountLastIDCall) Return(arg0 uint64, arg1 error) *IDeployAccountLastIDCall

Return rewrite *gomock.Call.Return

type IDeployAccountListCall

type IDeployAccountListCall struct {
	*gomock.Call
}

IDeployAccountListCall wrap *gomock.Call

func (*IDeployAccountListCall) Do

func (c *IDeployAccountListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.DeployAccount, error)) *IDeployAccountListCall

Do rewrite *gomock.Call.Do

func (*IDeployAccountListCall) DoAndReturn

func (c *IDeployAccountListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.DeployAccount, error)) *IDeployAccountListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeployAccountListCall) Return

func (c *IDeployAccountListCall) Return(arg0 []*storage.DeployAccount, arg1 error) *IDeployAccountListCall

Return rewrite *gomock.Call.Return

type IDeployAccountSaveCall

type IDeployAccountSaveCall struct {
	*gomock.Call
}

IDeployAccountSaveCall wrap *gomock.Call

func (*IDeployAccountSaveCall) Do

func (c *IDeployAccountSaveCall) Do(f func(context.Context, *storage.DeployAccount) error) *IDeployAccountSaveCall

Do rewrite *gomock.Call.Do

func (*IDeployAccountSaveCall) DoAndReturn

func (c *IDeployAccountSaveCall) DoAndReturn(f func(context.Context, *storage.DeployAccount) error) *IDeployAccountSaveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeployAccountSaveCall) Return

func (c *IDeployAccountSaveCall) Return(arg0 error) *IDeployAccountSaveCall

Return rewrite *gomock.Call.Return

type IDeployAccountUpdateCall

type IDeployAccountUpdateCall struct {
	*gomock.Call
}

IDeployAccountUpdateCall wrap *gomock.Call

func (*IDeployAccountUpdateCall) Do

func (c *IDeployAccountUpdateCall) Do(f func(context.Context, *storage.DeployAccount) error) *IDeployAccountUpdateCall

Do rewrite *gomock.Call.Do

func (*IDeployAccountUpdateCall) DoAndReturn

func (c *IDeployAccountUpdateCall) DoAndReturn(f func(context.Context, *storage.DeployAccount) error) *IDeployAccountUpdateCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeployAccountUpdateCall) Return

func (c *IDeployAccountUpdateCall) Return(arg0 error) *IDeployAccountUpdateCall

Return rewrite *gomock.Call.Return

type IDeployCursorListCall

type IDeployCursorListCall struct {
	*gomock.Call
}

IDeployCursorListCall wrap *gomock.Call

func (*IDeployCursorListCall) Do

func (c *IDeployCursorListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Deploy, error)) *IDeployCursorListCall

Do rewrite *gomock.Call.Do

func (*IDeployCursorListCall) DoAndReturn

func (c *IDeployCursorListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Deploy, error)) *IDeployCursorListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeployCursorListCall) Return

func (c *IDeployCursorListCall) Return(arg0 []*storage.Deploy, arg1 error) *IDeployCursorListCall

Return rewrite *gomock.Call.Return

type IDeployFilterCall

type IDeployFilterCall struct {
	*gomock.Call
}

IDeployFilterCall wrap *gomock.Call

func (*IDeployFilterCall) Do

func (c *IDeployFilterCall) Do(f func(context.Context, []storage.DeployFilter, ...storage.FilterOption) ([]storage.Deploy, error)) *IDeployFilterCall

Do rewrite *gomock.Call.Do

func (*IDeployFilterCall) DoAndReturn

func (c *IDeployFilterCall) DoAndReturn(f func(context.Context, []storage.DeployFilter, ...storage.FilterOption) ([]storage.Deploy, error)) *IDeployFilterCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeployFilterCall) Return

func (c *IDeployFilterCall) Return(arg0 []storage.Deploy, arg1 error) *IDeployFilterCall

Return rewrite *gomock.Call.Return

type IDeployGetByIDCall

type IDeployGetByIDCall struct {
	*gomock.Call
}

IDeployGetByIDCall wrap *gomock.Call

func (*IDeployGetByIDCall) Do

func (c *IDeployGetByIDCall) Do(f func(context.Context, uint64) (*storage.Deploy, error)) *IDeployGetByIDCall

Do rewrite *gomock.Call.Do

func (*IDeployGetByIDCall) DoAndReturn

func (c *IDeployGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Deploy, error)) *IDeployGetByIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeployGetByIDCall) Return

func (c *IDeployGetByIDCall) Return(arg0 *storage.Deploy, arg1 error) *IDeployGetByIDCall

Return rewrite *gomock.Call.Return

type IDeployIsNoRowsCall

type IDeployIsNoRowsCall struct {
	*gomock.Call
}

IDeployIsNoRowsCall wrap *gomock.Call

func (*IDeployIsNoRowsCall) Do

func (c *IDeployIsNoRowsCall) Do(f func(error) bool) *IDeployIsNoRowsCall

Do rewrite *gomock.Call.Do

func (*IDeployIsNoRowsCall) DoAndReturn

func (c *IDeployIsNoRowsCall) DoAndReturn(f func(error) bool) *IDeployIsNoRowsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeployIsNoRowsCall) Return

func (c *IDeployIsNoRowsCall) Return(arg0 bool) *IDeployIsNoRowsCall

Return rewrite *gomock.Call.Return

type IDeployLastIDCall

type IDeployLastIDCall struct {
	*gomock.Call
}

IDeployLastIDCall wrap *gomock.Call

func (*IDeployLastIDCall) Do

func (c *IDeployLastIDCall) Do(f func(context.Context) (uint64, error)) *IDeployLastIDCall

Do rewrite *gomock.Call.Do

func (*IDeployLastIDCall) DoAndReturn

func (c *IDeployLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IDeployLastIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeployLastIDCall) Return

func (c *IDeployLastIDCall) Return(arg0 uint64, arg1 error) *IDeployLastIDCall

Return rewrite *gomock.Call.Return

type IDeployListCall

type IDeployListCall struct {
	*gomock.Call
}

IDeployListCall wrap *gomock.Call

func (*IDeployListCall) Do

func (c *IDeployListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Deploy, error)) *IDeployListCall

Do rewrite *gomock.Call.Do

func (*IDeployListCall) DoAndReturn

func (c *IDeployListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Deploy, error)) *IDeployListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeployListCall) Return

func (c *IDeployListCall) Return(arg0 []*storage.Deploy, arg1 error) *IDeployListCall

Return rewrite *gomock.Call.Return

type IDeploySaveCall

type IDeploySaveCall struct {
	*gomock.Call
}

IDeploySaveCall wrap *gomock.Call

func (*IDeploySaveCall) Do

func (c *IDeploySaveCall) Do(f func(context.Context, *storage.Deploy) error) *IDeploySaveCall

Do rewrite *gomock.Call.Do

func (*IDeploySaveCall) DoAndReturn

func (c *IDeploySaveCall) DoAndReturn(f func(context.Context, *storage.Deploy) error) *IDeploySaveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeploySaveCall) Return

func (c *IDeploySaveCall) Return(arg0 error) *IDeploySaveCall

Return rewrite *gomock.Call.Return

type IDeployUpdateCall

type IDeployUpdateCall struct {
	*gomock.Call
}

IDeployUpdateCall wrap *gomock.Call

func (*IDeployUpdateCall) Do

func (c *IDeployUpdateCall) Do(f func(context.Context, *storage.Deploy) error) *IDeployUpdateCall

Do rewrite *gomock.Call.Do

func (*IDeployUpdateCall) DoAndReturn

func (c *IDeployUpdateCall) DoAndReturn(f func(context.Context, *storage.Deploy) error) *IDeployUpdateCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IDeployUpdateCall) Return

func (c *IDeployUpdateCall) Return(arg0 error) *IDeployUpdateCall

Return rewrite *gomock.Call.Return

type IEventCursorListCall

type IEventCursorListCall struct {
	*gomock.Call
}

IEventCursorListCall wrap *gomock.Call

func (*IEventCursorListCall) Do

func (c *IEventCursorListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Event, error)) *IEventCursorListCall

Do rewrite *gomock.Call.Do

func (*IEventCursorListCall) DoAndReturn

func (c *IEventCursorListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Event, error)) *IEventCursorListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IEventCursorListCall) Return

func (c *IEventCursorListCall) Return(arg0 []*storage.Event, arg1 error) *IEventCursorListCall

Return rewrite *gomock.Call.Return

type IEventFilterCall

type IEventFilterCall struct {
	*gomock.Call
}

IEventFilterCall wrap *gomock.Call

func (*IEventFilterCall) Do

func (c *IEventFilterCall) Do(f func(context.Context, []storage.EventFilter, ...storage.FilterOption) ([]storage.Event, error)) *IEventFilterCall

Do rewrite *gomock.Call.Do

func (*IEventFilterCall) DoAndReturn

func (c *IEventFilterCall) DoAndReturn(f func(context.Context, []storage.EventFilter, ...storage.FilterOption) ([]storage.Event, error)) *IEventFilterCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IEventFilterCall) Return

func (c *IEventFilterCall) Return(arg0 []storage.Event, arg1 error) *IEventFilterCall

Return rewrite *gomock.Call.Return

type IEventGetByIDCall

type IEventGetByIDCall struct {
	*gomock.Call
}

IEventGetByIDCall wrap *gomock.Call

func (*IEventGetByIDCall) Do

func (c *IEventGetByIDCall) Do(f func(context.Context, uint64) (*storage.Event, error)) *IEventGetByIDCall

Do rewrite *gomock.Call.Do

func (*IEventGetByIDCall) DoAndReturn

func (c *IEventGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Event, error)) *IEventGetByIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IEventGetByIDCall) Return

func (c *IEventGetByIDCall) Return(arg0 *storage.Event, arg1 error) *IEventGetByIDCall

Return rewrite *gomock.Call.Return

type IEventIsNoRowsCall

type IEventIsNoRowsCall struct {
	*gomock.Call
}

IEventIsNoRowsCall wrap *gomock.Call

func (*IEventIsNoRowsCall) Do

func (c *IEventIsNoRowsCall) Do(f func(error) bool) *IEventIsNoRowsCall

Do rewrite *gomock.Call.Do

func (*IEventIsNoRowsCall) DoAndReturn

func (c *IEventIsNoRowsCall) DoAndReturn(f func(error) bool) *IEventIsNoRowsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IEventIsNoRowsCall) Return

func (c *IEventIsNoRowsCall) Return(arg0 bool) *IEventIsNoRowsCall

Return rewrite *gomock.Call.Return

type IEventLastIDCall

type IEventLastIDCall struct {
	*gomock.Call
}

IEventLastIDCall wrap *gomock.Call

func (*IEventLastIDCall) Do

func (c *IEventLastIDCall) Do(f func(context.Context) (uint64, error)) *IEventLastIDCall

Do rewrite *gomock.Call.Do

func (*IEventLastIDCall) DoAndReturn

func (c *IEventLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IEventLastIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IEventLastIDCall) Return

func (c *IEventLastIDCall) Return(arg0 uint64, arg1 error) *IEventLastIDCall

Return rewrite *gomock.Call.Return

type IEventListCall

type IEventListCall struct {
	*gomock.Call
}

IEventListCall wrap *gomock.Call

func (*IEventListCall) Do

func (c *IEventListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Event, error)) *IEventListCall

Do rewrite *gomock.Call.Do

func (*IEventListCall) DoAndReturn

func (c *IEventListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Event, error)) *IEventListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IEventListCall) Return

func (c *IEventListCall) Return(arg0 []*storage.Event, arg1 error) *IEventListCall

Return rewrite *gomock.Call.Return

type IEventSaveCall

type IEventSaveCall struct {
	*gomock.Call
}

IEventSaveCall wrap *gomock.Call

func (*IEventSaveCall) Do

func (c *IEventSaveCall) Do(f func(context.Context, *storage.Event) error) *IEventSaveCall

Do rewrite *gomock.Call.Do

func (*IEventSaveCall) DoAndReturn

func (c *IEventSaveCall) DoAndReturn(f func(context.Context, *storage.Event) error) *IEventSaveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IEventSaveCall) Return

func (c *IEventSaveCall) Return(arg0 error) *IEventSaveCall

Return rewrite *gomock.Call.Return

type IEventUpdateCall

type IEventUpdateCall struct {
	*gomock.Call
}

IEventUpdateCall wrap *gomock.Call

func (*IEventUpdateCall) Do

func (c *IEventUpdateCall) Do(f func(context.Context, *storage.Event) error) *IEventUpdateCall

Do rewrite *gomock.Call.Do

func (*IEventUpdateCall) DoAndReturn

func (c *IEventUpdateCall) DoAndReturn(f func(context.Context, *storage.Event) error) *IEventUpdateCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IEventUpdateCall) Return

func (c *IEventUpdateCall) Return(arg0 error) *IEventUpdateCall

Return rewrite *gomock.Call.Return

type IFeeCursorListCall

type IFeeCursorListCall struct {
	*gomock.Call
}

IFeeCursorListCall wrap *gomock.Call

func (*IFeeCursorListCall) Do

func (c *IFeeCursorListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Fee, error)) *IFeeCursorListCall

Do rewrite *gomock.Call.Do

func (*IFeeCursorListCall) DoAndReturn

func (c *IFeeCursorListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Fee, error)) *IFeeCursorListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IFeeCursorListCall) Return

func (c *IFeeCursorListCall) Return(arg0 []*storage.Fee, arg1 error) *IFeeCursorListCall

Return rewrite *gomock.Call.Return

type IFeeFilterCall

type IFeeFilterCall struct {
	*gomock.Call
}

IFeeFilterCall wrap *gomock.Call

func (*IFeeFilterCall) Do

func (c *IFeeFilterCall) Do(f func(context.Context, []storage.FeeFilter, ...storage.FilterOption) ([]storage.Fee, error)) *IFeeFilterCall

Do rewrite *gomock.Call.Do

func (*IFeeFilterCall) DoAndReturn

func (c *IFeeFilterCall) DoAndReturn(f func(context.Context, []storage.FeeFilter, ...storage.FilterOption) ([]storage.Fee, error)) *IFeeFilterCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IFeeFilterCall) Return

func (c *IFeeFilterCall) Return(arg0 []storage.Fee, arg1 error) *IFeeFilterCall

Return rewrite *gomock.Call.Return

type IFeeGetByIDCall

type IFeeGetByIDCall struct {
	*gomock.Call
}

IFeeGetByIDCall wrap *gomock.Call

func (*IFeeGetByIDCall) Do

func (c *IFeeGetByIDCall) Do(f func(context.Context, uint64) (*storage.Fee, error)) *IFeeGetByIDCall

Do rewrite *gomock.Call.Do

func (*IFeeGetByIDCall) DoAndReturn

func (c *IFeeGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Fee, error)) *IFeeGetByIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IFeeGetByIDCall) Return

func (c *IFeeGetByIDCall) Return(arg0 *storage.Fee, arg1 error) *IFeeGetByIDCall

Return rewrite *gomock.Call.Return

type IFeeIsNoRowsCall

type IFeeIsNoRowsCall struct {
	*gomock.Call
}

IFeeIsNoRowsCall wrap *gomock.Call

func (*IFeeIsNoRowsCall) Do

func (c *IFeeIsNoRowsCall) Do(f func(error) bool) *IFeeIsNoRowsCall

Do rewrite *gomock.Call.Do

func (*IFeeIsNoRowsCall) DoAndReturn

func (c *IFeeIsNoRowsCall) DoAndReturn(f func(error) bool) *IFeeIsNoRowsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IFeeIsNoRowsCall) Return

func (c *IFeeIsNoRowsCall) Return(arg0 bool) *IFeeIsNoRowsCall

Return rewrite *gomock.Call.Return

type IFeeLastIDCall

type IFeeLastIDCall struct {
	*gomock.Call
}

IFeeLastIDCall wrap *gomock.Call

func (*IFeeLastIDCall) Do

func (c *IFeeLastIDCall) Do(f func(context.Context) (uint64, error)) *IFeeLastIDCall

Do rewrite *gomock.Call.Do

func (*IFeeLastIDCall) DoAndReturn

func (c *IFeeLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IFeeLastIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IFeeLastIDCall) Return

func (c *IFeeLastIDCall) Return(arg0 uint64, arg1 error) *IFeeLastIDCall

Return rewrite *gomock.Call.Return

type IFeeListCall

type IFeeListCall struct {
	*gomock.Call
}

IFeeListCall wrap *gomock.Call

func (*IFeeListCall) Do

func (c *IFeeListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Fee, error)) *IFeeListCall

Do rewrite *gomock.Call.Do

func (*IFeeListCall) DoAndReturn

func (c *IFeeListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Fee, error)) *IFeeListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IFeeListCall) Return

func (c *IFeeListCall) Return(arg0 []*storage.Fee, arg1 error) *IFeeListCall

Return rewrite *gomock.Call.Return

type IFeeSaveCall

type IFeeSaveCall struct {
	*gomock.Call
}

IFeeSaveCall wrap *gomock.Call

func (*IFeeSaveCall) Do

func (c *IFeeSaveCall) Do(f func(context.Context, *storage.Fee) error) *IFeeSaveCall

Do rewrite *gomock.Call.Do

func (*IFeeSaveCall) DoAndReturn

func (c *IFeeSaveCall) DoAndReturn(f func(context.Context, *storage.Fee) error) *IFeeSaveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IFeeSaveCall) Return

func (c *IFeeSaveCall) Return(arg0 error) *IFeeSaveCall

Return rewrite *gomock.Call.Return

type IFeeUpdateCall

type IFeeUpdateCall struct {
	*gomock.Call
}

IFeeUpdateCall wrap *gomock.Call

func (*IFeeUpdateCall) Do

func (c *IFeeUpdateCall) Do(f func(context.Context, *storage.Fee) error) *IFeeUpdateCall

Do rewrite *gomock.Call.Do

func (*IFeeUpdateCall) DoAndReturn

func (c *IFeeUpdateCall) DoAndReturn(f func(context.Context, *storage.Fee) error) *IFeeUpdateCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IFeeUpdateCall) Return

func (c *IFeeUpdateCall) Return(arg0 error) *IFeeUpdateCall

Return rewrite *gomock.Call.Return

type IInternalCursorListCall

type IInternalCursorListCall struct {
	*gomock.Call
}

IInternalCursorListCall wrap *gomock.Call

func (*IInternalCursorListCall) Do

func (c *IInternalCursorListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Internal, error)) *IInternalCursorListCall

Do rewrite *gomock.Call.Do

func (*IInternalCursorListCall) DoAndReturn

func (c *IInternalCursorListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Internal, error)) *IInternalCursorListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IInternalCursorListCall) Return

func (c *IInternalCursorListCall) Return(arg0 []*storage.Internal, arg1 error) *IInternalCursorListCall

Return rewrite *gomock.Call.Return

type IInternalFilterCall

type IInternalFilterCall struct {
	*gomock.Call
}

IInternalFilterCall wrap *gomock.Call

func (*IInternalFilterCall) Do

func (c *IInternalFilterCall) Do(f func(context.Context, []storage.InternalFilter, ...storage.FilterOption) ([]storage.Internal, error)) *IInternalFilterCall

Do rewrite *gomock.Call.Do

func (*IInternalFilterCall) DoAndReturn

func (c *IInternalFilterCall) DoAndReturn(f func(context.Context, []storage.InternalFilter, ...storage.FilterOption) ([]storage.Internal, error)) *IInternalFilterCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IInternalFilterCall) Return

func (c *IInternalFilterCall) Return(arg0 []storage.Internal, arg1 error) *IInternalFilterCall

Return rewrite *gomock.Call.Return

type IInternalGetByIDCall

type IInternalGetByIDCall struct {
	*gomock.Call
}

IInternalGetByIDCall wrap *gomock.Call

func (*IInternalGetByIDCall) Do

func (c *IInternalGetByIDCall) Do(f func(context.Context, uint64) (*storage.Internal, error)) *IInternalGetByIDCall

Do rewrite *gomock.Call.Do

func (*IInternalGetByIDCall) DoAndReturn

func (c *IInternalGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Internal, error)) *IInternalGetByIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IInternalGetByIDCall) Return

func (c *IInternalGetByIDCall) Return(arg0 *storage.Internal, arg1 error) *IInternalGetByIDCall

Return rewrite *gomock.Call.Return

type IInternalIsNoRowsCall

type IInternalIsNoRowsCall struct {
	*gomock.Call
}

IInternalIsNoRowsCall wrap *gomock.Call

func (*IInternalIsNoRowsCall) Do

func (c *IInternalIsNoRowsCall) Do(f func(error) bool) *IInternalIsNoRowsCall

Do rewrite *gomock.Call.Do

func (*IInternalIsNoRowsCall) DoAndReturn

func (c *IInternalIsNoRowsCall) DoAndReturn(f func(error) bool) *IInternalIsNoRowsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IInternalIsNoRowsCall) Return

func (c *IInternalIsNoRowsCall) Return(arg0 bool) *IInternalIsNoRowsCall

Return rewrite *gomock.Call.Return

type IInternalLastIDCall

type IInternalLastIDCall struct {
	*gomock.Call
}

IInternalLastIDCall wrap *gomock.Call

func (*IInternalLastIDCall) Do

func (c *IInternalLastIDCall) Do(f func(context.Context) (uint64, error)) *IInternalLastIDCall

Do rewrite *gomock.Call.Do

func (*IInternalLastIDCall) DoAndReturn

func (c *IInternalLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IInternalLastIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IInternalLastIDCall) Return

func (c *IInternalLastIDCall) Return(arg0 uint64, arg1 error) *IInternalLastIDCall

Return rewrite *gomock.Call.Return

type IInternalListCall

type IInternalListCall struct {
	*gomock.Call
}

IInternalListCall wrap *gomock.Call

func (*IInternalListCall) Do

func (c *IInternalListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Internal, error)) *IInternalListCall

Do rewrite *gomock.Call.Do

func (*IInternalListCall) DoAndReturn

func (c *IInternalListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Internal, error)) *IInternalListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IInternalListCall) Return

func (c *IInternalListCall) Return(arg0 []*storage.Internal, arg1 error) *IInternalListCall

Return rewrite *gomock.Call.Return

type IInternalSaveCall

type IInternalSaveCall struct {
	*gomock.Call
}

IInternalSaveCall wrap *gomock.Call

func (*IInternalSaveCall) Do

func (c *IInternalSaveCall) Do(f func(context.Context, *storage.Internal) error) *IInternalSaveCall

Do rewrite *gomock.Call.Do

func (*IInternalSaveCall) DoAndReturn

func (c *IInternalSaveCall) DoAndReturn(f func(context.Context, *storage.Internal) error) *IInternalSaveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IInternalSaveCall) Return

func (c *IInternalSaveCall) Return(arg0 error) *IInternalSaveCall

Return rewrite *gomock.Call.Return

type IInternalUpdateCall

type IInternalUpdateCall struct {
	*gomock.Call
}

IInternalUpdateCall wrap *gomock.Call

func (*IInternalUpdateCall) Do

func (c *IInternalUpdateCall) Do(f func(context.Context, *storage.Internal) error) *IInternalUpdateCall

Do rewrite *gomock.Call.Do

func (*IInternalUpdateCall) DoAndReturn

func (c *IInternalUpdateCall) DoAndReturn(f func(context.Context, *storage.Internal) error) *IInternalUpdateCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IInternalUpdateCall) Return

func (c *IInternalUpdateCall) Return(arg0 error) *IInternalUpdateCall

Return rewrite *gomock.Call.Return

type IInvokeCursorListCall

type IInvokeCursorListCall struct {
	*gomock.Call
}

IInvokeCursorListCall wrap *gomock.Call

func (*IInvokeCursorListCall) Do

func (c *IInvokeCursorListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Invoke, error)) *IInvokeCursorListCall

Do rewrite *gomock.Call.Do

func (*IInvokeCursorListCall) DoAndReturn

func (c *IInvokeCursorListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Invoke, error)) *IInvokeCursorListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IInvokeCursorListCall) Return

func (c *IInvokeCursorListCall) Return(arg0 []*storage.Invoke, arg1 error) *IInvokeCursorListCall

Return rewrite *gomock.Call.Return

type IInvokeFilterCall

type IInvokeFilterCall struct {
	*gomock.Call
}

IInvokeFilterCall wrap *gomock.Call

func (*IInvokeFilterCall) Do

func (c *IInvokeFilterCall) Do(f func(context.Context, []storage.InvokeFilter, ...storage.FilterOption) ([]storage.Invoke, error)) *IInvokeFilterCall

Do rewrite *gomock.Call.Do

func (*IInvokeFilterCall) DoAndReturn

func (c *IInvokeFilterCall) DoAndReturn(f func(context.Context, []storage.InvokeFilter, ...storage.FilterOption) ([]storage.Invoke, error)) *IInvokeFilterCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IInvokeFilterCall) Return

func (c *IInvokeFilterCall) Return(arg0 []storage.Invoke, arg1 error) *IInvokeFilterCall

Return rewrite *gomock.Call.Return

type IInvokeGetByIDCall

type IInvokeGetByIDCall struct {
	*gomock.Call
}

IInvokeGetByIDCall wrap *gomock.Call

func (*IInvokeGetByIDCall) Do

func (c *IInvokeGetByIDCall) Do(f func(context.Context, uint64) (*storage.Invoke, error)) *IInvokeGetByIDCall

Do rewrite *gomock.Call.Do

func (*IInvokeGetByIDCall) DoAndReturn

func (c *IInvokeGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Invoke, error)) *IInvokeGetByIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IInvokeGetByIDCall) Return

func (c *IInvokeGetByIDCall) Return(arg0 *storage.Invoke, arg1 error) *IInvokeGetByIDCall

Return rewrite *gomock.Call.Return

type IInvokeHashByHeightCall

type IInvokeHashByHeightCall struct {
	*gomock.Call
}

IInvokeHashByHeightCall wrap *gomock.Call

func (*IInvokeHashByHeightCall) Do

func (c *IInvokeHashByHeightCall) Do(f func(context.Context, uint64) ([]byte, error)) *IInvokeHashByHeightCall

Do rewrite *gomock.Call.Do

func (*IInvokeHashByHeightCall) DoAndReturn

func (c *IInvokeHashByHeightCall) DoAndReturn(f func(context.Context, uint64) ([]byte, error)) *IInvokeHashByHeightCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IInvokeHashByHeightCall) Return

func (c *IInvokeHashByHeightCall) Return(arg0 []byte, arg1 error) *IInvokeHashByHeightCall

Return rewrite *gomock.Call.Return

type IInvokeIsNoRowsCall

type IInvokeIsNoRowsCall struct {
	*gomock.Call
}

IInvokeIsNoRowsCall wrap *gomock.Call

func (*IInvokeIsNoRowsCall) Do

func (c *IInvokeIsNoRowsCall) Do(f func(error) bool) *IInvokeIsNoRowsCall

Do rewrite *gomock.Call.Do

func (*IInvokeIsNoRowsCall) DoAndReturn

func (c *IInvokeIsNoRowsCall) DoAndReturn(f func(error) bool) *IInvokeIsNoRowsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IInvokeIsNoRowsCall) Return

func (c *IInvokeIsNoRowsCall) Return(arg0 bool) *IInvokeIsNoRowsCall

Return rewrite *gomock.Call.Return

type IInvokeLastIDCall

type IInvokeLastIDCall struct {
	*gomock.Call
}

IInvokeLastIDCall wrap *gomock.Call

func (*IInvokeLastIDCall) Do

func (c *IInvokeLastIDCall) Do(f func(context.Context) (uint64, error)) *IInvokeLastIDCall

Do rewrite *gomock.Call.Do

func (*IInvokeLastIDCall) DoAndReturn

func (c *IInvokeLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IInvokeLastIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IInvokeLastIDCall) Return

func (c *IInvokeLastIDCall) Return(arg0 uint64, arg1 error) *IInvokeLastIDCall

Return rewrite *gomock.Call.Return

type IInvokeListCall

type IInvokeListCall struct {
	*gomock.Call
}

IInvokeListCall wrap *gomock.Call

func (*IInvokeListCall) Do

func (c *IInvokeListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Invoke, error)) *IInvokeListCall

Do rewrite *gomock.Call.Do

func (*IInvokeListCall) DoAndReturn

func (c *IInvokeListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Invoke, error)) *IInvokeListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IInvokeListCall) Return

func (c *IInvokeListCall) Return(arg0 []*storage.Invoke, arg1 error) *IInvokeListCall

Return rewrite *gomock.Call.Return

type IInvokeSaveCall

type IInvokeSaveCall struct {
	*gomock.Call
}

IInvokeSaveCall wrap *gomock.Call

func (*IInvokeSaveCall) Do

func (c *IInvokeSaveCall) Do(f func(context.Context, *storage.Invoke) error) *IInvokeSaveCall

Do rewrite *gomock.Call.Do

func (*IInvokeSaveCall) DoAndReturn

func (c *IInvokeSaveCall) DoAndReturn(f func(context.Context, *storage.Invoke) error) *IInvokeSaveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IInvokeSaveCall) Return

func (c *IInvokeSaveCall) Return(arg0 error) *IInvokeSaveCall

Return rewrite *gomock.Call.Return

type IInvokeUpdateCall

type IInvokeUpdateCall struct {
	*gomock.Call
}

IInvokeUpdateCall wrap *gomock.Call

func (*IInvokeUpdateCall) Do

func (c *IInvokeUpdateCall) Do(f func(context.Context, *storage.Invoke) error) *IInvokeUpdateCall

Do rewrite *gomock.Call.Do

func (*IInvokeUpdateCall) DoAndReturn

func (c *IInvokeUpdateCall) DoAndReturn(f func(context.Context, *storage.Invoke) error) *IInvokeUpdateCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IInvokeUpdateCall) Return

func (c *IInvokeUpdateCall) Return(arg0 error) *IInvokeUpdateCall

Return rewrite *gomock.Call.Return

type IL1HandlerCursorListCall

type IL1HandlerCursorListCall struct {
	*gomock.Call
}

IL1HandlerCursorListCall wrap *gomock.Call

func (*IL1HandlerCursorListCall) Do

func (c *IL1HandlerCursorListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.L1Handler, error)) *IL1HandlerCursorListCall

Do rewrite *gomock.Call.Do

func (*IL1HandlerCursorListCall) DoAndReturn

func (c *IL1HandlerCursorListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.L1Handler, error)) *IL1HandlerCursorListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IL1HandlerCursorListCall) Return

func (c *IL1HandlerCursorListCall) Return(arg0 []*storage.L1Handler, arg1 error) *IL1HandlerCursorListCall

Return rewrite *gomock.Call.Return

type IL1HandlerFilterCall

type IL1HandlerFilterCall struct {
	*gomock.Call
}

IL1HandlerFilterCall wrap *gomock.Call

func (*IL1HandlerFilterCall) Do

func (c *IL1HandlerFilterCall) Do(f func(context.Context, []storage.L1HandlerFilter, ...storage.FilterOption) ([]storage.L1Handler, error)) *IL1HandlerFilterCall

Do rewrite *gomock.Call.Do

func (*IL1HandlerFilterCall) DoAndReturn

func (c *IL1HandlerFilterCall) DoAndReturn(f func(context.Context, []storage.L1HandlerFilter, ...storage.FilterOption) ([]storage.L1Handler, error)) *IL1HandlerFilterCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IL1HandlerFilterCall) Return

func (c *IL1HandlerFilterCall) Return(arg0 []storage.L1Handler, arg1 error) *IL1HandlerFilterCall

Return rewrite *gomock.Call.Return

type IL1HandlerGetByIDCall

type IL1HandlerGetByIDCall struct {
	*gomock.Call
}

IL1HandlerGetByIDCall wrap *gomock.Call

func (*IL1HandlerGetByIDCall) Do

func (c *IL1HandlerGetByIDCall) Do(f func(context.Context, uint64) (*storage.L1Handler, error)) *IL1HandlerGetByIDCall

Do rewrite *gomock.Call.Do

func (*IL1HandlerGetByIDCall) DoAndReturn

func (c *IL1HandlerGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.L1Handler, error)) *IL1HandlerGetByIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IL1HandlerGetByIDCall) Return

func (c *IL1HandlerGetByIDCall) Return(arg0 *storage.L1Handler, arg1 error) *IL1HandlerGetByIDCall

Return rewrite *gomock.Call.Return

type IL1HandlerIsNoRowsCall

type IL1HandlerIsNoRowsCall struct {
	*gomock.Call
}

IL1HandlerIsNoRowsCall wrap *gomock.Call

func (*IL1HandlerIsNoRowsCall) Do

func (c *IL1HandlerIsNoRowsCall) Do(f func(error) bool) *IL1HandlerIsNoRowsCall

Do rewrite *gomock.Call.Do

func (*IL1HandlerIsNoRowsCall) DoAndReturn

func (c *IL1HandlerIsNoRowsCall) DoAndReturn(f func(error) bool) *IL1HandlerIsNoRowsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IL1HandlerIsNoRowsCall) Return

func (c *IL1HandlerIsNoRowsCall) Return(arg0 bool) *IL1HandlerIsNoRowsCall

Return rewrite *gomock.Call.Return

type IL1HandlerLastIDCall

type IL1HandlerLastIDCall struct {
	*gomock.Call
}

IL1HandlerLastIDCall wrap *gomock.Call

func (*IL1HandlerLastIDCall) Do

func (c *IL1HandlerLastIDCall) Do(f func(context.Context) (uint64, error)) *IL1HandlerLastIDCall

Do rewrite *gomock.Call.Do

func (*IL1HandlerLastIDCall) DoAndReturn

func (c *IL1HandlerLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IL1HandlerLastIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IL1HandlerLastIDCall) Return

func (c *IL1HandlerLastIDCall) Return(arg0 uint64, arg1 error) *IL1HandlerLastIDCall

Return rewrite *gomock.Call.Return

type IL1HandlerListCall

type IL1HandlerListCall struct {
	*gomock.Call
}

IL1HandlerListCall wrap *gomock.Call

func (*IL1HandlerListCall) Do

func (c *IL1HandlerListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.L1Handler, error)) *IL1HandlerListCall

Do rewrite *gomock.Call.Do

func (*IL1HandlerListCall) DoAndReturn

func (c *IL1HandlerListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.L1Handler, error)) *IL1HandlerListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IL1HandlerListCall) Return

func (c *IL1HandlerListCall) Return(arg0 []*storage.L1Handler, arg1 error) *IL1HandlerListCall

Return rewrite *gomock.Call.Return

type IL1HandlerSaveCall

type IL1HandlerSaveCall struct {
	*gomock.Call
}

IL1HandlerSaveCall wrap *gomock.Call

func (*IL1HandlerSaveCall) Do

func (c *IL1HandlerSaveCall) Do(f func(context.Context, *storage.L1Handler) error) *IL1HandlerSaveCall

Do rewrite *gomock.Call.Do

func (*IL1HandlerSaveCall) DoAndReturn

func (c *IL1HandlerSaveCall) DoAndReturn(f func(context.Context, *storage.L1Handler) error) *IL1HandlerSaveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IL1HandlerSaveCall) Return

func (c *IL1HandlerSaveCall) Return(arg0 error) *IL1HandlerSaveCall

Return rewrite *gomock.Call.Return

type IL1HandlerUpdateCall

type IL1HandlerUpdateCall struct {
	*gomock.Call
}

IL1HandlerUpdateCall wrap *gomock.Call

func (*IL1HandlerUpdateCall) Do

func (c *IL1HandlerUpdateCall) Do(f func(context.Context, *storage.L1Handler) error) *IL1HandlerUpdateCall

Do rewrite *gomock.Call.Do

func (*IL1HandlerUpdateCall) DoAndReturn

func (c *IL1HandlerUpdateCall) DoAndReturn(f func(context.Context, *storage.L1Handler) error) *IL1HandlerUpdateCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IL1HandlerUpdateCall) Return

func (c *IL1HandlerUpdateCall) Return(arg0 error) *IL1HandlerUpdateCall

Return rewrite *gomock.Call.Return

type IMessageCursorListCall

type IMessageCursorListCall struct {
	*gomock.Call
}

IMessageCursorListCall wrap *gomock.Call

func (*IMessageCursorListCall) Do

func (c *IMessageCursorListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Message, error)) *IMessageCursorListCall

Do rewrite *gomock.Call.Do

func (*IMessageCursorListCall) DoAndReturn

func (c *IMessageCursorListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Message, error)) *IMessageCursorListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IMessageCursorListCall) Return

func (c *IMessageCursorListCall) Return(arg0 []*storage.Message, arg1 error) *IMessageCursorListCall

Return rewrite *gomock.Call.Return

type IMessageFilterCall

type IMessageFilterCall struct {
	*gomock.Call
}

IMessageFilterCall wrap *gomock.Call

func (*IMessageFilterCall) Do

func (c *IMessageFilterCall) Do(f func(context.Context, []storage.MessageFilter, ...storage.FilterOption) ([]storage.Message, error)) *IMessageFilterCall

Do rewrite *gomock.Call.Do

func (*IMessageFilterCall) DoAndReturn

func (c *IMessageFilterCall) DoAndReturn(f func(context.Context, []storage.MessageFilter, ...storage.FilterOption) ([]storage.Message, error)) *IMessageFilterCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IMessageFilterCall) Return

func (c *IMessageFilterCall) Return(arg0 []storage.Message, arg1 error) *IMessageFilterCall

Return rewrite *gomock.Call.Return

type IMessageGetByIDCall

type IMessageGetByIDCall struct {
	*gomock.Call
}

IMessageGetByIDCall wrap *gomock.Call

func (*IMessageGetByIDCall) Do

func (c *IMessageGetByIDCall) Do(f func(context.Context, uint64) (*storage.Message, error)) *IMessageGetByIDCall

Do rewrite *gomock.Call.Do

func (*IMessageGetByIDCall) DoAndReturn

func (c *IMessageGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Message, error)) *IMessageGetByIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IMessageGetByIDCall) Return

func (c *IMessageGetByIDCall) Return(arg0 *storage.Message, arg1 error) *IMessageGetByIDCall

Return rewrite *gomock.Call.Return

type IMessageIsNoRowsCall

type IMessageIsNoRowsCall struct {
	*gomock.Call
}

IMessageIsNoRowsCall wrap *gomock.Call

func (*IMessageIsNoRowsCall) Do

func (c *IMessageIsNoRowsCall) Do(f func(error) bool) *IMessageIsNoRowsCall

Do rewrite *gomock.Call.Do

func (*IMessageIsNoRowsCall) DoAndReturn

func (c *IMessageIsNoRowsCall) DoAndReturn(f func(error) bool) *IMessageIsNoRowsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IMessageIsNoRowsCall) Return

func (c *IMessageIsNoRowsCall) Return(arg0 bool) *IMessageIsNoRowsCall

Return rewrite *gomock.Call.Return

type IMessageLastIDCall

type IMessageLastIDCall struct {
	*gomock.Call
}

IMessageLastIDCall wrap *gomock.Call

func (*IMessageLastIDCall) Do

func (c *IMessageLastIDCall) Do(f func(context.Context) (uint64, error)) *IMessageLastIDCall

Do rewrite *gomock.Call.Do

func (*IMessageLastIDCall) DoAndReturn

func (c *IMessageLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IMessageLastIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IMessageLastIDCall) Return

func (c *IMessageLastIDCall) Return(arg0 uint64, arg1 error) *IMessageLastIDCall

Return rewrite *gomock.Call.Return

type IMessageListCall

type IMessageListCall struct {
	*gomock.Call
}

IMessageListCall wrap *gomock.Call

func (*IMessageListCall) Do

func (c *IMessageListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Message, error)) *IMessageListCall

Do rewrite *gomock.Call.Do

func (*IMessageListCall) DoAndReturn

func (c *IMessageListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Message, error)) *IMessageListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IMessageListCall) Return

func (c *IMessageListCall) Return(arg0 []*storage.Message, arg1 error) *IMessageListCall

Return rewrite *gomock.Call.Return

type IMessageSaveCall

type IMessageSaveCall struct {
	*gomock.Call
}

IMessageSaveCall wrap *gomock.Call

func (*IMessageSaveCall) Do

func (c *IMessageSaveCall) Do(f func(context.Context, *storage.Message) error) *IMessageSaveCall

Do rewrite *gomock.Call.Do

func (*IMessageSaveCall) DoAndReturn

func (c *IMessageSaveCall) DoAndReturn(f func(context.Context, *storage.Message) error) *IMessageSaveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IMessageSaveCall) Return

func (c *IMessageSaveCall) Return(arg0 error) *IMessageSaveCall

Return rewrite *gomock.Call.Return

type IMessageUpdateCall

type IMessageUpdateCall struct {
	*gomock.Call
}

IMessageUpdateCall wrap *gomock.Call

func (*IMessageUpdateCall) Do

func (c *IMessageUpdateCall) Do(f func(context.Context, *storage.Message) error) *IMessageUpdateCall

Do rewrite *gomock.Call.Do

func (*IMessageUpdateCall) DoAndReturn

func (c *IMessageUpdateCall) DoAndReturn(f func(context.Context, *storage.Message) error) *IMessageUpdateCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IMessageUpdateCall) Return

func (c *IMessageUpdateCall) Return(arg0 error) *IMessageUpdateCall

Return rewrite *gomock.Call.Return

type IProxyCursorListCall

type IProxyCursorListCall struct {
	*gomock.Call
}

IProxyCursorListCall wrap *gomock.Call

func (*IProxyCursorListCall) Do

func (c *IProxyCursorListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Proxy, error)) *IProxyCursorListCall

Do rewrite *gomock.Call.Do

func (*IProxyCursorListCall) DoAndReturn

func (c *IProxyCursorListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Proxy, error)) *IProxyCursorListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IProxyCursorListCall) Return

func (c *IProxyCursorListCall) Return(arg0 []*storage.Proxy, arg1 error) *IProxyCursorListCall

Return rewrite *gomock.Call.Return

type IProxyGetByHashCall

type IProxyGetByHashCall struct {
	*gomock.Call
}

IProxyGetByHashCall wrap *gomock.Call

func (*IProxyGetByHashCall) Do

func (c *IProxyGetByHashCall) Do(f func(context.Context, []byte, []byte) (storage.Proxy, error)) *IProxyGetByHashCall

Do rewrite *gomock.Call.Do

func (*IProxyGetByHashCall) DoAndReturn

func (c *IProxyGetByHashCall) DoAndReturn(f func(context.Context, []byte, []byte) (storage.Proxy, error)) *IProxyGetByHashCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IProxyGetByHashCall) Return

func (c *IProxyGetByHashCall) Return(arg0 storage.Proxy, arg1 error) *IProxyGetByHashCall

Return rewrite *gomock.Call.Return

type IProxyGetByIDCall

type IProxyGetByIDCall struct {
	*gomock.Call
}

IProxyGetByIDCall wrap *gomock.Call

func (*IProxyGetByIDCall) Do

func (c *IProxyGetByIDCall) Do(f func(context.Context, uint64) (*storage.Proxy, error)) *IProxyGetByIDCall

Do rewrite *gomock.Call.Do

func (*IProxyGetByIDCall) DoAndReturn

func (c *IProxyGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Proxy, error)) *IProxyGetByIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IProxyGetByIDCall) Return

func (c *IProxyGetByIDCall) Return(arg0 *storage.Proxy, arg1 error) *IProxyGetByIDCall

Return rewrite *gomock.Call.Return

type IProxyIsNoRowsCall

type IProxyIsNoRowsCall struct {
	*gomock.Call
}

IProxyIsNoRowsCall wrap *gomock.Call

func (*IProxyIsNoRowsCall) Do

func (c *IProxyIsNoRowsCall) Do(f func(error) bool) *IProxyIsNoRowsCall

Do rewrite *gomock.Call.Do

func (*IProxyIsNoRowsCall) DoAndReturn

func (c *IProxyIsNoRowsCall) DoAndReturn(f func(error) bool) *IProxyIsNoRowsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IProxyIsNoRowsCall) Return

func (c *IProxyIsNoRowsCall) Return(arg0 bool) *IProxyIsNoRowsCall

Return rewrite *gomock.Call.Return

type IProxyLastIDCall

type IProxyLastIDCall struct {
	*gomock.Call
}

IProxyLastIDCall wrap *gomock.Call

func (*IProxyLastIDCall) Do

func (c *IProxyLastIDCall) Do(f func(context.Context) (uint64, error)) *IProxyLastIDCall

Do rewrite *gomock.Call.Do

func (*IProxyLastIDCall) DoAndReturn

func (c *IProxyLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IProxyLastIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IProxyLastIDCall) Return

func (c *IProxyLastIDCall) Return(arg0 uint64, arg1 error) *IProxyLastIDCall

Return rewrite *gomock.Call.Return

type IProxyListCall

type IProxyListCall struct {
	*gomock.Call
}

IProxyListCall wrap *gomock.Call

func (*IProxyListCall) Do

func (c *IProxyListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Proxy, error)) *IProxyListCall

Do rewrite *gomock.Call.Do

func (*IProxyListCall) DoAndReturn

func (c *IProxyListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Proxy, error)) *IProxyListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IProxyListCall) Return

func (c *IProxyListCall) Return(arg0 []*storage.Proxy, arg1 error) *IProxyListCall

Return rewrite *gomock.Call.Return

type IProxySaveCall

type IProxySaveCall struct {
	*gomock.Call
}

IProxySaveCall wrap *gomock.Call

func (*IProxySaveCall) Do

func (c *IProxySaveCall) Do(f func(context.Context, *storage.Proxy) error) *IProxySaveCall

Do rewrite *gomock.Call.Do

func (*IProxySaveCall) DoAndReturn

func (c *IProxySaveCall) DoAndReturn(f func(context.Context, *storage.Proxy) error) *IProxySaveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IProxySaveCall) Return

func (c *IProxySaveCall) Return(arg0 error) *IProxySaveCall

Return rewrite *gomock.Call.Return

type IProxyUpdateCall

type IProxyUpdateCall struct {
	*gomock.Call
}

IProxyUpdateCall wrap *gomock.Call

func (*IProxyUpdateCall) Do

func (c *IProxyUpdateCall) Do(f func(context.Context, *storage.Proxy) error) *IProxyUpdateCall

Do rewrite *gomock.Call.Do

func (*IProxyUpdateCall) DoAndReturn

func (c *IProxyUpdateCall) DoAndReturn(f func(context.Context, *storage.Proxy) error) *IProxyUpdateCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IProxyUpdateCall) Return

func (c *IProxyUpdateCall) Return(arg0 error) *IProxyUpdateCall

Return rewrite *gomock.Call.Return

type IProxyUpgradeCursorListCall

type IProxyUpgradeCursorListCall struct {
	*gomock.Call
}

IProxyUpgradeCursorListCall wrap *gomock.Call

func (*IProxyUpgradeCursorListCall) Do

func (c *IProxyUpgradeCursorListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.ProxyUpgrade, error)) *IProxyUpgradeCursorListCall

Do rewrite *gomock.Call.Do

func (*IProxyUpgradeCursorListCall) DoAndReturn

func (c *IProxyUpgradeCursorListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.ProxyUpgrade, error)) *IProxyUpgradeCursorListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IProxyUpgradeCursorListCall) Return

func (c *IProxyUpgradeCursorListCall) Return(arg0 []*storage.ProxyUpgrade, arg1 error) *IProxyUpgradeCursorListCall

Return rewrite *gomock.Call.Return

type IProxyUpgradeGetByIDCall

type IProxyUpgradeGetByIDCall struct {
	*gomock.Call
}

IProxyUpgradeGetByIDCall wrap *gomock.Call

func (*IProxyUpgradeGetByIDCall) Do

func (c *IProxyUpgradeGetByIDCall) Do(f func(context.Context, uint64) (*storage.ProxyUpgrade, error)) *IProxyUpgradeGetByIDCall

Do rewrite *gomock.Call.Do

func (*IProxyUpgradeGetByIDCall) DoAndReturn

func (c *IProxyUpgradeGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.ProxyUpgrade, error)) *IProxyUpgradeGetByIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IProxyUpgradeGetByIDCall) Return

func (c *IProxyUpgradeGetByIDCall) Return(arg0 *storage.ProxyUpgrade, arg1 error) *IProxyUpgradeGetByIDCall

Return rewrite *gomock.Call.Return

type IProxyUpgradeIsNoRowsCall

type IProxyUpgradeIsNoRowsCall struct {
	*gomock.Call
}

IProxyUpgradeIsNoRowsCall wrap *gomock.Call

func (*IProxyUpgradeIsNoRowsCall) Do

func (c *IProxyUpgradeIsNoRowsCall) Do(f func(error) bool) *IProxyUpgradeIsNoRowsCall

Do rewrite *gomock.Call.Do

func (*IProxyUpgradeIsNoRowsCall) DoAndReturn

func (c *IProxyUpgradeIsNoRowsCall) DoAndReturn(f func(error) bool) *IProxyUpgradeIsNoRowsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IProxyUpgradeIsNoRowsCall) Return

func (c *IProxyUpgradeIsNoRowsCall) Return(arg0 bool) *IProxyUpgradeIsNoRowsCall

Return rewrite *gomock.Call.Return

type IProxyUpgradeLastBeforeCall

type IProxyUpgradeLastBeforeCall struct {
	*gomock.Call
}

IProxyUpgradeLastBeforeCall wrap *gomock.Call

func (*IProxyUpgradeLastBeforeCall) Do

func (c *IProxyUpgradeLastBeforeCall) Do(f func(context.Context, []byte, []byte, uint64) (storage.ProxyUpgrade, error)) *IProxyUpgradeLastBeforeCall

Do rewrite *gomock.Call.Do

func (*IProxyUpgradeLastBeforeCall) DoAndReturn

func (c *IProxyUpgradeLastBeforeCall) DoAndReturn(f func(context.Context, []byte, []byte, uint64) (storage.ProxyUpgrade, error)) *IProxyUpgradeLastBeforeCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IProxyUpgradeLastBeforeCall) Return

func (c *IProxyUpgradeLastBeforeCall) Return(arg0 storage.ProxyUpgrade, arg1 error) *IProxyUpgradeLastBeforeCall

Return rewrite *gomock.Call.Return

type IProxyUpgradeLastIDCall

type IProxyUpgradeLastIDCall struct {
	*gomock.Call
}

IProxyUpgradeLastIDCall wrap *gomock.Call

func (*IProxyUpgradeLastIDCall) Do

func (c *IProxyUpgradeLastIDCall) Do(f func(context.Context) (uint64, error)) *IProxyUpgradeLastIDCall

Do rewrite *gomock.Call.Do

func (*IProxyUpgradeLastIDCall) DoAndReturn

func (c *IProxyUpgradeLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IProxyUpgradeLastIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IProxyUpgradeLastIDCall) Return

func (c *IProxyUpgradeLastIDCall) Return(arg0 uint64, arg1 error) *IProxyUpgradeLastIDCall

Return rewrite *gomock.Call.Return

type IProxyUpgradeListCall

type IProxyUpgradeListCall struct {
	*gomock.Call
}

IProxyUpgradeListCall wrap *gomock.Call

func (*IProxyUpgradeListCall) Do

func (c *IProxyUpgradeListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.ProxyUpgrade, error)) *IProxyUpgradeListCall

Do rewrite *gomock.Call.Do

func (*IProxyUpgradeListCall) DoAndReturn

func (c *IProxyUpgradeListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.ProxyUpgrade, error)) *IProxyUpgradeListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IProxyUpgradeListCall) Return

func (c *IProxyUpgradeListCall) Return(arg0 []*storage.ProxyUpgrade, arg1 error) *IProxyUpgradeListCall

Return rewrite *gomock.Call.Return

type IProxyUpgradeListWithHeightCall

type IProxyUpgradeListWithHeightCall struct {
	*gomock.Call
}

IProxyUpgradeListWithHeightCall wrap *gomock.Call

func (*IProxyUpgradeListWithHeightCall) Do

func (c *IProxyUpgradeListWithHeightCall) Do(f func(context.Context, uint64, int, int) ([]storage.ProxyUpgrade, error)) *IProxyUpgradeListWithHeightCall

Do rewrite *gomock.Call.Do

func (*IProxyUpgradeListWithHeightCall) DoAndReturn

func (c *IProxyUpgradeListWithHeightCall) DoAndReturn(f func(context.Context, uint64, int, int) ([]storage.ProxyUpgrade, error)) *IProxyUpgradeListWithHeightCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IProxyUpgradeListWithHeightCall) Return

func (c *IProxyUpgradeListWithHeightCall) Return(arg0 []storage.ProxyUpgrade, arg1 error) *IProxyUpgradeListWithHeightCall

Return rewrite *gomock.Call.Return

type IProxyUpgradeSaveCall

type IProxyUpgradeSaveCall struct {
	*gomock.Call
}

IProxyUpgradeSaveCall wrap *gomock.Call

func (*IProxyUpgradeSaveCall) Do

func (c *IProxyUpgradeSaveCall) Do(f func(context.Context, *storage.ProxyUpgrade) error) *IProxyUpgradeSaveCall

Do rewrite *gomock.Call.Do

func (*IProxyUpgradeSaveCall) DoAndReturn

func (c *IProxyUpgradeSaveCall) DoAndReturn(f func(context.Context, *storage.ProxyUpgrade) error) *IProxyUpgradeSaveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IProxyUpgradeSaveCall) Return

func (c *IProxyUpgradeSaveCall) Return(arg0 error) *IProxyUpgradeSaveCall

Return rewrite *gomock.Call.Return

type IProxyUpgradeUpdateCall

type IProxyUpgradeUpdateCall struct {
	*gomock.Call
}

IProxyUpgradeUpdateCall wrap *gomock.Call

func (*IProxyUpgradeUpdateCall) Do

func (c *IProxyUpgradeUpdateCall) Do(f func(context.Context, *storage.ProxyUpgrade) error) *IProxyUpgradeUpdateCall

Do rewrite *gomock.Call.Do

func (*IProxyUpgradeUpdateCall) DoAndReturn

func (c *IProxyUpgradeUpdateCall) DoAndReturn(f func(context.Context, *storage.ProxyUpgrade) error) *IProxyUpgradeUpdateCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IProxyUpgradeUpdateCall) Return

func (c *IProxyUpgradeUpdateCall) Return(arg0 error) *IProxyUpgradeUpdateCall

Return rewrite *gomock.Call.Return

type IStateByNameCall

type IStateByNameCall struct {
	*gomock.Call
}

IStateByNameCall wrap *gomock.Call

func (*IStateByNameCall) Do

func (c *IStateByNameCall) Do(f func(context.Context, string) (storage.State, error)) *IStateByNameCall

Do rewrite *gomock.Call.Do

func (*IStateByNameCall) DoAndReturn

func (c *IStateByNameCall) DoAndReturn(f func(context.Context, string) (storage.State, error)) *IStateByNameCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IStateByNameCall) Return

func (c *IStateByNameCall) Return(arg0 storage.State, arg1 error) *IStateByNameCall

Return rewrite *gomock.Call.Return

type IStateCursorListCall

type IStateCursorListCall struct {
	*gomock.Call
}

IStateCursorListCall wrap *gomock.Call

func (*IStateCursorListCall) Do

func (c *IStateCursorListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.State, error)) *IStateCursorListCall

Do rewrite *gomock.Call.Do

func (*IStateCursorListCall) DoAndReturn

func (c *IStateCursorListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.State, error)) *IStateCursorListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IStateCursorListCall) Return

func (c *IStateCursorListCall) Return(arg0 []*storage.State, arg1 error) *IStateCursorListCall

Return rewrite *gomock.Call.Return

type IStateGetByIDCall

type IStateGetByIDCall struct {
	*gomock.Call
}

IStateGetByIDCall wrap *gomock.Call

func (*IStateGetByIDCall) Do

func (c *IStateGetByIDCall) Do(f func(context.Context, uint64) (*storage.State, error)) *IStateGetByIDCall

Do rewrite *gomock.Call.Do

func (*IStateGetByIDCall) DoAndReturn

func (c *IStateGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.State, error)) *IStateGetByIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IStateGetByIDCall) Return

func (c *IStateGetByIDCall) Return(arg0 *storage.State, arg1 error) *IStateGetByIDCall

Return rewrite *gomock.Call.Return

type IStateIsNoRowsCall

type IStateIsNoRowsCall struct {
	*gomock.Call
}

IStateIsNoRowsCall wrap *gomock.Call

func (*IStateIsNoRowsCall) Do

func (c *IStateIsNoRowsCall) Do(f func(error) bool) *IStateIsNoRowsCall

Do rewrite *gomock.Call.Do

func (*IStateIsNoRowsCall) DoAndReturn

func (c *IStateIsNoRowsCall) DoAndReturn(f func(error) bool) *IStateIsNoRowsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IStateIsNoRowsCall) Return

func (c *IStateIsNoRowsCall) Return(arg0 bool) *IStateIsNoRowsCall

Return rewrite *gomock.Call.Return

type IStateLastIDCall

type IStateLastIDCall struct {
	*gomock.Call
}

IStateLastIDCall wrap *gomock.Call

func (*IStateLastIDCall) Do

func (c *IStateLastIDCall) Do(f func(context.Context) (uint64, error)) *IStateLastIDCall

Do rewrite *gomock.Call.Do

func (*IStateLastIDCall) DoAndReturn

func (c *IStateLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IStateLastIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IStateLastIDCall) Return

func (c *IStateLastIDCall) Return(arg0 uint64, arg1 error) *IStateLastIDCall

Return rewrite *gomock.Call.Return

type IStateListCall

type IStateListCall struct {
	*gomock.Call
}

IStateListCall wrap *gomock.Call

func (*IStateListCall) Do

func (c *IStateListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.State, error)) *IStateListCall

Do rewrite *gomock.Call.Do

func (*IStateListCall) DoAndReturn

func (c *IStateListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.State, error)) *IStateListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IStateListCall) Return

func (c *IStateListCall) Return(arg0 []*storage.State, arg1 error) *IStateListCall

Return rewrite *gomock.Call.Return

type IStateSaveCall

type IStateSaveCall struct {
	*gomock.Call
}

IStateSaveCall wrap *gomock.Call

func (*IStateSaveCall) Do

func (c *IStateSaveCall) Do(f func(context.Context, *storage.State) error) *IStateSaveCall

Do rewrite *gomock.Call.Do

func (*IStateSaveCall) DoAndReturn

func (c *IStateSaveCall) DoAndReturn(f func(context.Context, *storage.State) error) *IStateSaveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IStateSaveCall) Return

func (c *IStateSaveCall) Return(arg0 error) *IStateSaveCall

Return rewrite *gomock.Call.Return

type IStateUpdateCall

type IStateUpdateCall struct {
	*gomock.Call
}

IStateUpdateCall wrap *gomock.Call

func (*IStateUpdateCall) Do

func (c *IStateUpdateCall) Do(f func(context.Context, *storage.State) error) *IStateUpdateCall

Do rewrite *gomock.Call.Do

func (*IStateUpdateCall) DoAndReturn

func (c *IStateUpdateCall) DoAndReturn(f func(context.Context, *storage.State) error) *IStateUpdateCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IStateUpdateCall) Return

func (c *IStateUpdateCall) Return(arg0 error) *IStateUpdateCall

Return rewrite *gomock.Call.Return

type IStorageDiffCursorListCall

type IStorageDiffCursorListCall struct {
	*gomock.Call
}

IStorageDiffCursorListCall wrap *gomock.Call

func (*IStorageDiffCursorListCall) Do

func (c *IStorageDiffCursorListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.StorageDiff, error)) *IStorageDiffCursorListCall

Do rewrite *gomock.Call.Do

func (*IStorageDiffCursorListCall) DoAndReturn

func (c *IStorageDiffCursorListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.StorageDiff, error)) *IStorageDiffCursorListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IStorageDiffCursorListCall) Return

func (c *IStorageDiffCursorListCall) Return(arg0 []*storage.StorageDiff, arg1 error) *IStorageDiffCursorListCall

Return rewrite *gomock.Call.Return

type IStorageDiffFilterCall

type IStorageDiffFilterCall struct {
	*gomock.Call
}

IStorageDiffFilterCall wrap *gomock.Call

func (*IStorageDiffFilterCall) Do

func (c *IStorageDiffFilterCall) Do(f func(context.Context, []storage.StorageDiffFilter, ...storage.FilterOption) ([]storage.StorageDiff, error)) *IStorageDiffFilterCall

Do rewrite *gomock.Call.Do

func (*IStorageDiffFilterCall) DoAndReturn

func (c *IStorageDiffFilterCall) DoAndReturn(f func(context.Context, []storage.StorageDiffFilter, ...storage.FilterOption) ([]storage.StorageDiff, error)) *IStorageDiffFilterCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IStorageDiffFilterCall) Return

func (c *IStorageDiffFilterCall) Return(arg0 []storage.StorageDiff, arg1 error) *IStorageDiffFilterCall

Return rewrite *gomock.Call.Return

type IStorageDiffGetByIDCall

type IStorageDiffGetByIDCall struct {
	*gomock.Call
}

IStorageDiffGetByIDCall wrap *gomock.Call

func (*IStorageDiffGetByIDCall) Do

func (c *IStorageDiffGetByIDCall) Do(f func(context.Context, uint64) (*storage.StorageDiff, error)) *IStorageDiffGetByIDCall

Do rewrite *gomock.Call.Do

func (*IStorageDiffGetByIDCall) DoAndReturn

func (c *IStorageDiffGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.StorageDiff, error)) *IStorageDiffGetByIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IStorageDiffGetByIDCall) Return

func (c *IStorageDiffGetByIDCall) Return(arg0 *storage.StorageDiff, arg1 error) *IStorageDiffGetByIDCall

Return rewrite *gomock.Call.Return

type IStorageDiffGetOnBlockCall

type IStorageDiffGetOnBlockCall struct {
	*gomock.Call
}

IStorageDiffGetOnBlockCall wrap *gomock.Call

func (*IStorageDiffGetOnBlockCall) Do

func (c *IStorageDiffGetOnBlockCall) Do(f func(context.Context, uint64, uint64, []byte) (storage.StorageDiff, error)) *IStorageDiffGetOnBlockCall

Do rewrite *gomock.Call.Do

func (*IStorageDiffGetOnBlockCall) DoAndReturn

func (c *IStorageDiffGetOnBlockCall) DoAndReturn(f func(context.Context, uint64, uint64, []byte) (storage.StorageDiff, error)) *IStorageDiffGetOnBlockCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IStorageDiffGetOnBlockCall) Return

func (c *IStorageDiffGetOnBlockCall) Return(arg0 storage.StorageDiff, arg1 error) *IStorageDiffGetOnBlockCall

Return rewrite *gomock.Call.Return

type IStorageDiffIsNoRowsCall

type IStorageDiffIsNoRowsCall struct {
	*gomock.Call
}

IStorageDiffIsNoRowsCall wrap *gomock.Call

func (*IStorageDiffIsNoRowsCall) Do

func (c *IStorageDiffIsNoRowsCall) Do(f func(error) bool) *IStorageDiffIsNoRowsCall

Do rewrite *gomock.Call.Do

func (*IStorageDiffIsNoRowsCall) DoAndReturn

func (c *IStorageDiffIsNoRowsCall) DoAndReturn(f func(error) bool) *IStorageDiffIsNoRowsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IStorageDiffIsNoRowsCall) Return

func (c *IStorageDiffIsNoRowsCall) Return(arg0 bool) *IStorageDiffIsNoRowsCall

Return rewrite *gomock.Call.Return

type IStorageDiffLastIDCall

type IStorageDiffLastIDCall struct {
	*gomock.Call
}

IStorageDiffLastIDCall wrap *gomock.Call

func (*IStorageDiffLastIDCall) Do

func (c *IStorageDiffLastIDCall) Do(f func(context.Context) (uint64, error)) *IStorageDiffLastIDCall

Do rewrite *gomock.Call.Do

func (*IStorageDiffLastIDCall) DoAndReturn

func (c *IStorageDiffLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *IStorageDiffLastIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IStorageDiffLastIDCall) Return

func (c *IStorageDiffLastIDCall) Return(arg0 uint64, arg1 error) *IStorageDiffLastIDCall

Return rewrite *gomock.Call.Return

type IStorageDiffListCall

type IStorageDiffListCall struct {
	*gomock.Call
}

IStorageDiffListCall wrap *gomock.Call

func (*IStorageDiffListCall) Do

func (c *IStorageDiffListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.StorageDiff, error)) *IStorageDiffListCall

Do rewrite *gomock.Call.Do

func (*IStorageDiffListCall) DoAndReturn

func (c *IStorageDiffListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.StorageDiff, error)) *IStorageDiffListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IStorageDiffListCall) Return

func (c *IStorageDiffListCall) Return(arg0 []*storage.StorageDiff, arg1 error) *IStorageDiffListCall

Return rewrite *gomock.Call.Return

type IStorageDiffSaveCall

type IStorageDiffSaveCall struct {
	*gomock.Call
}

IStorageDiffSaveCall wrap *gomock.Call

func (*IStorageDiffSaveCall) Do

func (c *IStorageDiffSaveCall) Do(f func(context.Context, *storage.StorageDiff) error) *IStorageDiffSaveCall

Do rewrite *gomock.Call.Do

func (*IStorageDiffSaveCall) DoAndReturn

func (c *IStorageDiffSaveCall) DoAndReturn(f func(context.Context, *storage.StorageDiff) error) *IStorageDiffSaveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IStorageDiffSaveCall) Return

func (c *IStorageDiffSaveCall) Return(arg0 error) *IStorageDiffSaveCall

Return rewrite *gomock.Call.Return

type IStorageDiffUpdateCall

type IStorageDiffUpdateCall struct {
	*gomock.Call
}

IStorageDiffUpdateCall wrap *gomock.Call

func (*IStorageDiffUpdateCall) Do

func (c *IStorageDiffUpdateCall) Do(f func(context.Context, *storage.StorageDiff) error) *IStorageDiffUpdateCall

Do rewrite *gomock.Call.Do

func (*IStorageDiffUpdateCall) DoAndReturn

func (c *IStorageDiffUpdateCall) DoAndReturn(f func(context.Context, *storage.StorageDiff) error) *IStorageDiffUpdateCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*IStorageDiffUpdateCall) Return

func (c *IStorageDiffUpdateCall) Return(arg0 error) *IStorageDiffUpdateCall

Return rewrite *gomock.Call.Return

type ITokenBalanceBalancesCall

type ITokenBalanceBalancesCall struct {
	*gomock.Call
}

ITokenBalanceBalancesCall wrap *gomock.Call

func (*ITokenBalanceBalancesCall) Do

func (c *ITokenBalanceBalancesCall) Do(f func(context.Context, uint64, int64, int, int) ([]storage.TokenBalance, error)) *ITokenBalanceBalancesCall

Do rewrite *gomock.Call.Do

func (*ITokenBalanceBalancesCall) DoAndReturn

func (c *ITokenBalanceBalancesCall) DoAndReturn(f func(context.Context, uint64, int64, int, int) ([]storage.TokenBalance, error)) *ITokenBalanceBalancesCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITokenBalanceBalancesCall) Return

func (c *ITokenBalanceBalancesCall) Return(arg0 []storage.TokenBalance, arg1 error) *ITokenBalanceBalancesCall

Return rewrite *gomock.Call.Return

type ITokenBalanceCursorListCall

type ITokenBalanceCursorListCall struct {
	*gomock.Call
}

ITokenBalanceCursorListCall wrap *gomock.Call

func (*ITokenBalanceCursorListCall) Do

func (c *ITokenBalanceCursorListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.TokenBalance, error)) *ITokenBalanceCursorListCall

Do rewrite *gomock.Call.Do

func (*ITokenBalanceCursorListCall) DoAndReturn

func (c *ITokenBalanceCursorListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.TokenBalance, error)) *ITokenBalanceCursorListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITokenBalanceCursorListCall) Return

func (c *ITokenBalanceCursorListCall) Return(arg0 []*storage.TokenBalance, arg1 error) *ITokenBalanceCursorListCall

Return rewrite *gomock.Call.Return

type ITokenBalanceFilterCall

type ITokenBalanceFilterCall struct {
	*gomock.Call
}

ITokenBalanceFilterCall wrap *gomock.Call

func (*ITokenBalanceFilterCall) Do

func (c *ITokenBalanceFilterCall) Do(f func(context.Context, []storage.TokenBalanceFilter, ...storage.FilterOption) ([]storage.TokenBalance, error)) *ITokenBalanceFilterCall

Do rewrite *gomock.Call.Do

func (*ITokenBalanceFilterCall) DoAndReturn

func (c *ITokenBalanceFilterCall) DoAndReturn(f func(context.Context, []storage.TokenBalanceFilter, ...storage.FilterOption) ([]storage.TokenBalance, error)) *ITokenBalanceFilterCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITokenBalanceFilterCall) Return

func (c *ITokenBalanceFilterCall) Return(arg0 []storage.TokenBalance, arg1 error) *ITokenBalanceFilterCall

Return rewrite *gomock.Call.Return

type ITokenBalanceGetByIDCall

type ITokenBalanceGetByIDCall struct {
	*gomock.Call
}

ITokenBalanceGetByIDCall wrap *gomock.Call

func (*ITokenBalanceGetByIDCall) Do

func (c *ITokenBalanceGetByIDCall) Do(f func(context.Context, uint64) (*storage.TokenBalance, error)) *ITokenBalanceGetByIDCall

Do rewrite *gomock.Call.Do

func (*ITokenBalanceGetByIDCall) DoAndReturn

func (c *ITokenBalanceGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.TokenBalance, error)) *ITokenBalanceGetByIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITokenBalanceGetByIDCall) Return

func (c *ITokenBalanceGetByIDCall) Return(arg0 *storage.TokenBalance, arg1 error) *ITokenBalanceGetByIDCall

Return rewrite *gomock.Call.Return

type ITokenBalanceIsNoRowsCall

type ITokenBalanceIsNoRowsCall struct {
	*gomock.Call
}

ITokenBalanceIsNoRowsCall wrap *gomock.Call

func (*ITokenBalanceIsNoRowsCall) Do

func (c *ITokenBalanceIsNoRowsCall) Do(f func(error) bool) *ITokenBalanceIsNoRowsCall

Do rewrite *gomock.Call.Do

func (*ITokenBalanceIsNoRowsCall) DoAndReturn

func (c *ITokenBalanceIsNoRowsCall) DoAndReturn(f func(error) bool) *ITokenBalanceIsNoRowsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITokenBalanceIsNoRowsCall) Return

func (c *ITokenBalanceIsNoRowsCall) Return(arg0 bool) *ITokenBalanceIsNoRowsCall

Return rewrite *gomock.Call.Return

type ITokenBalanceLastIDCall

type ITokenBalanceLastIDCall struct {
	*gomock.Call
}

ITokenBalanceLastIDCall wrap *gomock.Call

func (*ITokenBalanceLastIDCall) Do

func (c *ITokenBalanceLastIDCall) Do(f func(context.Context) (uint64, error)) *ITokenBalanceLastIDCall

Do rewrite *gomock.Call.Do

func (*ITokenBalanceLastIDCall) DoAndReturn

func (c *ITokenBalanceLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *ITokenBalanceLastIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITokenBalanceLastIDCall) Return

func (c *ITokenBalanceLastIDCall) Return(arg0 uint64, arg1 error) *ITokenBalanceLastIDCall

Return rewrite *gomock.Call.Return

type ITokenBalanceListCall

type ITokenBalanceListCall struct {
	*gomock.Call
}

ITokenBalanceListCall wrap *gomock.Call

func (*ITokenBalanceListCall) Do

func (c *ITokenBalanceListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.TokenBalance, error)) *ITokenBalanceListCall

Do rewrite *gomock.Call.Do

func (*ITokenBalanceListCall) DoAndReturn

func (c *ITokenBalanceListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.TokenBalance, error)) *ITokenBalanceListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITokenBalanceListCall) Return

func (c *ITokenBalanceListCall) Return(arg0 []*storage.TokenBalance, arg1 error) *ITokenBalanceListCall

Return rewrite *gomock.Call.Return

type ITokenBalanceSaveCall

type ITokenBalanceSaveCall struct {
	*gomock.Call
}

ITokenBalanceSaveCall wrap *gomock.Call

func (*ITokenBalanceSaveCall) Do

func (c *ITokenBalanceSaveCall) Do(f func(context.Context, *storage.TokenBalance) error) *ITokenBalanceSaveCall

Do rewrite *gomock.Call.Do

func (*ITokenBalanceSaveCall) DoAndReturn

func (c *ITokenBalanceSaveCall) DoAndReturn(f func(context.Context, *storage.TokenBalance) error) *ITokenBalanceSaveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITokenBalanceSaveCall) Return

func (c *ITokenBalanceSaveCall) Return(arg0 error) *ITokenBalanceSaveCall

Return rewrite *gomock.Call.Return

type ITokenBalanceUpdateCall

type ITokenBalanceUpdateCall struct {
	*gomock.Call
}

ITokenBalanceUpdateCall wrap *gomock.Call

func (*ITokenBalanceUpdateCall) Do

func (c *ITokenBalanceUpdateCall) Do(f func(context.Context, *storage.TokenBalance) error) *ITokenBalanceUpdateCall

Do rewrite *gomock.Call.Do

func (*ITokenBalanceUpdateCall) DoAndReturn

func (c *ITokenBalanceUpdateCall) DoAndReturn(f func(context.Context, *storage.TokenBalance) error) *ITokenBalanceUpdateCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITokenBalanceUpdateCall) Return

func (c *ITokenBalanceUpdateCall) Return(arg0 error) *ITokenBalanceUpdateCall

Return rewrite *gomock.Call.Return

type ITokenCursorListCall

type ITokenCursorListCall struct {
	*gomock.Call
}

ITokenCursorListCall wrap *gomock.Call

func (*ITokenCursorListCall) Do

func (c *ITokenCursorListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Token, error)) *ITokenCursorListCall

Do rewrite *gomock.Call.Do

func (*ITokenCursorListCall) DoAndReturn

func (c *ITokenCursorListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Token, error)) *ITokenCursorListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITokenCursorListCall) Return

func (c *ITokenCursorListCall) Return(arg0 []*storage.Token, arg1 error) *ITokenCursorListCall

Return rewrite *gomock.Call.Return

type ITokenFilterCall

type ITokenFilterCall struct {
	*gomock.Call
}

ITokenFilterCall wrap *gomock.Call

func (*ITokenFilterCall) Do

func (c *ITokenFilterCall) Do(f func(context.Context, []storage.TokenFilter, ...storage.FilterOption) ([]storage.Token, error)) *ITokenFilterCall

Do rewrite *gomock.Call.Do

func (*ITokenFilterCall) DoAndReturn

func (c *ITokenFilterCall) DoAndReturn(f func(context.Context, []storage.TokenFilter, ...storage.FilterOption) ([]storage.Token, error)) *ITokenFilterCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITokenFilterCall) Return

func (c *ITokenFilterCall) Return(arg0 []storage.Token, arg1 error) *ITokenFilterCall

Return rewrite *gomock.Call.Return

type ITokenFindCall

type ITokenFindCall struct {
	*gomock.Call
}

ITokenFindCall wrap *gomock.Call

func (*ITokenFindCall) Do

func (c *ITokenFindCall) Do(f func(context.Context, uint64, string) (storage.Token, error)) *ITokenFindCall

Do rewrite *gomock.Call.Do

func (*ITokenFindCall) DoAndReturn

func (c *ITokenFindCall) DoAndReturn(f func(context.Context, uint64, string) (storage.Token, error)) *ITokenFindCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITokenFindCall) Return

func (c *ITokenFindCall) Return(arg0 storage.Token, arg1 error) *ITokenFindCall

Return rewrite *gomock.Call.Return

type ITokenGetByIDCall

type ITokenGetByIDCall struct {
	*gomock.Call
}

ITokenGetByIDCall wrap *gomock.Call

func (*ITokenGetByIDCall) Do

func (c *ITokenGetByIDCall) Do(f func(context.Context, uint64) (*storage.Token, error)) *ITokenGetByIDCall

Do rewrite *gomock.Call.Do

func (*ITokenGetByIDCall) DoAndReturn

func (c *ITokenGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Token, error)) *ITokenGetByIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITokenGetByIDCall) Return

func (c *ITokenGetByIDCall) Return(arg0 *storage.Token, arg1 error) *ITokenGetByIDCall

Return rewrite *gomock.Call.Return

type ITokenIsNoRowsCall

type ITokenIsNoRowsCall struct {
	*gomock.Call
}

ITokenIsNoRowsCall wrap *gomock.Call

func (*ITokenIsNoRowsCall) Do

func (c *ITokenIsNoRowsCall) Do(f func(error) bool) *ITokenIsNoRowsCall

Do rewrite *gomock.Call.Do

func (*ITokenIsNoRowsCall) DoAndReturn

func (c *ITokenIsNoRowsCall) DoAndReturn(f func(error) bool) *ITokenIsNoRowsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITokenIsNoRowsCall) Return

func (c *ITokenIsNoRowsCall) Return(arg0 bool) *ITokenIsNoRowsCall

Return rewrite *gomock.Call.Return

type ITokenLastIDCall

type ITokenLastIDCall struct {
	*gomock.Call
}

ITokenLastIDCall wrap *gomock.Call

func (*ITokenLastIDCall) Do

func (c *ITokenLastIDCall) Do(f func(context.Context) (uint64, error)) *ITokenLastIDCall

Do rewrite *gomock.Call.Do

func (*ITokenLastIDCall) DoAndReturn

func (c *ITokenLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *ITokenLastIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITokenLastIDCall) Return

func (c *ITokenLastIDCall) Return(arg0 uint64, arg1 error) *ITokenLastIDCall

Return rewrite *gomock.Call.Return

type ITokenListByTypeCall

type ITokenListByTypeCall struct {
	*gomock.Call
}

ITokenListByTypeCall wrap *gomock.Call

func (*ITokenListByTypeCall) Do

func (c *ITokenListByTypeCall) Do(f func(context.Context, storage.TokenType, uint64, uint64, storage0.SortOrder) ([]storage.Token, error)) *ITokenListByTypeCall

Do rewrite *gomock.Call.Do

func (*ITokenListByTypeCall) DoAndReturn

func (c *ITokenListByTypeCall) DoAndReturn(f func(context.Context, storage.TokenType, uint64, uint64, storage0.SortOrder) ([]storage.Token, error)) *ITokenListByTypeCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITokenListByTypeCall) Return

func (c *ITokenListByTypeCall) Return(arg0 []storage.Token, arg1 error) *ITokenListByTypeCall

Return rewrite *gomock.Call.Return

type ITokenListCall

type ITokenListCall struct {
	*gomock.Call
}

ITokenListCall wrap *gomock.Call

func (*ITokenListCall) Do

func (c *ITokenListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Token, error)) *ITokenListCall

Do rewrite *gomock.Call.Do

func (*ITokenListCall) DoAndReturn

func (c *ITokenListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Token, error)) *ITokenListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITokenListCall) Return

func (c *ITokenListCall) Return(arg0 []*storage.Token, arg1 error) *ITokenListCall

Return rewrite *gomock.Call.Return

type ITokenSaveCall

type ITokenSaveCall struct {
	*gomock.Call
}

ITokenSaveCall wrap *gomock.Call

func (*ITokenSaveCall) Do

func (c *ITokenSaveCall) Do(f func(context.Context, *storage.Token) error) *ITokenSaveCall

Do rewrite *gomock.Call.Do

func (*ITokenSaveCall) DoAndReturn

func (c *ITokenSaveCall) DoAndReturn(f func(context.Context, *storage.Token) error) *ITokenSaveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITokenSaveCall) Return

func (c *ITokenSaveCall) Return(arg0 error) *ITokenSaveCall

Return rewrite *gomock.Call.Return

type ITokenUpdateCall

type ITokenUpdateCall struct {
	*gomock.Call
}

ITokenUpdateCall wrap *gomock.Call

func (*ITokenUpdateCall) Do

func (c *ITokenUpdateCall) Do(f func(context.Context, *storage.Token) error) *ITokenUpdateCall

Do rewrite *gomock.Call.Do

func (*ITokenUpdateCall) DoAndReturn

func (c *ITokenUpdateCall) DoAndReturn(f func(context.Context, *storage.Token) error) *ITokenUpdateCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITokenUpdateCall) Return

func (c *ITokenUpdateCall) Return(arg0 error) *ITokenUpdateCall

Return rewrite *gomock.Call.Return

type ITransferCursorListCall

type ITransferCursorListCall struct {
	*gomock.Call
}

ITransferCursorListCall wrap *gomock.Call

func (*ITransferCursorListCall) Do

func (c *ITransferCursorListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Transfer, error)) *ITransferCursorListCall

Do rewrite *gomock.Call.Do

func (*ITransferCursorListCall) DoAndReturn

func (c *ITransferCursorListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder, storage0.Comparator) ([]*storage.Transfer, error)) *ITransferCursorListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITransferCursorListCall) Return

func (c *ITransferCursorListCall) Return(arg0 []*storage.Transfer, arg1 error) *ITransferCursorListCall

Return rewrite *gomock.Call.Return

type ITransferFilterCall

type ITransferFilterCall struct {
	*gomock.Call
}

ITransferFilterCall wrap *gomock.Call

func (*ITransferFilterCall) Do

func (c *ITransferFilterCall) Do(f func(context.Context, []storage.TransferFilter, ...storage.FilterOption) ([]storage.Transfer, error)) *ITransferFilterCall

Do rewrite *gomock.Call.Do

func (*ITransferFilterCall) DoAndReturn

func (c *ITransferFilterCall) DoAndReturn(f func(context.Context, []storage.TransferFilter, ...storage.FilterOption) ([]storage.Transfer, error)) *ITransferFilterCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITransferFilterCall) Return

func (c *ITransferFilterCall) Return(arg0 []storage.Transfer, arg1 error) *ITransferFilterCall

Return rewrite *gomock.Call.Return

type ITransferGetByIDCall

type ITransferGetByIDCall struct {
	*gomock.Call
}

ITransferGetByIDCall wrap *gomock.Call

func (*ITransferGetByIDCall) Do

func (c *ITransferGetByIDCall) Do(f func(context.Context, uint64) (*storage.Transfer, error)) *ITransferGetByIDCall

Do rewrite *gomock.Call.Do

func (*ITransferGetByIDCall) DoAndReturn

func (c *ITransferGetByIDCall) DoAndReturn(f func(context.Context, uint64) (*storage.Transfer, error)) *ITransferGetByIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITransferGetByIDCall) Return

func (c *ITransferGetByIDCall) Return(arg0 *storage.Transfer, arg1 error) *ITransferGetByIDCall

Return rewrite *gomock.Call.Return

type ITransferIsNoRowsCall

type ITransferIsNoRowsCall struct {
	*gomock.Call
}

ITransferIsNoRowsCall wrap *gomock.Call

func (*ITransferIsNoRowsCall) Do

func (c *ITransferIsNoRowsCall) Do(f func(error) bool) *ITransferIsNoRowsCall

Do rewrite *gomock.Call.Do

func (*ITransferIsNoRowsCall) DoAndReturn

func (c *ITransferIsNoRowsCall) DoAndReturn(f func(error) bool) *ITransferIsNoRowsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITransferIsNoRowsCall) Return

func (c *ITransferIsNoRowsCall) Return(arg0 bool) *ITransferIsNoRowsCall

Return rewrite *gomock.Call.Return

type ITransferLastIDCall

type ITransferLastIDCall struct {
	*gomock.Call
}

ITransferLastIDCall wrap *gomock.Call

func (*ITransferLastIDCall) Do

func (c *ITransferLastIDCall) Do(f func(context.Context) (uint64, error)) *ITransferLastIDCall

Do rewrite *gomock.Call.Do

func (*ITransferLastIDCall) DoAndReturn

func (c *ITransferLastIDCall) DoAndReturn(f func(context.Context) (uint64, error)) *ITransferLastIDCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITransferLastIDCall) Return

func (c *ITransferLastIDCall) Return(arg0 uint64, arg1 error) *ITransferLastIDCall

Return rewrite *gomock.Call.Return

type ITransferListCall

type ITransferListCall struct {
	*gomock.Call
}

ITransferListCall wrap *gomock.Call

func (*ITransferListCall) Do

func (c *ITransferListCall) Do(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Transfer, error)) *ITransferListCall

Do rewrite *gomock.Call.Do

func (*ITransferListCall) DoAndReturn

func (c *ITransferListCall) DoAndReturn(f func(context.Context, uint64, uint64, storage0.SortOrder) ([]*storage.Transfer, error)) *ITransferListCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITransferListCall) Return

func (c *ITransferListCall) Return(arg0 []*storage.Transfer, arg1 error) *ITransferListCall

Return rewrite *gomock.Call.Return

type ITransferSaveCall

type ITransferSaveCall struct {
	*gomock.Call
}

ITransferSaveCall wrap *gomock.Call

func (*ITransferSaveCall) Do

func (c *ITransferSaveCall) Do(f func(context.Context, *storage.Transfer) error) *ITransferSaveCall

Do rewrite *gomock.Call.Do

func (*ITransferSaveCall) DoAndReturn

func (c *ITransferSaveCall) DoAndReturn(f func(context.Context, *storage.Transfer) error) *ITransferSaveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITransferSaveCall) Return

func (c *ITransferSaveCall) Return(arg0 error) *ITransferSaveCall

Return rewrite *gomock.Call.Return

type ITransferUpdateCall

type ITransferUpdateCall struct {
	*gomock.Call
}

ITransferUpdateCall wrap *gomock.Call

func (*ITransferUpdateCall) Do

func (c *ITransferUpdateCall) Do(f func(context.Context, *storage.Transfer) error) *ITransferUpdateCall

Do rewrite *gomock.Call.Do

func (*ITransferUpdateCall) DoAndReturn

func (c *ITransferUpdateCall) DoAndReturn(f func(context.Context, *storage.Transfer) error) *ITransferUpdateCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*ITransferUpdateCall) Return

func (c *ITransferUpdateCall) Return(arg0 error) *ITransferUpdateCall

Return rewrite *gomock.Call.Return

type MockIAddress

type MockIAddress struct {
	// contains filtered or unexported fields
}

MockIAddress is a mock of IAddress interface.

func NewMockIAddress

func NewMockIAddress(ctrl *gomock.Controller) *MockIAddress

NewMockIAddress creates a new mock instance.

func (*MockIAddress) CursorList

func (m *MockIAddress) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, cmp storage0.Comparator) ([]*storage.Address, error)

CursorList mocks base method.

func (*MockIAddress) EXPECT

func (m *MockIAddress) EXPECT() *MockIAddressMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockIAddress) Filter

func (m *MockIAddress) Filter(ctx context.Context, flt []storage.AddressFilter, opts ...storage.FilterOption) ([]storage.Address, error)

Filter mocks base method.

func (*MockIAddress) GetAddresses

func (m *MockIAddress) GetAddresses(ctx context.Context, ids ...uint64) ([]storage.Address, error)

GetAddresses mocks base method.

func (*MockIAddress) GetByHash

func (m *MockIAddress) GetByHash(ctx context.Context, hash []byte) (storage.Address, error)

GetByHash mocks base method.

func (*MockIAddress) GetByHashes

func (m *MockIAddress) GetByHashes(ctx context.Context, hash [][]byte) ([]storage.Address, error)

GetByHashes mocks base method.

func (*MockIAddress) GetByID

func (m *MockIAddress) GetByID(ctx context.Context, id uint64) (*storage.Address, error)

GetByID mocks base method.

func (*MockIAddress) IsNoRows

func (m *MockIAddress) IsNoRows(err error) bool

IsNoRows mocks base method.

func (*MockIAddress) LastID

func (m *MockIAddress) LastID(ctx context.Context) (uint64, error)

LastID mocks base method.

func (*MockIAddress) List

func (m *MockIAddress) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Address, error)

List mocks base method.

func (*MockIAddress) Save

func (m_2 *MockIAddress) Save(ctx context.Context, m *storage.Address) error

Save mocks base method.

func (*MockIAddress) Update

func (m_2 *MockIAddress) Update(ctx context.Context, m *storage.Address) error

Update mocks base method.

type MockIAddressMockRecorder

type MockIAddressMockRecorder struct {
	// contains filtered or unexported fields
}

MockIAddressMockRecorder is the mock recorder for MockIAddress.

func (*MockIAddressMockRecorder) CursorList

func (mr *MockIAddressMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IAddressCursorListCall

CursorList indicates an expected call of CursorList.

func (*MockIAddressMockRecorder) Filter

func (mr *MockIAddressMockRecorder) Filter(ctx, flt any, opts ...any) *IAddressFilterCall

Filter indicates an expected call of Filter.

func (*MockIAddressMockRecorder) GetAddresses

func (mr *MockIAddressMockRecorder) GetAddresses(ctx any, ids ...any) *IAddressGetAddressesCall

GetAddresses indicates an expected call of GetAddresses.

func (*MockIAddressMockRecorder) GetByHash

func (mr *MockIAddressMockRecorder) GetByHash(ctx, hash any) *IAddressGetByHashCall

GetByHash indicates an expected call of GetByHash.

func (*MockIAddressMockRecorder) GetByHashes

func (mr *MockIAddressMockRecorder) GetByHashes(ctx, hash any) *IAddressGetByHashesCall

GetByHashes indicates an expected call of GetByHashes.

func (*MockIAddressMockRecorder) GetByID

func (mr *MockIAddressMockRecorder) GetByID(ctx, id any) *IAddressGetByIDCall

GetByID indicates an expected call of GetByID.

func (*MockIAddressMockRecorder) IsNoRows

func (mr *MockIAddressMockRecorder) IsNoRows(err any) *IAddressIsNoRowsCall

IsNoRows indicates an expected call of IsNoRows.

func (*MockIAddressMockRecorder) LastID

func (mr *MockIAddressMockRecorder) LastID(ctx any) *IAddressLastIDCall

LastID indicates an expected call of LastID.

func (*MockIAddressMockRecorder) List

func (mr *MockIAddressMockRecorder) List(ctx, limit, offset, order any) *IAddressListCall

List indicates an expected call of List.

func (*MockIAddressMockRecorder) Save

func (mr *MockIAddressMockRecorder) Save(ctx, m any) *IAddressSaveCall

Save indicates an expected call of Save.

func (*MockIAddressMockRecorder) Update

func (mr *MockIAddressMockRecorder) Update(ctx, m any) *IAddressUpdateCall

Update indicates an expected call of Update.

type MockIBlock

type MockIBlock struct {
	// contains filtered or unexported fields
}

MockIBlock is a mock of IBlock interface.

func NewMockIBlock

func NewMockIBlock(ctrl *gomock.Controller) *MockIBlock

NewMockIBlock creates a new mock instance.

func (*MockIBlock) ByHeight

func (m *MockIBlock) ByHeight(ctx context.Context, height uint64) (storage.Block, error)

ByHeight mocks base method.

func (*MockIBlock) ByStatus

func (m *MockIBlock) ByStatus(ctx context.Context, status storage.Status, limit, offset uint64, order storage0.SortOrder) ([]storage.Block, error)

ByStatus mocks base method.

func (*MockIBlock) CursorList

func (m *MockIBlock) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, cmp storage0.Comparator) ([]*storage.Block, error)

CursorList mocks base method.

func (*MockIBlock) EXPECT

func (m *MockIBlock) EXPECT() *MockIBlockMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockIBlock) GetByID

func (m *MockIBlock) GetByID(ctx context.Context, id uint64) (*storage.Block, error)

GetByID mocks base method.

func (*MockIBlock) IsNoRows

func (m *MockIBlock) IsNoRows(err error) bool

IsNoRows mocks base method.

func (*MockIBlock) Last

func (m *MockIBlock) Last(ctx context.Context) (storage.Block, error)

Last mocks base method.

func (*MockIBlock) LastID

func (m *MockIBlock) LastID(ctx context.Context) (uint64, error)

LastID mocks base method.

func (*MockIBlock) List

func (m *MockIBlock) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Block, error)

List mocks base method.

func (*MockIBlock) Save

func (m_2 *MockIBlock) Save(ctx context.Context, m *storage.Block) error

Save mocks base method.

func (*MockIBlock) Update

func (m_2 *MockIBlock) Update(ctx context.Context, m *storage.Block) error

Update mocks base method.

type MockIBlockMockRecorder

type MockIBlockMockRecorder struct {
	// contains filtered or unexported fields
}

MockIBlockMockRecorder is the mock recorder for MockIBlock.

func (*MockIBlockMockRecorder) ByHeight

func (mr *MockIBlockMockRecorder) ByHeight(ctx, height any) *IBlockByHeightCall

ByHeight indicates an expected call of ByHeight.

func (*MockIBlockMockRecorder) ByStatus

func (mr *MockIBlockMockRecorder) ByStatus(ctx, status, limit, offset, order any) *IBlockByStatusCall

ByStatus indicates an expected call of ByStatus.

func (*MockIBlockMockRecorder) CursorList

func (mr *MockIBlockMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IBlockCursorListCall

CursorList indicates an expected call of CursorList.

func (*MockIBlockMockRecorder) GetByID

func (mr *MockIBlockMockRecorder) GetByID(ctx, id any) *IBlockGetByIDCall

GetByID indicates an expected call of GetByID.

func (*MockIBlockMockRecorder) IsNoRows

func (mr *MockIBlockMockRecorder) IsNoRows(err any) *IBlockIsNoRowsCall

IsNoRows indicates an expected call of IsNoRows.

func (*MockIBlockMockRecorder) Last

func (mr *MockIBlockMockRecorder) Last(ctx any) *IBlockLastCall

Last indicates an expected call of Last.

func (*MockIBlockMockRecorder) LastID

func (mr *MockIBlockMockRecorder) LastID(ctx any) *IBlockLastIDCall

LastID indicates an expected call of LastID.

func (*MockIBlockMockRecorder) List

func (mr *MockIBlockMockRecorder) List(ctx, limit, offset, order any) *IBlockListCall

List indicates an expected call of List.

func (*MockIBlockMockRecorder) Save

func (mr *MockIBlockMockRecorder) Save(ctx, m any) *IBlockSaveCall

Save indicates an expected call of Save.

func (*MockIBlockMockRecorder) Update

func (mr *MockIBlockMockRecorder) Update(ctx, m any) *IBlockUpdateCall

Update indicates an expected call of Update.

type MockIClass

type MockIClass struct {
	// contains filtered or unexported fields
}

MockIClass is a mock of IClass interface.

func NewMockIClass

func NewMockIClass(ctrl *gomock.Controller) *MockIClass

NewMockIClass creates a new mock instance.

func (*MockIClass) CursorList

func (m *MockIClass) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, cmp storage0.Comparator) ([]*storage.Class, error)

CursorList mocks base method.

func (*MockIClass) EXPECT

func (m *MockIClass) EXPECT() *MockIClassMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockIClass) GetByHash

func (m *MockIClass) GetByHash(ctx context.Context, hash []byte) (storage.Class, error)

GetByHash mocks base method.

func (*MockIClass) GetByID

func (m *MockIClass) GetByID(ctx context.Context, id uint64) (*storage.Class, error)

GetByID mocks base method.

func (*MockIClass) GetUnresolved

func (m *MockIClass) GetUnresolved(ctx context.Context) ([]storage.Class, error)

GetUnresolved mocks base method.

func (*MockIClass) IsNoRows

func (m *MockIClass) IsNoRows(err error) bool

IsNoRows mocks base method.

func (*MockIClass) LastID

func (m *MockIClass) LastID(ctx context.Context) (uint64, error)

LastID mocks base method.

func (*MockIClass) List

func (m *MockIClass) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Class, error)

List mocks base method.

func (*MockIClass) Save

func (m_2 *MockIClass) Save(ctx context.Context, m *storage.Class) error

Save mocks base method.

func (*MockIClass) Update

func (m_2 *MockIClass) Update(ctx context.Context, m *storage.Class) error

Update mocks base method.

type MockIClassMockRecorder

type MockIClassMockRecorder struct {
	// contains filtered or unexported fields
}

MockIClassMockRecorder is the mock recorder for MockIClass.

func (*MockIClassMockRecorder) CursorList

func (mr *MockIClassMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IClassCursorListCall

CursorList indicates an expected call of CursorList.

func (*MockIClassMockRecorder) GetByHash

func (mr *MockIClassMockRecorder) GetByHash(ctx, hash any) *IClassGetByHashCall

GetByHash indicates an expected call of GetByHash.

func (*MockIClassMockRecorder) GetByID

func (mr *MockIClassMockRecorder) GetByID(ctx, id any) *IClassGetByIDCall

GetByID indicates an expected call of GetByID.

func (*MockIClassMockRecorder) GetUnresolved

func (mr *MockIClassMockRecorder) GetUnresolved(ctx any) *IClassGetUnresolvedCall

GetUnresolved indicates an expected call of GetUnresolved.

func (*MockIClassMockRecorder) IsNoRows

func (mr *MockIClassMockRecorder) IsNoRows(err any) *IClassIsNoRowsCall

IsNoRows indicates an expected call of IsNoRows.

func (*MockIClassMockRecorder) LastID

func (mr *MockIClassMockRecorder) LastID(ctx any) *IClassLastIDCall

LastID indicates an expected call of LastID.

func (*MockIClassMockRecorder) List

func (mr *MockIClassMockRecorder) List(ctx, limit, offset, order any) *IClassListCall

List indicates an expected call of List.

func (*MockIClassMockRecorder) Save

func (mr *MockIClassMockRecorder) Save(ctx, m any) *IClassSaveCall

Save indicates an expected call of Save.

func (*MockIClassMockRecorder) Update

func (mr *MockIClassMockRecorder) Update(ctx, m any) *IClassUpdateCall

Update indicates an expected call of Update.

type MockIClassReplace

type MockIClassReplace struct {
	// contains filtered or unexported fields
}

MockIClassReplace is a mock of IClassReplace interface.

func NewMockIClassReplace

func NewMockIClassReplace(ctrl *gomock.Controller) *MockIClassReplace

NewMockIClassReplace creates a new mock instance.

func (*MockIClassReplace) ByHeight

func (m *MockIClassReplace) ByHeight(ctx context.Context, height uint64) ([]storage.ClassReplace, error)

ByHeight mocks base method.

func (*MockIClassReplace) CursorList

func (m *MockIClassReplace) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, cmp storage0.Comparator) ([]*storage.ClassReplace, error)

CursorList mocks base method.

func (*MockIClassReplace) EXPECT

func (m *MockIClassReplace) EXPECT() *MockIClassReplaceMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockIClassReplace) GetByID

func (m *MockIClassReplace) GetByID(ctx context.Context, id uint64) (*storage.ClassReplace, error)

GetByID mocks base method.

func (*MockIClassReplace) IsNoRows

func (m *MockIClassReplace) IsNoRows(err error) bool

IsNoRows mocks base method.

func (*MockIClassReplace) LastID

func (m *MockIClassReplace) LastID(ctx context.Context) (uint64, error)

LastID mocks base method.

func (*MockIClassReplace) List

func (m *MockIClassReplace) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.ClassReplace, error)

List mocks base method.

func (*MockIClassReplace) Save

func (m_2 *MockIClassReplace) Save(ctx context.Context, m *storage.ClassReplace) error

Save mocks base method.

func (*MockIClassReplace) Update

func (m_2 *MockIClassReplace) Update(ctx context.Context, m *storage.ClassReplace) error

Update mocks base method.

type MockIClassReplaceMockRecorder

type MockIClassReplaceMockRecorder struct {
	// contains filtered or unexported fields
}

MockIClassReplaceMockRecorder is the mock recorder for MockIClassReplace.

func (*MockIClassReplaceMockRecorder) ByHeight

func (mr *MockIClassReplaceMockRecorder) ByHeight(ctx, height any) *IClassReplaceByHeightCall

ByHeight indicates an expected call of ByHeight.

func (*MockIClassReplaceMockRecorder) CursorList

func (mr *MockIClassReplaceMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IClassReplaceCursorListCall

CursorList indicates an expected call of CursorList.

func (*MockIClassReplaceMockRecorder) GetByID

func (mr *MockIClassReplaceMockRecorder) GetByID(ctx, id any) *IClassReplaceGetByIDCall

GetByID indicates an expected call of GetByID.

func (*MockIClassReplaceMockRecorder) IsNoRows

func (mr *MockIClassReplaceMockRecorder) IsNoRows(err any) *IClassReplaceIsNoRowsCall

IsNoRows indicates an expected call of IsNoRows.

func (*MockIClassReplaceMockRecorder) LastID

func (mr *MockIClassReplaceMockRecorder) LastID(ctx any) *IClassReplaceLastIDCall

LastID indicates an expected call of LastID.

func (*MockIClassReplaceMockRecorder) List

func (mr *MockIClassReplaceMockRecorder) List(ctx, limit, offset, order any) *IClassReplaceListCall

List indicates an expected call of List.

func (*MockIClassReplaceMockRecorder) Save

func (mr *MockIClassReplaceMockRecorder) Save(ctx, m any) *IClassReplaceSaveCall

Save indicates an expected call of Save.

func (*MockIClassReplaceMockRecorder) Update

func (mr *MockIClassReplaceMockRecorder) Update(ctx, m any) *IClassReplaceUpdateCall

Update indicates an expected call of Update.

type MockIDeclare

type MockIDeclare struct {
	// contains filtered or unexported fields
}

MockIDeclare is a mock of IDeclare interface.

func NewMockIDeclare

func NewMockIDeclare(ctrl *gomock.Controller) *MockIDeclare

NewMockIDeclare creates a new mock instance.

func (*MockIDeclare) CursorList

func (m *MockIDeclare) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, cmp storage0.Comparator) ([]*storage.Declare, error)

CursorList mocks base method.

func (*MockIDeclare) EXPECT

func (m *MockIDeclare) EXPECT() *MockIDeclareMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockIDeclare) Filter

func (m *MockIDeclare) Filter(ctx context.Context, flt []storage.DeclareFilter, opts ...storage.FilterOption) ([]storage.Declare, error)

Filter mocks base method.

func (*MockIDeclare) GetByID

func (m *MockIDeclare) GetByID(ctx context.Context, id uint64) (*storage.Declare, error)

GetByID mocks base method.

func (*MockIDeclare) IsNoRows

func (m *MockIDeclare) IsNoRows(err error) bool

IsNoRows mocks base method.

func (*MockIDeclare) LastID

func (m *MockIDeclare) LastID(ctx context.Context) (uint64, error)

LastID mocks base method.

func (*MockIDeclare) List

func (m *MockIDeclare) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Declare, error)

List mocks base method.

func (*MockIDeclare) Save

func (m_2 *MockIDeclare) Save(ctx context.Context, m *storage.Declare) error

Save mocks base method.

func (*MockIDeclare) Update

func (m_2 *MockIDeclare) Update(ctx context.Context, m *storage.Declare) error

Update mocks base method.

type MockIDeclareMockRecorder

type MockIDeclareMockRecorder struct {
	// contains filtered or unexported fields
}

MockIDeclareMockRecorder is the mock recorder for MockIDeclare.

func (*MockIDeclareMockRecorder) CursorList

func (mr *MockIDeclareMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IDeclareCursorListCall

CursorList indicates an expected call of CursorList.

func (*MockIDeclareMockRecorder) Filter

func (mr *MockIDeclareMockRecorder) Filter(ctx, flt any, opts ...any) *IDeclareFilterCall

Filter indicates an expected call of Filter.

func (*MockIDeclareMockRecorder) GetByID

func (mr *MockIDeclareMockRecorder) GetByID(ctx, id any) *IDeclareGetByIDCall

GetByID indicates an expected call of GetByID.

func (*MockIDeclareMockRecorder) IsNoRows

func (mr *MockIDeclareMockRecorder) IsNoRows(err any) *IDeclareIsNoRowsCall

IsNoRows indicates an expected call of IsNoRows.

func (*MockIDeclareMockRecorder) LastID

func (mr *MockIDeclareMockRecorder) LastID(ctx any) *IDeclareLastIDCall

LastID indicates an expected call of LastID.

func (*MockIDeclareMockRecorder) List

func (mr *MockIDeclareMockRecorder) List(ctx, limit, offset, order any) *IDeclareListCall

List indicates an expected call of List.

func (*MockIDeclareMockRecorder) Save

func (mr *MockIDeclareMockRecorder) Save(ctx, m any) *IDeclareSaveCall

Save indicates an expected call of Save.

func (*MockIDeclareMockRecorder) Update

func (mr *MockIDeclareMockRecorder) Update(ctx, m any) *IDeclareUpdateCall

Update indicates an expected call of Update.

type MockIDeploy

type MockIDeploy struct {
	// contains filtered or unexported fields
}

MockIDeploy is a mock of IDeploy interface.

func NewMockIDeploy

func NewMockIDeploy(ctrl *gomock.Controller) *MockIDeploy

NewMockIDeploy creates a new mock instance.

func (*MockIDeploy) CursorList

func (m *MockIDeploy) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, cmp storage0.Comparator) ([]*storage.Deploy, error)

CursorList mocks base method.

func (*MockIDeploy) EXPECT

func (m *MockIDeploy) EXPECT() *MockIDeployMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockIDeploy) Filter

func (m *MockIDeploy) Filter(ctx context.Context, flt []storage.DeployFilter, opts ...storage.FilterOption) ([]storage.Deploy, error)

Filter mocks base method.

func (*MockIDeploy) GetByID

func (m *MockIDeploy) GetByID(ctx context.Context, id uint64) (*storage.Deploy, error)

GetByID mocks base method.

func (*MockIDeploy) IsNoRows

func (m *MockIDeploy) IsNoRows(err error) bool

IsNoRows mocks base method.

func (*MockIDeploy) LastID

func (m *MockIDeploy) LastID(ctx context.Context) (uint64, error)

LastID mocks base method.

func (*MockIDeploy) List

func (m *MockIDeploy) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Deploy, error)

List mocks base method.

func (*MockIDeploy) Save

func (m_2 *MockIDeploy) Save(ctx context.Context, m *storage.Deploy) error

Save mocks base method.

func (*MockIDeploy) Update

func (m_2 *MockIDeploy) Update(ctx context.Context, m *storage.Deploy) error

Update mocks base method.

type MockIDeployAccount

type MockIDeployAccount struct {
	// contains filtered or unexported fields
}

MockIDeployAccount is a mock of IDeployAccount interface.

func NewMockIDeployAccount

func NewMockIDeployAccount(ctrl *gomock.Controller) *MockIDeployAccount

NewMockIDeployAccount creates a new mock instance.

func (*MockIDeployAccount) CursorList

func (m *MockIDeployAccount) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, cmp storage0.Comparator) ([]*storage.DeployAccount, error)

CursorList mocks base method.

func (*MockIDeployAccount) EXPECT

func (m *MockIDeployAccount) EXPECT() *MockIDeployAccountMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockIDeployAccount) Filter

func (m *MockIDeployAccount) Filter(ctx context.Context, flt []storage.DeployAccountFilter, opts ...storage.FilterOption) ([]storage.DeployAccount, error)

Filter mocks base method.

func (*MockIDeployAccount) GetByID

func (m *MockIDeployAccount) GetByID(ctx context.Context, id uint64) (*storage.DeployAccount, error)

GetByID mocks base method.

func (*MockIDeployAccount) IsNoRows

func (m *MockIDeployAccount) IsNoRows(err error) bool

IsNoRows mocks base method.

func (*MockIDeployAccount) LastID

func (m *MockIDeployAccount) LastID(ctx context.Context) (uint64, error)

LastID mocks base method.

func (*MockIDeployAccount) List

func (m *MockIDeployAccount) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.DeployAccount, error)

List mocks base method.

func (*MockIDeployAccount) Save

func (m_2 *MockIDeployAccount) Save(ctx context.Context, m *storage.DeployAccount) error

Save mocks base method.

func (*MockIDeployAccount) Update

func (m_2 *MockIDeployAccount) Update(ctx context.Context, m *storage.DeployAccount) error

Update mocks base method.

type MockIDeployAccountMockRecorder

type MockIDeployAccountMockRecorder struct {
	// contains filtered or unexported fields
}

MockIDeployAccountMockRecorder is the mock recorder for MockIDeployAccount.

func (*MockIDeployAccountMockRecorder) CursorList

func (mr *MockIDeployAccountMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IDeployAccountCursorListCall

CursorList indicates an expected call of CursorList.

func (*MockIDeployAccountMockRecorder) Filter

func (mr *MockIDeployAccountMockRecorder) Filter(ctx, flt any, opts ...any) *IDeployAccountFilterCall

Filter indicates an expected call of Filter.

func (*MockIDeployAccountMockRecorder) GetByID

func (mr *MockIDeployAccountMockRecorder) GetByID(ctx, id any) *IDeployAccountGetByIDCall

GetByID indicates an expected call of GetByID.

func (*MockIDeployAccountMockRecorder) IsNoRows

func (mr *MockIDeployAccountMockRecorder) IsNoRows(err any) *IDeployAccountIsNoRowsCall

IsNoRows indicates an expected call of IsNoRows.

func (*MockIDeployAccountMockRecorder) LastID

func (mr *MockIDeployAccountMockRecorder) LastID(ctx any) *IDeployAccountLastIDCall

LastID indicates an expected call of LastID.

func (*MockIDeployAccountMockRecorder) List

func (mr *MockIDeployAccountMockRecorder) List(ctx, limit, offset, order any) *IDeployAccountListCall

List indicates an expected call of List.

func (*MockIDeployAccountMockRecorder) Save

func (mr *MockIDeployAccountMockRecorder) Save(ctx, m any) *IDeployAccountSaveCall

Save indicates an expected call of Save.

func (*MockIDeployAccountMockRecorder) Update

func (mr *MockIDeployAccountMockRecorder) Update(ctx, m any) *IDeployAccountUpdateCall

Update indicates an expected call of Update.

type MockIDeployMockRecorder

type MockIDeployMockRecorder struct {
	// contains filtered or unexported fields
}

MockIDeployMockRecorder is the mock recorder for MockIDeploy.

func (*MockIDeployMockRecorder) CursorList

func (mr *MockIDeployMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IDeployCursorListCall

CursorList indicates an expected call of CursorList.

func (*MockIDeployMockRecorder) Filter

func (mr *MockIDeployMockRecorder) Filter(ctx, flt any, opts ...any) *IDeployFilterCall

Filter indicates an expected call of Filter.

func (*MockIDeployMockRecorder) GetByID

func (mr *MockIDeployMockRecorder) GetByID(ctx, id any) *IDeployGetByIDCall

GetByID indicates an expected call of GetByID.

func (*MockIDeployMockRecorder) IsNoRows

func (mr *MockIDeployMockRecorder) IsNoRows(err any) *IDeployIsNoRowsCall

IsNoRows indicates an expected call of IsNoRows.

func (*MockIDeployMockRecorder) LastID

func (mr *MockIDeployMockRecorder) LastID(ctx any) *IDeployLastIDCall

LastID indicates an expected call of LastID.

func (*MockIDeployMockRecorder) List

func (mr *MockIDeployMockRecorder) List(ctx, limit, offset, order any) *IDeployListCall

List indicates an expected call of List.

func (*MockIDeployMockRecorder) Save

func (mr *MockIDeployMockRecorder) Save(ctx, m any) *IDeploySaveCall

Save indicates an expected call of Save.

func (*MockIDeployMockRecorder) Update

func (mr *MockIDeployMockRecorder) Update(ctx, m any) *IDeployUpdateCall

Update indicates an expected call of Update.

type MockIEvent

type MockIEvent struct {
	// contains filtered or unexported fields
}

MockIEvent is a mock of IEvent interface.

func NewMockIEvent

func NewMockIEvent(ctrl *gomock.Controller) *MockIEvent

NewMockIEvent creates a new mock instance.

func (*MockIEvent) CursorList

func (m *MockIEvent) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, cmp storage0.Comparator) ([]*storage.Event, error)

CursorList mocks base method.

func (*MockIEvent) EXPECT

func (m *MockIEvent) EXPECT() *MockIEventMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockIEvent) Filter

func (m *MockIEvent) Filter(ctx context.Context, flt []storage.EventFilter, opts ...storage.FilterOption) ([]storage.Event, error)

Filter mocks base method.

func (*MockIEvent) GetByID

func (m *MockIEvent) GetByID(ctx context.Context, id uint64) (*storage.Event, error)

GetByID mocks base method.

func (*MockIEvent) IsNoRows

func (m *MockIEvent) IsNoRows(err error) bool

IsNoRows mocks base method.

func (*MockIEvent) LastID

func (m *MockIEvent) LastID(ctx context.Context) (uint64, error)

LastID mocks base method.

func (*MockIEvent) List

func (m *MockIEvent) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Event, error)

List mocks base method.

func (*MockIEvent) Save

func (m_2 *MockIEvent) Save(ctx context.Context, m *storage.Event) error

Save mocks base method.

func (*MockIEvent) Update

func (m_2 *MockIEvent) Update(ctx context.Context, m *storage.Event) error

Update mocks base method.

type MockIEventMockRecorder

type MockIEventMockRecorder struct {
	// contains filtered or unexported fields
}

MockIEventMockRecorder is the mock recorder for MockIEvent.

func (*MockIEventMockRecorder) CursorList

func (mr *MockIEventMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IEventCursorListCall

CursorList indicates an expected call of CursorList.

func (*MockIEventMockRecorder) Filter

func (mr *MockIEventMockRecorder) Filter(ctx, flt any, opts ...any) *IEventFilterCall

Filter indicates an expected call of Filter.

func (*MockIEventMockRecorder) GetByID

func (mr *MockIEventMockRecorder) GetByID(ctx, id any) *IEventGetByIDCall

GetByID indicates an expected call of GetByID.

func (*MockIEventMockRecorder) IsNoRows

func (mr *MockIEventMockRecorder) IsNoRows(err any) *IEventIsNoRowsCall

IsNoRows indicates an expected call of IsNoRows.

func (*MockIEventMockRecorder) LastID

func (mr *MockIEventMockRecorder) LastID(ctx any) *IEventLastIDCall

LastID indicates an expected call of LastID.

func (*MockIEventMockRecorder) List

func (mr *MockIEventMockRecorder) List(ctx, limit, offset, order any) *IEventListCall

List indicates an expected call of List.

func (*MockIEventMockRecorder) Save

func (mr *MockIEventMockRecorder) Save(ctx, m any) *IEventSaveCall

Save indicates an expected call of Save.

func (*MockIEventMockRecorder) Update

func (mr *MockIEventMockRecorder) Update(ctx, m any) *IEventUpdateCall

Update indicates an expected call of Update.

type MockIFee

type MockIFee struct {
	// contains filtered or unexported fields
}

MockIFee is a mock of IFee interface.

func NewMockIFee

func NewMockIFee(ctrl *gomock.Controller) *MockIFee

NewMockIFee creates a new mock instance.

func (*MockIFee) CursorList

func (m *MockIFee) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, cmp storage0.Comparator) ([]*storage.Fee, error)

CursorList mocks base method.

func (*MockIFee) EXPECT

func (m *MockIFee) EXPECT() *MockIFeeMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockIFee) Filter

func (m *MockIFee) Filter(ctx context.Context, flt []storage.FeeFilter, opts ...storage.FilterOption) ([]storage.Fee, error)

Filter mocks base method.

func (*MockIFee) GetByID

func (m *MockIFee) GetByID(ctx context.Context, id uint64) (*storage.Fee, error)

GetByID mocks base method.

func (*MockIFee) IsNoRows

func (m *MockIFee) IsNoRows(err error) bool

IsNoRows mocks base method.

func (*MockIFee) LastID

func (m *MockIFee) LastID(ctx context.Context) (uint64, error)

LastID mocks base method.

func (*MockIFee) List

func (m *MockIFee) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Fee, error)

List mocks base method.

func (*MockIFee) Save

func (m_2 *MockIFee) Save(ctx context.Context, m *storage.Fee) error

Save mocks base method.

func (*MockIFee) Update

func (m_2 *MockIFee) Update(ctx context.Context, m *storage.Fee) error

Update mocks base method.

type MockIFeeMockRecorder

type MockIFeeMockRecorder struct {
	// contains filtered or unexported fields
}

MockIFeeMockRecorder is the mock recorder for MockIFee.

func (*MockIFeeMockRecorder) CursorList

func (mr *MockIFeeMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IFeeCursorListCall

CursorList indicates an expected call of CursorList.

func (*MockIFeeMockRecorder) Filter

func (mr *MockIFeeMockRecorder) Filter(ctx, flt any, opts ...any) *IFeeFilterCall

Filter indicates an expected call of Filter.

func (*MockIFeeMockRecorder) GetByID

func (mr *MockIFeeMockRecorder) GetByID(ctx, id any) *IFeeGetByIDCall

GetByID indicates an expected call of GetByID.

func (*MockIFeeMockRecorder) IsNoRows

func (mr *MockIFeeMockRecorder) IsNoRows(err any) *IFeeIsNoRowsCall

IsNoRows indicates an expected call of IsNoRows.

func (*MockIFeeMockRecorder) LastID

func (mr *MockIFeeMockRecorder) LastID(ctx any) *IFeeLastIDCall

LastID indicates an expected call of LastID.

func (*MockIFeeMockRecorder) List

func (mr *MockIFeeMockRecorder) List(ctx, limit, offset, order any) *IFeeListCall

List indicates an expected call of List.

func (*MockIFeeMockRecorder) Save

func (mr *MockIFeeMockRecorder) Save(ctx, m any) *IFeeSaveCall

Save indicates an expected call of Save.

func (*MockIFeeMockRecorder) Update

func (mr *MockIFeeMockRecorder) Update(ctx, m any) *IFeeUpdateCall

Update indicates an expected call of Update.

type MockIInternal

type MockIInternal struct {
	// contains filtered or unexported fields
}

MockIInternal is a mock of IInternal interface.

func NewMockIInternal

func NewMockIInternal(ctrl *gomock.Controller) *MockIInternal

NewMockIInternal creates a new mock instance.

func (*MockIInternal) CursorList

func (m *MockIInternal) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, cmp storage0.Comparator) ([]*storage.Internal, error)

CursorList mocks base method.

func (*MockIInternal) EXPECT

func (m *MockIInternal) EXPECT() *MockIInternalMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockIInternal) Filter

func (m *MockIInternal) Filter(ctx context.Context, flt []storage.InternalFilter, opts ...storage.FilterOption) ([]storage.Internal, error)

Filter mocks base method.

func (*MockIInternal) GetByID

func (m *MockIInternal) GetByID(ctx context.Context, id uint64) (*storage.Internal, error)

GetByID mocks base method.

func (*MockIInternal) IsNoRows

func (m *MockIInternal) IsNoRows(err error) bool

IsNoRows mocks base method.

func (*MockIInternal) LastID

func (m *MockIInternal) LastID(ctx context.Context) (uint64, error)

LastID mocks base method.

func (*MockIInternal) List

func (m *MockIInternal) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Internal, error)

List mocks base method.

func (*MockIInternal) Save

func (m_2 *MockIInternal) Save(ctx context.Context, m *storage.Internal) error

Save mocks base method.

func (*MockIInternal) Update

func (m_2 *MockIInternal) Update(ctx context.Context, m *storage.Internal) error

Update mocks base method.

type MockIInternalMockRecorder

type MockIInternalMockRecorder struct {
	// contains filtered or unexported fields
}

MockIInternalMockRecorder is the mock recorder for MockIInternal.

func (*MockIInternalMockRecorder) CursorList

func (mr *MockIInternalMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IInternalCursorListCall

CursorList indicates an expected call of CursorList.

func (*MockIInternalMockRecorder) Filter

func (mr *MockIInternalMockRecorder) Filter(ctx, flt any, opts ...any) *IInternalFilterCall

Filter indicates an expected call of Filter.

func (*MockIInternalMockRecorder) GetByID

func (mr *MockIInternalMockRecorder) GetByID(ctx, id any) *IInternalGetByIDCall

GetByID indicates an expected call of GetByID.

func (*MockIInternalMockRecorder) IsNoRows

func (mr *MockIInternalMockRecorder) IsNoRows(err any) *IInternalIsNoRowsCall

IsNoRows indicates an expected call of IsNoRows.

func (*MockIInternalMockRecorder) LastID

func (mr *MockIInternalMockRecorder) LastID(ctx any) *IInternalLastIDCall

LastID indicates an expected call of LastID.

func (*MockIInternalMockRecorder) List

func (mr *MockIInternalMockRecorder) List(ctx, limit, offset, order any) *IInternalListCall

List indicates an expected call of List.

func (*MockIInternalMockRecorder) Save

func (mr *MockIInternalMockRecorder) Save(ctx, m any) *IInternalSaveCall

Save indicates an expected call of Save.

func (*MockIInternalMockRecorder) Update

func (mr *MockIInternalMockRecorder) Update(ctx, m any) *IInternalUpdateCall

Update indicates an expected call of Update.

type MockIInvoke

type MockIInvoke struct {
	// contains filtered or unexported fields
}

MockIInvoke is a mock of IInvoke interface.

func NewMockIInvoke

func NewMockIInvoke(ctrl *gomock.Controller) *MockIInvoke

NewMockIInvoke creates a new mock instance.

func (*MockIInvoke) CursorList

func (m *MockIInvoke) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, cmp storage0.Comparator) ([]*storage.Invoke, error)

CursorList mocks base method.

func (*MockIInvoke) EXPECT

func (m *MockIInvoke) EXPECT() *MockIInvokeMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockIInvoke) Filter

func (m *MockIInvoke) Filter(ctx context.Context, flt []storage.InvokeFilter, opts ...storage.FilterOption) ([]storage.Invoke, error)

Filter mocks base method.

func (*MockIInvoke) GetByID

func (m *MockIInvoke) GetByID(ctx context.Context, id uint64) (*storage.Invoke, error)

GetByID mocks base method.

func (*MockIInvoke) HashByHeight

func (m *MockIInvoke) HashByHeight(ctx context.Context, height uint64) ([]byte, error)

HashByHeight mocks base method.

func (*MockIInvoke) IsNoRows

func (m *MockIInvoke) IsNoRows(err error) bool

IsNoRows mocks base method.

func (*MockIInvoke) LastID

func (m *MockIInvoke) LastID(ctx context.Context) (uint64, error)

LastID mocks base method.

func (*MockIInvoke) List

func (m *MockIInvoke) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Invoke, error)

List mocks base method.

func (*MockIInvoke) Save

func (m_2 *MockIInvoke) Save(ctx context.Context, m *storage.Invoke) error

Save mocks base method.

func (*MockIInvoke) Update

func (m_2 *MockIInvoke) Update(ctx context.Context, m *storage.Invoke) error

Update mocks base method.

type MockIInvokeMockRecorder

type MockIInvokeMockRecorder struct {
	// contains filtered or unexported fields
}

MockIInvokeMockRecorder is the mock recorder for MockIInvoke.

func (*MockIInvokeMockRecorder) CursorList

func (mr *MockIInvokeMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IInvokeCursorListCall

CursorList indicates an expected call of CursorList.

func (*MockIInvokeMockRecorder) Filter

func (mr *MockIInvokeMockRecorder) Filter(ctx, flt any, opts ...any) *IInvokeFilterCall

Filter indicates an expected call of Filter.

func (*MockIInvokeMockRecorder) GetByID

func (mr *MockIInvokeMockRecorder) GetByID(ctx, id any) *IInvokeGetByIDCall

GetByID indicates an expected call of GetByID.

func (*MockIInvokeMockRecorder) HashByHeight

func (mr *MockIInvokeMockRecorder) HashByHeight(ctx, height any) *IInvokeHashByHeightCall

HashByHeight indicates an expected call of HashByHeight.

func (*MockIInvokeMockRecorder) IsNoRows

func (mr *MockIInvokeMockRecorder) IsNoRows(err any) *IInvokeIsNoRowsCall

IsNoRows indicates an expected call of IsNoRows.

func (*MockIInvokeMockRecorder) LastID

func (mr *MockIInvokeMockRecorder) LastID(ctx any) *IInvokeLastIDCall

LastID indicates an expected call of LastID.

func (*MockIInvokeMockRecorder) List

func (mr *MockIInvokeMockRecorder) List(ctx, limit, offset, order any) *IInvokeListCall

List indicates an expected call of List.

func (*MockIInvokeMockRecorder) Save

func (mr *MockIInvokeMockRecorder) Save(ctx, m any) *IInvokeSaveCall

Save indicates an expected call of Save.

func (*MockIInvokeMockRecorder) Update

func (mr *MockIInvokeMockRecorder) Update(ctx, m any) *IInvokeUpdateCall

Update indicates an expected call of Update.

type MockIL1Handler

type MockIL1Handler struct {
	// contains filtered or unexported fields
}

MockIL1Handler is a mock of IL1Handler interface.

func NewMockIL1Handler

func NewMockIL1Handler(ctrl *gomock.Controller) *MockIL1Handler

NewMockIL1Handler creates a new mock instance.

func (*MockIL1Handler) CursorList

func (m *MockIL1Handler) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, cmp storage0.Comparator) ([]*storage.L1Handler, error)

CursorList mocks base method.

func (*MockIL1Handler) EXPECT

func (m *MockIL1Handler) EXPECT() *MockIL1HandlerMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockIL1Handler) Filter

func (m *MockIL1Handler) Filter(ctx context.Context, flt []storage.L1HandlerFilter, opts ...storage.FilterOption) ([]storage.L1Handler, error)

Filter mocks base method.

func (*MockIL1Handler) GetByID

func (m *MockIL1Handler) GetByID(ctx context.Context, id uint64) (*storage.L1Handler, error)

GetByID mocks base method.

func (*MockIL1Handler) IsNoRows

func (m *MockIL1Handler) IsNoRows(err error) bool

IsNoRows mocks base method.

func (*MockIL1Handler) LastID

func (m *MockIL1Handler) LastID(ctx context.Context) (uint64, error)

LastID mocks base method.

func (*MockIL1Handler) List

func (m *MockIL1Handler) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.L1Handler, error)

List mocks base method.

func (*MockIL1Handler) Save

func (m_2 *MockIL1Handler) Save(ctx context.Context, m *storage.L1Handler) error

Save mocks base method.

func (*MockIL1Handler) Update

func (m_2 *MockIL1Handler) Update(ctx context.Context, m *storage.L1Handler) error

Update mocks base method.

type MockIL1HandlerMockRecorder

type MockIL1HandlerMockRecorder struct {
	// contains filtered or unexported fields
}

MockIL1HandlerMockRecorder is the mock recorder for MockIL1Handler.

func (*MockIL1HandlerMockRecorder) CursorList

func (mr *MockIL1HandlerMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IL1HandlerCursorListCall

CursorList indicates an expected call of CursorList.

func (*MockIL1HandlerMockRecorder) Filter

func (mr *MockIL1HandlerMockRecorder) Filter(ctx, flt any, opts ...any) *IL1HandlerFilterCall

Filter indicates an expected call of Filter.

func (*MockIL1HandlerMockRecorder) GetByID

func (mr *MockIL1HandlerMockRecorder) GetByID(ctx, id any) *IL1HandlerGetByIDCall

GetByID indicates an expected call of GetByID.

func (*MockIL1HandlerMockRecorder) IsNoRows

func (mr *MockIL1HandlerMockRecorder) IsNoRows(err any) *IL1HandlerIsNoRowsCall

IsNoRows indicates an expected call of IsNoRows.

func (*MockIL1HandlerMockRecorder) LastID

func (mr *MockIL1HandlerMockRecorder) LastID(ctx any) *IL1HandlerLastIDCall

LastID indicates an expected call of LastID.

func (*MockIL1HandlerMockRecorder) List

func (mr *MockIL1HandlerMockRecorder) List(ctx, limit, offset, order any) *IL1HandlerListCall

List indicates an expected call of List.

func (*MockIL1HandlerMockRecorder) Save

func (mr *MockIL1HandlerMockRecorder) Save(ctx, m any) *IL1HandlerSaveCall

Save indicates an expected call of Save.

func (*MockIL1HandlerMockRecorder) Update

func (mr *MockIL1HandlerMockRecorder) Update(ctx, m any) *IL1HandlerUpdateCall

Update indicates an expected call of Update.

type MockIMessage

type MockIMessage struct {
	// contains filtered or unexported fields
}

MockIMessage is a mock of IMessage interface.

func NewMockIMessage

func NewMockIMessage(ctrl *gomock.Controller) *MockIMessage

NewMockIMessage creates a new mock instance.

func (*MockIMessage) CursorList

func (m *MockIMessage) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, cmp storage0.Comparator) ([]*storage.Message, error)

CursorList mocks base method.

func (*MockIMessage) EXPECT

func (m *MockIMessage) EXPECT() *MockIMessageMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockIMessage) Filter

func (m *MockIMessage) Filter(ctx context.Context, flt []storage.MessageFilter, opts ...storage.FilterOption) ([]storage.Message, error)

Filter mocks base method.

func (*MockIMessage) GetByID

func (m *MockIMessage) GetByID(ctx context.Context, id uint64) (*storage.Message, error)

GetByID mocks base method.

func (*MockIMessage) IsNoRows

func (m *MockIMessage) IsNoRows(err error) bool

IsNoRows mocks base method.

func (*MockIMessage) LastID

func (m *MockIMessage) LastID(ctx context.Context) (uint64, error)

LastID mocks base method.

func (*MockIMessage) List

func (m *MockIMessage) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Message, error)

List mocks base method.

func (*MockIMessage) Save

func (m_2 *MockIMessage) Save(ctx context.Context, m *storage.Message) error

Save mocks base method.

func (*MockIMessage) Update

func (m_2 *MockIMessage) Update(ctx context.Context, m *storage.Message) error

Update mocks base method.

type MockIMessageMockRecorder

type MockIMessageMockRecorder struct {
	// contains filtered or unexported fields
}

MockIMessageMockRecorder is the mock recorder for MockIMessage.

func (*MockIMessageMockRecorder) CursorList

func (mr *MockIMessageMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IMessageCursorListCall

CursorList indicates an expected call of CursorList.

func (*MockIMessageMockRecorder) Filter

func (mr *MockIMessageMockRecorder) Filter(ctx, flt any, opts ...any) *IMessageFilterCall

Filter indicates an expected call of Filter.

func (*MockIMessageMockRecorder) GetByID

func (mr *MockIMessageMockRecorder) GetByID(ctx, id any) *IMessageGetByIDCall

GetByID indicates an expected call of GetByID.

func (*MockIMessageMockRecorder) IsNoRows

func (mr *MockIMessageMockRecorder) IsNoRows(err any) *IMessageIsNoRowsCall

IsNoRows indicates an expected call of IsNoRows.

func (*MockIMessageMockRecorder) LastID

func (mr *MockIMessageMockRecorder) LastID(ctx any) *IMessageLastIDCall

LastID indicates an expected call of LastID.

func (*MockIMessageMockRecorder) List

func (mr *MockIMessageMockRecorder) List(ctx, limit, offset, order any) *IMessageListCall

List indicates an expected call of List.

func (*MockIMessageMockRecorder) Save

func (mr *MockIMessageMockRecorder) Save(ctx, m any) *IMessageSaveCall

Save indicates an expected call of Save.

func (*MockIMessageMockRecorder) Update

func (mr *MockIMessageMockRecorder) Update(ctx, m any) *IMessageUpdateCall

Update indicates an expected call of Update.

type MockIProxy

type MockIProxy struct {
	// contains filtered or unexported fields
}

MockIProxy is a mock of IProxy interface.

func NewMockIProxy

func NewMockIProxy(ctrl *gomock.Controller) *MockIProxy

NewMockIProxy creates a new mock instance.

func (*MockIProxy) CursorList

func (m *MockIProxy) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, cmp storage0.Comparator) ([]*storage.Proxy, error)

CursorList mocks base method.

func (*MockIProxy) EXPECT

func (m *MockIProxy) EXPECT() *MockIProxyMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockIProxy) GetByHash

func (m *MockIProxy) GetByHash(ctx context.Context, address, selector []byte) (storage.Proxy, error)

GetByHash mocks base method.

func (*MockIProxy) GetByID

func (m *MockIProxy) GetByID(ctx context.Context, id uint64) (*storage.Proxy, error)

GetByID mocks base method.

func (*MockIProxy) IsNoRows

func (m *MockIProxy) IsNoRows(err error) bool

IsNoRows mocks base method.

func (*MockIProxy) LastID

func (m *MockIProxy) LastID(ctx context.Context) (uint64, error)

LastID mocks base method.

func (*MockIProxy) List

func (m *MockIProxy) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Proxy, error)

List mocks base method.

func (*MockIProxy) Save

func (m_2 *MockIProxy) Save(ctx context.Context, m *storage.Proxy) error

Save mocks base method.

func (*MockIProxy) Update

func (m_2 *MockIProxy) Update(ctx context.Context, m *storage.Proxy) error

Update mocks base method.

type MockIProxyMockRecorder

type MockIProxyMockRecorder struct {
	// contains filtered or unexported fields
}

MockIProxyMockRecorder is the mock recorder for MockIProxy.

func (*MockIProxyMockRecorder) CursorList

func (mr *MockIProxyMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IProxyCursorListCall

CursorList indicates an expected call of CursorList.

func (*MockIProxyMockRecorder) GetByHash

func (mr *MockIProxyMockRecorder) GetByHash(ctx, address, selector any) *IProxyGetByHashCall

GetByHash indicates an expected call of GetByHash.

func (*MockIProxyMockRecorder) GetByID

func (mr *MockIProxyMockRecorder) GetByID(ctx, id any) *IProxyGetByIDCall

GetByID indicates an expected call of GetByID.

func (*MockIProxyMockRecorder) IsNoRows

func (mr *MockIProxyMockRecorder) IsNoRows(err any) *IProxyIsNoRowsCall

IsNoRows indicates an expected call of IsNoRows.

func (*MockIProxyMockRecorder) LastID

func (mr *MockIProxyMockRecorder) LastID(ctx any) *IProxyLastIDCall

LastID indicates an expected call of LastID.

func (*MockIProxyMockRecorder) List

func (mr *MockIProxyMockRecorder) List(ctx, limit, offset, order any) *IProxyListCall

List indicates an expected call of List.

func (*MockIProxyMockRecorder) Save

func (mr *MockIProxyMockRecorder) Save(ctx, m any) *IProxySaveCall

Save indicates an expected call of Save.

func (*MockIProxyMockRecorder) Update

func (mr *MockIProxyMockRecorder) Update(ctx, m any) *IProxyUpdateCall

Update indicates an expected call of Update.

type MockIProxyUpgrade

type MockIProxyUpgrade struct {
	// contains filtered or unexported fields
}

MockIProxyUpgrade is a mock of IProxyUpgrade interface.

func NewMockIProxyUpgrade

func NewMockIProxyUpgrade(ctrl *gomock.Controller) *MockIProxyUpgrade

NewMockIProxyUpgrade creates a new mock instance.

func (*MockIProxyUpgrade) CursorList

func (m *MockIProxyUpgrade) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, cmp storage0.Comparator) ([]*storage.ProxyUpgrade, error)

CursorList mocks base method.

func (*MockIProxyUpgrade) EXPECT

func (m *MockIProxyUpgrade) EXPECT() *MockIProxyUpgradeMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockIProxyUpgrade) GetByID

func (m *MockIProxyUpgrade) GetByID(ctx context.Context, id uint64) (*storage.ProxyUpgrade, error)

GetByID mocks base method.

func (*MockIProxyUpgrade) IsNoRows

func (m *MockIProxyUpgrade) IsNoRows(err error) bool

IsNoRows mocks base method.

func (*MockIProxyUpgrade) LastBefore

func (m *MockIProxyUpgrade) LastBefore(ctx context.Context, hash, selector []byte, height uint64) (storage.ProxyUpgrade, error)

LastBefore mocks base method.

func (*MockIProxyUpgrade) LastID

func (m *MockIProxyUpgrade) LastID(ctx context.Context) (uint64, error)

LastID mocks base method.

func (*MockIProxyUpgrade) List

func (m *MockIProxyUpgrade) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.ProxyUpgrade, error)

List mocks base method.

func (*MockIProxyUpgrade) ListWithHeight

func (m *MockIProxyUpgrade) ListWithHeight(ctx context.Context, height uint64, limit, offset int) ([]storage.ProxyUpgrade, error)

ListWithHeight mocks base method.

func (*MockIProxyUpgrade) Save

func (m_2 *MockIProxyUpgrade) Save(ctx context.Context, m *storage.ProxyUpgrade) error

Save mocks base method.

func (*MockIProxyUpgrade) Update

func (m_2 *MockIProxyUpgrade) Update(ctx context.Context, m *storage.ProxyUpgrade) error

Update mocks base method.

type MockIProxyUpgradeMockRecorder

type MockIProxyUpgradeMockRecorder struct {
	// contains filtered or unexported fields
}

MockIProxyUpgradeMockRecorder is the mock recorder for MockIProxyUpgrade.

func (*MockIProxyUpgradeMockRecorder) CursorList

func (mr *MockIProxyUpgradeMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IProxyUpgradeCursorListCall

CursorList indicates an expected call of CursorList.

func (*MockIProxyUpgradeMockRecorder) GetByID

func (mr *MockIProxyUpgradeMockRecorder) GetByID(ctx, id any) *IProxyUpgradeGetByIDCall

GetByID indicates an expected call of GetByID.

func (*MockIProxyUpgradeMockRecorder) IsNoRows

func (mr *MockIProxyUpgradeMockRecorder) IsNoRows(err any) *IProxyUpgradeIsNoRowsCall

IsNoRows indicates an expected call of IsNoRows.

func (*MockIProxyUpgradeMockRecorder) LastBefore

func (mr *MockIProxyUpgradeMockRecorder) LastBefore(ctx, hash, selector, height any) *IProxyUpgradeLastBeforeCall

LastBefore indicates an expected call of LastBefore.

func (*MockIProxyUpgradeMockRecorder) LastID

func (mr *MockIProxyUpgradeMockRecorder) LastID(ctx any) *IProxyUpgradeLastIDCall

LastID indicates an expected call of LastID.

func (*MockIProxyUpgradeMockRecorder) List

func (mr *MockIProxyUpgradeMockRecorder) List(ctx, limit, offset, order any) *IProxyUpgradeListCall

List indicates an expected call of List.

func (*MockIProxyUpgradeMockRecorder) ListWithHeight

func (mr *MockIProxyUpgradeMockRecorder) ListWithHeight(ctx, height, limit, offset any) *IProxyUpgradeListWithHeightCall

ListWithHeight indicates an expected call of ListWithHeight.

func (*MockIProxyUpgradeMockRecorder) Save

func (mr *MockIProxyUpgradeMockRecorder) Save(ctx, m any) *IProxyUpgradeSaveCall

Save indicates an expected call of Save.

func (*MockIProxyUpgradeMockRecorder) Update

func (mr *MockIProxyUpgradeMockRecorder) Update(ctx, m any) *IProxyUpgradeUpdateCall

Update indicates an expected call of Update.

type MockIState

type MockIState struct {
	// contains filtered or unexported fields
}

MockIState is a mock of IState interface.

func NewMockIState

func NewMockIState(ctrl *gomock.Controller) *MockIState

NewMockIState creates a new mock instance.

func (*MockIState) ByName

func (m *MockIState) ByName(ctx context.Context, name string) (storage.State, error)

ByName mocks base method.

func (*MockIState) CursorList

func (m *MockIState) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, cmp storage0.Comparator) ([]*storage.State, error)

CursorList mocks base method.

func (*MockIState) EXPECT

func (m *MockIState) EXPECT() *MockIStateMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockIState) GetByID

func (m *MockIState) GetByID(ctx context.Context, id uint64) (*storage.State, error)

GetByID mocks base method.

func (*MockIState) IsNoRows

func (m *MockIState) IsNoRows(err error) bool

IsNoRows mocks base method.

func (*MockIState) LastID

func (m *MockIState) LastID(ctx context.Context) (uint64, error)

LastID mocks base method.

func (*MockIState) List

func (m *MockIState) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.State, error)

List mocks base method.

func (*MockIState) Save

func (m_2 *MockIState) Save(ctx context.Context, m *storage.State) error

Save mocks base method.

func (*MockIState) Update

func (m_2 *MockIState) Update(ctx context.Context, m *storage.State) error

Update mocks base method.

type MockIStateMockRecorder

type MockIStateMockRecorder struct {
	// contains filtered or unexported fields
}

MockIStateMockRecorder is the mock recorder for MockIState.

func (*MockIStateMockRecorder) ByName

func (mr *MockIStateMockRecorder) ByName(ctx, name any) *IStateByNameCall

ByName indicates an expected call of ByName.

func (*MockIStateMockRecorder) CursorList

func (mr *MockIStateMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IStateCursorListCall

CursorList indicates an expected call of CursorList.

func (*MockIStateMockRecorder) GetByID

func (mr *MockIStateMockRecorder) GetByID(ctx, id any) *IStateGetByIDCall

GetByID indicates an expected call of GetByID.

func (*MockIStateMockRecorder) IsNoRows

func (mr *MockIStateMockRecorder) IsNoRows(err any) *IStateIsNoRowsCall

IsNoRows indicates an expected call of IsNoRows.

func (*MockIStateMockRecorder) LastID

func (mr *MockIStateMockRecorder) LastID(ctx any) *IStateLastIDCall

LastID indicates an expected call of LastID.

func (*MockIStateMockRecorder) List

func (mr *MockIStateMockRecorder) List(ctx, limit, offset, order any) *IStateListCall

List indicates an expected call of List.

func (*MockIStateMockRecorder) Save

func (mr *MockIStateMockRecorder) Save(ctx, m any) *IStateSaveCall

Save indicates an expected call of Save.

func (*MockIStateMockRecorder) Update

func (mr *MockIStateMockRecorder) Update(ctx, m any) *IStateUpdateCall

Update indicates an expected call of Update.

type MockIStorageDiff

type MockIStorageDiff struct {
	// contains filtered or unexported fields
}

MockIStorageDiff is a mock of IStorageDiff interface.

func NewMockIStorageDiff

func NewMockIStorageDiff(ctrl *gomock.Controller) *MockIStorageDiff

NewMockIStorageDiff creates a new mock instance.

func (*MockIStorageDiff) CursorList

func (m *MockIStorageDiff) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, cmp storage0.Comparator) ([]*storage.StorageDiff, error)

CursorList mocks base method.

func (*MockIStorageDiff) EXPECT

func (m *MockIStorageDiff) EXPECT() *MockIStorageDiffMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockIStorageDiff) Filter

func (m *MockIStorageDiff) Filter(ctx context.Context, flt []storage.StorageDiffFilter, opts ...storage.FilterOption) ([]storage.StorageDiff, error)

Filter mocks base method.

func (*MockIStorageDiff) GetByID

func (m *MockIStorageDiff) GetByID(ctx context.Context, id uint64) (*storage.StorageDiff, error)

GetByID mocks base method.

func (*MockIStorageDiff) GetOnBlock

func (m *MockIStorageDiff) GetOnBlock(ctx context.Context, height, contractId uint64, key []byte) (storage.StorageDiff, error)

GetOnBlock mocks base method.

func (*MockIStorageDiff) IsNoRows

func (m *MockIStorageDiff) IsNoRows(err error) bool

IsNoRows mocks base method.

func (*MockIStorageDiff) LastID

func (m *MockIStorageDiff) LastID(ctx context.Context) (uint64, error)

LastID mocks base method.

func (*MockIStorageDiff) List

func (m *MockIStorageDiff) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.StorageDiff, error)

List mocks base method.

func (*MockIStorageDiff) Save

func (m_2 *MockIStorageDiff) Save(ctx context.Context, m *storage.StorageDiff) error

Save mocks base method.

func (*MockIStorageDiff) Update

func (m_2 *MockIStorageDiff) Update(ctx context.Context, m *storage.StorageDiff) error

Update mocks base method.

type MockIStorageDiffMockRecorder

type MockIStorageDiffMockRecorder struct {
	// contains filtered or unexported fields
}

MockIStorageDiffMockRecorder is the mock recorder for MockIStorageDiff.

func (*MockIStorageDiffMockRecorder) CursorList

func (mr *MockIStorageDiffMockRecorder) CursorList(ctx, id, limit, order, cmp any) *IStorageDiffCursorListCall

CursorList indicates an expected call of CursorList.

func (*MockIStorageDiffMockRecorder) Filter

func (mr *MockIStorageDiffMockRecorder) Filter(ctx, flt any, opts ...any) *IStorageDiffFilterCall

Filter indicates an expected call of Filter.

func (*MockIStorageDiffMockRecorder) GetByID

func (mr *MockIStorageDiffMockRecorder) GetByID(ctx, id any) *IStorageDiffGetByIDCall

GetByID indicates an expected call of GetByID.

func (*MockIStorageDiffMockRecorder) GetOnBlock

func (mr *MockIStorageDiffMockRecorder) GetOnBlock(ctx, height, contractId, key any) *IStorageDiffGetOnBlockCall

GetOnBlock indicates an expected call of GetOnBlock.

func (*MockIStorageDiffMockRecorder) IsNoRows

func (mr *MockIStorageDiffMockRecorder) IsNoRows(err any) *IStorageDiffIsNoRowsCall

IsNoRows indicates an expected call of IsNoRows.

func (*MockIStorageDiffMockRecorder) LastID

func (mr *MockIStorageDiffMockRecorder) LastID(ctx any) *IStorageDiffLastIDCall

LastID indicates an expected call of LastID.

func (*MockIStorageDiffMockRecorder) List

func (mr *MockIStorageDiffMockRecorder) List(ctx, limit, offset, order any) *IStorageDiffListCall

List indicates an expected call of List.

func (*MockIStorageDiffMockRecorder) Save

func (mr *MockIStorageDiffMockRecorder) Save(ctx, m any) *IStorageDiffSaveCall

Save indicates an expected call of Save.

func (*MockIStorageDiffMockRecorder) Update

func (mr *MockIStorageDiffMockRecorder) Update(ctx, m any) *IStorageDiffUpdateCall

Update indicates an expected call of Update.

type MockIToken

type MockIToken struct {
	// contains filtered or unexported fields
}

MockIToken is a mock of IToken interface.

func NewMockIToken

func NewMockIToken(ctrl *gomock.Controller) *MockIToken

NewMockIToken creates a new mock instance.

func (*MockIToken) CursorList

func (m *MockIToken) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, cmp storage0.Comparator) ([]*storage.Token, error)

CursorList mocks base method.

func (*MockIToken) EXPECT

func (m *MockIToken) EXPECT() *MockITokenMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockIToken) Filter

func (m *MockIToken) Filter(ctx context.Context, flt []storage.TokenFilter, opts ...storage.FilterOption) ([]storage.Token, error)

Filter mocks base method.

func (*MockIToken) Find

func (m *MockIToken) Find(ctx context.Context, contractId uint64, tokenId string) (storage.Token, error)

Find mocks base method.

func (*MockIToken) GetByID

func (m *MockIToken) GetByID(ctx context.Context, id uint64) (*storage.Token, error)

GetByID mocks base method.

func (*MockIToken) IsNoRows

func (m *MockIToken) IsNoRows(err error) bool

IsNoRows mocks base method.

func (*MockIToken) LastID

func (m *MockIToken) LastID(ctx context.Context) (uint64, error)

LastID mocks base method.

func (*MockIToken) List

func (m *MockIToken) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Token, error)

List mocks base method.

func (*MockIToken) ListByType

func (m *MockIToken) ListByType(ctx context.Context, typ storage.TokenType, limit, offset uint64, order storage0.SortOrder) ([]storage.Token, error)

ListByType mocks base method.

func (*MockIToken) Save

func (m_2 *MockIToken) Save(ctx context.Context, m *storage.Token) error

Save mocks base method.

func (*MockIToken) Update

func (m_2 *MockIToken) Update(ctx context.Context, m *storage.Token) error

Update mocks base method.

type MockITokenBalance

type MockITokenBalance struct {
	// contains filtered or unexported fields
}

MockITokenBalance is a mock of ITokenBalance interface.

func NewMockITokenBalance

func NewMockITokenBalance(ctrl *gomock.Controller) *MockITokenBalance

NewMockITokenBalance creates a new mock instance.

func (*MockITokenBalance) Balances

func (m *MockITokenBalance) Balances(ctx context.Context, contractId uint64, tokenId int64, limit, offset int) ([]storage.TokenBalance, error)

Balances mocks base method.

func (*MockITokenBalance) CursorList

func (m *MockITokenBalance) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, cmp storage0.Comparator) ([]*storage.TokenBalance, error)

CursorList mocks base method.

func (*MockITokenBalance) EXPECT

func (m *MockITokenBalance) EXPECT() *MockITokenBalanceMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockITokenBalance) Filter

func (m *MockITokenBalance) Filter(ctx context.Context, flt []storage.TokenBalanceFilter, opts ...storage.FilterOption) ([]storage.TokenBalance, error)

Filter mocks base method.

func (*MockITokenBalance) GetByID

func (m *MockITokenBalance) GetByID(ctx context.Context, id uint64) (*storage.TokenBalance, error)

GetByID mocks base method.

func (*MockITokenBalance) IsNoRows

func (m *MockITokenBalance) IsNoRows(err error) bool

IsNoRows mocks base method.

func (*MockITokenBalance) LastID

func (m *MockITokenBalance) LastID(ctx context.Context) (uint64, error)

LastID mocks base method.

func (*MockITokenBalance) List

func (m *MockITokenBalance) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.TokenBalance, error)

List mocks base method.

func (*MockITokenBalance) Save

func (m_2 *MockITokenBalance) Save(ctx context.Context, m *storage.TokenBalance) error

Save mocks base method.

func (*MockITokenBalance) Update

func (m_2 *MockITokenBalance) Update(ctx context.Context, m *storage.TokenBalance) error

Update mocks base method.

type MockITokenBalanceMockRecorder

type MockITokenBalanceMockRecorder struct {
	// contains filtered or unexported fields
}

MockITokenBalanceMockRecorder is the mock recorder for MockITokenBalance.

func (*MockITokenBalanceMockRecorder) Balances

func (mr *MockITokenBalanceMockRecorder) Balances(ctx, contractId, tokenId, limit, offset any) *ITokenBalanceBalancesCall

Balances indicates an expected call of Balances.

func (*MockITokenBalanceMockRecorder) CursorList

func (mr *MockITokenBalanceMockRecorder) CursorList(ctx, id, limit, order, cmp any) *ITokenBalanceCursorListCall

CursorList indicates an expected call of CursorList.

func (*MockITokenBalanceMockRecorder) Filter

func (mr *MockITokenBalanceMockRecorder) Filter(ctx, flt any, opts ...any) *ITokenBalanceFilterCall

Filter indicates an expected call of Filter.

func (*MockITokenBalanceMockRecorder) GetByID

func (mr *MockITokenBalanceMockRecorder) GetByID(ctx, id any) *ITokenBalanceGetByIDCall

GetByID indicates an expected call of GetByID.

func (*MockITokenBalanceMockRecorder) IsNoRows

func (mr *MockITokenBalanceMockRecorder) IsNoRows(err any) *ITokenBalanceIsNoRowsCall

IsNoRows indicates an expected call of IsNoRows.

func (*MockITokenBalanceMockRecorder) LastID

func (mr *MockITokenBalanceMockRecorder) LastID(ctx any) *ITokenBalanceLastIDCall

LastID indicates an expected call of LastID.

func (*MockITokenBalanceMockRecorder) List

func (mr *MockITokenBalanceMockRecorder) List(ctx, limit, offset, order any) *ITokenBalanceListCall

List indicates an expected call of List.

func (*MockITokenBalanceMockRecorder) Save

func (mr *MockITokenBalanceMockRecorder) Save(ctx, m any) *ITokenBalanceSaveCall

Save indicates an expected call of Save.

func (*MockITokenBalanceMockRecorder) Update

func (mr *MockITokenBalanceMockRecorder) Update(ctx, m any) *ITokenBalanceUpdateCall

Update indicates an expected call of Update.

type MockITokenMockRecorder

type MockITokenMockRecorder struct {
	// contains filtered or unexported fields
}

MockITokenMockRecorder is the mock recorder for MockIToken.

func (*MockITokenMockRecorder) CursorList

func (mr *MockITokenMockRecorder) CursorList(ctx, id, limit, order, cmp any) *ITokenCursorListCall

CursorList indicates an expected call of CursorList.

func (*MockITokenMockRecorder) Filter

func (mr *MockITokenMockRecorder) Filter(ctx, flt any, opts ...any) *ITokenFilterCall

Filter indicates an expected call of Filter.

func (*MockITokenMockRecorder) Find

func (mr *MockITokenMockRecorder) Find(ctx, contractId, tokenId any) *ITokenFindCall

Find indicates an expected call of Find.

func (*MockITokenMockRecorder) GetByID

func (mr *MockITokenMockRecorder) GetByID(ctx, id any) *ITokenGetByIDCall

GetByID indicates an expected call of GetByID.

func (*MockITokenMockRecorder) IsNoRows

func (mr *MockITokenMockRecorder) IsNoRows(err any) *ITokenIsNoRowsCall

IsNoRows indicates an expected call of IsNoRows.

func (*MockITokenMockRecorder) LastID

func (mr *MockITokenMockRecorder) LastID(ctx any) *ITokenLastIDCall

LastID indicates an expected call of LastID.

func (*MockITokenMockRecorder) List

func (mr *MockITokenMockRecorder) List(ctx, limit, offset, order any) *ITokenListCall

List indicates an expected call of List.

func (*MockITokenMockRecorder) ListByType

func (mr *MockITokenMockRecorder) ListByType(ctx, typ, limit, offset, order any) *ITokenListByTypeCall

ListByType indicates an expected call of ListByType.

func (*MockITokenMockRecorder) Save

func (mr *MockITokenMockRecorder) Save(ctx, m any) *ITokenSaveCall

Save indicates an expected call of Save.

func (*MockITokenMockRecorder) Update

func (mr *MockITokenMockRecorder) Update(ctx, m any) *ITokenUpdateCall

Update indicates an expected call of Update.

type MockITransfer

type MockITransfer struct {
	// contains filtered or unexported fields
}

MockITransfer is a mock of ITransfer interface.

func NewMockITransfer

func NewMockITransfer(ctrl *gomock.Controller) *MockITransfer

NewMockITransfer creates a new mock instance.

func (*MockITransfer) CursorList

func (m *MockITransfer) CursorList(ctx context.Context, id, limit uint64, order storage0.SortOrder, cmp storage0.Comparator) ([]*storage.Transfer, error)

CursorList mocks base method.

func (*MockITransfer) EXPECT

func (m *MockITransfer) EXPECT() *MockITransferMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockITransfer) Filter

func (m *MockITransfer) Filter(ctx context.Context, flt []storage.TransferFilter, opts ...storage.FilterOption) ([]storage.Transfer, error)

Filter mocks base method.

func (*MockITransfer) GetByID

func (m *MockITransfer) GetByID(ctx context.Context, id uint64) (*storage.Transfer, error)

GetByID mocks base method.

func (*MockITransfer) IsNoRows

func (m *MockITransfer) IsNoRows(err error) bool

IsNoRows mocks base method.

func (*MockITransfer) LastID

func (m *MockITransfer) LastID(ctx context.Context) (uint64, error)

LastID mocks base method.

func (*MockITransfer) List

func (m *MockITransfer) List(ctx context.Context, limit, offset uint64, order storage0.SortOrder) ([]*storage.Transfer, error)

List mocks base method.

func (*MockITransfer) Save

func (m_2 *MockITransfer) Save(ctx context.Context, m *storage.Transfer) error

Save mocks base method.

func (*MockITransfer) Update

func (m_2 *MockITransfer) Update(ctx context.Context, m *storage.Transfer) error

Update mocks base method.

type MockITransferMockRecorder

type MockITransferMockRecorder struct {
	// contains filtered or unexported fields
}

MockITransferMockRecorder is the mock recorder for MockITransfer.

func (*MockITransferMockRecorder) CursorList

func (mr *MockITransferMockRecorder) CursorList(ctx, id, limit, order, cmp any) *ITransferCursorListCall

CursorList indicates an expected call of CursorList.

func (*MockITransferMockRecorder) Filter

func (mr *MockITransferMockRecorder) Filter(ctx, flt any, opts ...any) *ITransferFilterCall

Filter indicates an expected call of Filter.

func (*MockITransferMockRecorder) GetByID

func (mr *MockITransferMockRecorder) GetByID(ctx, id any) *ITransferGetByIDCall

GetByID indicates an expected call of GetByID.

func (*MockITransferMockRecorder) IsNoRows

func (mr *MockITransferMockRecorder) IsNoRows(err any) *ITransferIsNoRowsCall

IsNoRows indicates an expected call of IsNoRows.

func (*MockITransferMockRecorder) LastID

func (mr *MockITransferMockRecorder) LastID(ctx any) *ITransferLastIDCall

LastID indicates an expected call of LastID.

func (*MockITransferMockRecorder) List

func (mr *MockITransferMockRecorder) List(ctx, limit, offset, order any) *ITransferListCall

List indicates an expected call of List.

func (*MockITransferMockRecorder) Save

func (mr *MockITransferMockRecorder) Save(ctx, m any) *ITransferSaveCall

Save indicates an expected call of Save.

func (*MockITransferMockRecorder) Update

func (mr *MockITransferMockRecorder) Update(ctx, m any) *ITransferUpdateCall

Update indicates an expected call of Update.