diff --git a/Makefile b/Makefile index 2fd728c18..b1f91a844 100644 --- a/Makefile +++ b/Makefile @@ -349,6 +349,9 @@ mock: ##@other Regenerate mocks mockgen -package=mock_balance_persistence -destination=services/wallet/token/mock/balance_persistence/balance_persistence.go -source=services/wallet/token/balance_persistence.go mockgen -package=mock_network -destination=rpc/network/mock/network.go -source=rpc/network/network.go mockgen -package=mock_rpcclient -destination=rpc/mock/client/client.go -source=rpc/client.go + mockgen -package=mock_collectibles -destination=services/wallet/collectibles/mock/collection_data_db.go -source=services/wallet/collectibles/collection_data_db.go + mockgen -package=mock_collectibles -destination=services/wallet/collectibles/mock/collectible_data_db.go -source=services/wallet/collectibles/collectible_data_db.go + mockgen -package=mock_thirdparty -destination=services/wallet/thirdparty/mock/collectible_types.go -source=services/wallet/thirdparty/collectible_types.go docker-test: ##@tests Run tests in a docker container with golang. docker run --privileged --rm -it -v "$(PWD):$(DOCKER_TEST_WORKDIR)" -w "$(DOCKER_TEST_WORKDIR)" $(DOCKER_TEST_IMAGE) go test ${ARGS} diff --git a/api/default_networks.go b/api/default_networks.go index 1214a4bab..74c16f8ab 100644 --- a/api/default_networks.go +++ b/api/default_networks.go @@ -81,7 +81,7 @@ var sepolia = params.Network{ var optimism = params.Network{ ChainID: optimismChainID, ChainName: "Optimism", - RPCURL: "https://optimism-mainnet.rpc.grove.city/v1/", + RPCURL: "https://optimism-archival.rpc.grove.city/v1/", FallbackURL: "https://optimism-mainnet.infura.io/v3/", BlockExplorerURL: "https://optimistic.etherscan.io", IconURL: "network/Network=Optimism", diff --git a/circuitbreaker/circuit_breaker.go b/circuitbreaker/circuit_breaker.go index a51708b30..85e14f5de 100644 --- a/circuitbreaker/circuit_breaker.go +++ b/circuitbreaker/circuit_breaker.go @@ -56,7 +56,8 @@ type Config struct { } type CircuitBreaker struct { - config Config + config Config + circuitNameHandler func(string) string } func NewCircuitBreaker(config Config) *CircuitBreaker { @@ -96,8 +97,13 @@ func (cb *CircuitBreaker) Execute(cmd *Command) CommandResult { break } - if hystrix.GetCircuitSettings()[f.circuitName] == nil { - hystrix.ConfigureCommand(f.circuitName, hystrix.CommandConfig{ + circuitName := f.circuitName + if cb.circuitNameHandler != nil { + circuitName = cb.circuitNameHandler(circuitName) + } + + if hystrix.GetCircuitSettings()[circuitName] == nil { + hystrix.ConfigureCommand(circuitName, hystrix.CommandConfig{ Timeout: cb.config.Timeout, MaxConcurrentRequests: cb.config.MaxConcurrentRequests, RequestVolumeThreshold: cb.config.RequestVolumeThreshold, @@ -106,7 +112,7 @@ func (cb *CircuitBreaker) Execute(cmd *Command) CommandResult { }) } - err := hystrix.DoC(ctx, f.circuitName, func(ctx context.Context) error { + err := hystrix.DoC(ctx, circuitName, func(ctx context.Context) error { res, err := f.exec() // Write to result only if success if err == nil { @@ -131,3 +137,19 @@ func (cb *CircuitBreaker) Execute(cmd *Command) CommandResult { return result } + +func (c *CircuitBreaker) SetOverrideCircuitNameHandler(f func(string) string) { + c.circuitNameHandler = f +} + +// Expects a circuit to exist because a new circuit is always closed. +// Call CircuitExists to check if a circuit exists. +func IsCircuitOpen(circuitName string) bool { + circuit, wasCreated, _ := hystrix.GetCircuit(circuitName) + return !wasCreated && circuit.IsOpen() +} + +func CircuitExists(circuitName string) bool { + _, wasCreated, _ := hystrix.GetCircuit(circuitName) + return !wasCreated +} diff --git a/circuitbreaker/circuit_breaker_test.go b/circuitbreaker/circuit_breaker_test.go index 7241795c5..9699ffad5 100644 --- a/circuitbreaker/circuit_breaker_test.go +++ b/circuitbreaker/circuit_breaker_test.go @@ -45,20 +45,20 @@ func TestCircuitBreaker_ExecuteMultipleFallbacksFail(t *testing.T) { ErrorPercentThreshold: 10, }) - circuitName := "" + circuitName := fmt.Sprintf("ExecuteMultipleFallbacksFail_%d", time.Now().Nanosecond()) // unique name to avoid conflicts with go tests `-count` option errSecProvFailed := errors.New("provider 2 failed") errThirdProvFailed := errors.New("provider 3 failed") cmd := NewCommand(context.TODO(), []*Functor{ NewFunctor(func() ([]interface{}, error) { time.Sleep(100 * time.Millisecond) // will cause hystrix: timeout return []any{success}, nil - }, circuitName), + }, circuitName+"1"), NewFunctor(func() ([]interface{}, error) { return nil, errSecProvFailed - }, circuitName), + }, circuitName+"2"), NewFunctor(func() ([]interface{}, error) { return nil, errThirdProvFailed - }, circuitName), + }, circuitName+"3"), }) result := cb.Execute(cmd) @@ -173,6 +173,8 @@ func TestCircuitBreaker_ExecuteHealthCheckOnWindowTimeout(t *testing.T) { assert.Less(t, prov1Called, 3) // most of the time only 1 call is made, but occasionally 2 can happen assert.Equal(t, 10, prov2Called) + assert.True(t, CircuitExists(circuitName+"1")) + assert.True(t, IsCircuitOpen(circuitName+"1")) // Wait for the sleep window to expire time.Sleep(time.Duration(sleepWindow+1) * time.Millisecond) @@ -230,3 +232,19 @@ func TestCircuitBreaker_EmptyOrNilCommand(t *testing.T) { result = cb.Execute(nil) require.Error(t, result.Error()) } + +func TestCircuitBreaker_CircuitExistsAndClosed(t *testing.T) { + timestamp := time.Now().Nanosecond() + nonExCircuit := fmt.Sprintf("nonexistent_%d", timestamp) // unique name to avoid conflicts with go tests `-count` option + require.False(t, CircuitExists(nonExCircuit)) + + cb := NewCircuitBreaker(Config{}) + cmd := NewCommand(context.TODO(), nil) + existCircuit := fmt.Sprintf("existing_%d", timestamp) // unique name to avoid conflicts with go tests `-count` option + cmd.Add(NewFunctor(func() ([]interface{}, error) { + return nil, nil + }, existCircuit)) + _ = cb.Execute(cmd) + require.True(t, CircuitExists(existCircuit)) + require.False(t, IsCircuitOpen(existCircuit)) +} diff --git a/rpc/chain/client.go b/rpc/chain/client.go index a1c4dfa01..2d3d556ea 100644 --- a/rpc/chain/client.go +++ b/rpc/chain/client.go @@ -16,6 +16,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/ethclient" + "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/rpc" "github.com/status-im/status-go/circuitbreaker" "github.com/status-im/status-go/services/rpcstats" @@ -71,6 +72,15 @@ func DeepCopyTagger(t Tagger) Tagger { return t.DeepCopyTag() } +type HealthMonitor interface { + GetCircuitBreaker() *circuitbreaker.CircuitBreaker + SetCircuitBreaker(cb *circuitbreaker.CircuitBreaker) +} + +type Copyable interface { + Copy() interface{} +} + // Shallow copy of the client with a deep copy of tag and group tag // To avoid passing tags as parameter to every chain call, it is sufficient for now // to set the tag and group tag once on the client @@ -117,6 +127,20 @@ type ClientWithFallback struct { groupTag string // tag for the limiter group } +func (c *ClientWithFallback) Copy() interface{} { + return &ClientWithFallback{ + ChainID: c.ChainID, + ethClients: c.ethClients, + commonLimiter: c.commonLimiter, + circuitbreaker: c.circuitbreaker, + WalletNotifier: c.WalletNotifier, + isConnected: c.isConnected, + LastCheckedAt: c.LastCheckedAt, + tag: c.tag, + groupTag: c.groupTag, + } +} + // Don't mark connection as failed if we get one of these errors var propagateErrors = []error{ vm.ErrOutOfGas, @@ -263,7 +287,7 @@ func (c *ClientWithFallback) makeCall(ctx context.Context, ethClients []*EthClie } } - if isVMError(err) { + if isVMError(err) || errors.Is(err, context.Canceled) { cmd.Cancel() } @@ -948,8 +972,10 @@ func (c *ClientWithFallback) SetWalletNotifier(notifier func(chainId uint64, mes func (c *ClientWithFallback) toggleConnectionState(err error) { connected := true if err != nil { - if !isVMError(err) && !errors.Is(err, ErrRequestsOverLimit) { + if !isVMError(err) && !errors.Is(err, ErrRequestsOverLimit) && !errors.Is(err, context.Canceled) { connected = false + } else { + log.Warn("Error in chain call", "error", err) } } c.SetIsConnected(connected) @@ -983,3 +1009,11 @@ func (c *ClientWithFallback) GetLimiter() RequestLimiter { func (c *ClientWithFallback) SetLimiter(limiter RequestLimiter) { c.commonLimiter = limiter } + +func (c *ClientWithFallback) GetCircuitBreaker() *circuitbreaker.CircuitBreaker { + return c.circuitbreaker +} + +func (c *ClientWithFallback) SetCircuitBreaker(cb *circuitbreaker.CircuitBreaker) { + c.circuitbreaker = cb +} diff --git a/services/wallet/collectibles/collectible_data_db.go b/services/wallet/collectibles/collectible_data_db.go index 4ac52a851..3c56a8668 100644 --- a/services/wallet/collectibles/collectible_data_db.go +++ b/services/wallet/collectibles/collectible_data_db.go @@ -11,6 +11,14 @@ import ( "github.com/status-im/status-go/sqlite" ) +type CollectibleDataStorage interface { + SetData(collectibles []thirdparty.CollectibleData, allowUpdate bool) error + GetIDsNotInDB(ids []thirdparty.CollectibleUniqueID) ([]thirdparty.CollectibleUniqueID, error) + GetData(ids []thirdparty.CollectibleUniqueID) (map[string]thirdparty.CollectibleData, error) + SetCommunityInfo(id thirdparty.CollectibleUniqueID, communityInfo thirdparty.CollectibleCommunityInfo) error + GetCommunityInfo(id thirdparty.CollectibleUniqueID) (*thirdparty.CollectibleCommunityInfo, error) +} + type CollectibleDataDB struct { db *sql.DB } diff --git a/services/wallet/collectibles/collection_data_db.go b/services/wallet/collectibles/collection_data_db.go index 6443b9c6f..2db3889b8 100644 --- a/services/wallet/collectibles/collection_data_db.go +++ b/services/wallet/collectibles/collection_data_db.go @@ -8,6 +8,14 @@ import ( "github.com/status-im/status-go/sqlite" ) +type CollectionDataStorage interface { + SetData(collections []thirdparty.CollectionData, allowUpdate bool) error + GetIDsNotInDB(ids []thirdparty.ContractID) ([]thirdparty.ContractID, error) + GetData(ids []thirdparty.ContractID) (map[string]thirdparty.CollectionData, error) + SetCollectionSocialsData(id thirdparty.ContractID, collectionSocials *thirdparty.CollectionSocials) error + GetSocialsForID(contractID thirdparty.ContractID) (*thirdparty.CollectionSocials, error) +} + type CollectionDataDB struct { db *sql.DB } diff --git a/services/wallet/collectibles/manager.go b/services/wallet/collectibles/manager.go index 97d4ae850..35401adfc 100644 --- a/services/wallet/collectibles/manager.go +++ b/services/wallet/collectibles/manager.go @@ -19,6 +19,7 @@ import ( "github.com/status-im/status-go/contracts/community-tokens/collectibles" "github.com/status-im/status-go/contracts/ierc1155" "github.com/status-im/status-go/rpc" + "github.com/status-im/status-go/rpc/chain" "github.com/status-im/status-go/server" "github.com/status-im/status-go/services/wallet/async" "github.com/status-im/status-go/services/wallet/bigint" @@ -52,13 +53,13 @@ type ManagerInterface interface { } type Manager struct { - rpcClient *rpc.Client + rpcClient rpc.ClientInterface providers thirdparty.CollectibleProviders httpClient *http.Client - collectiblesDataDB *CollectibleDataDB - collectionsDataDB *CollectionDataDB + collectiblesDataDB CollectibleDataStorage + collectionsDataDB CollectionDataStorage communityManager *community.Manager ownershipDB *OwnershipDB @@ -72,14 +73,20 @@ type Manager struct { func NewManager( db *sql.DB, - rpcClient *rpc.Client, + rpcClient rpc.ClientInterface, communityManager *community.Manager, providers thirdparty.CollectibleProviders, mediaServer *server.MediaServer, feed *event.Feed) *Manager { - ownershipDB := NewOwnershipDB(db) - statuses := initStatuses(ownershipDB) + var ownershipDB *OwnershipDB + var statuses *sync.Map + var statusNotifier *connection.StatusNotifier + if db != nil { + ownershipDB = NewOwnershipDB(db) + statuses = initStatuses(ownershipDB) + statusNotifier = createStatusNotifier(statuses, feed) + } cb := circuitbreaker.NewCircuitBreaker(circuitbreaker.Config{ Timeout: 10000, @@ -101,7 +108,7 @@ func NewManager( ownershipDB: ownershipDB, mediaServer: mediaServer, statuses: statuses, - statusNotifier: createStatusNotifier(statuses, feed), + statusNotifier: statusNotifier, feed: feed, circuitBreaker: cb, } @@ -577,12 +584,15 @@ func (o *Manager) fetchTokenURI(ctx context.Context, id thirdparty.CollectibleUn if id.TokenID == nil { return "", errors.New("empty token ID") } + backend, err := o.rpcClient.EthClient(uint64(id.ContractID.ChainID)) if err != nil { return "", err } + backend = getClientWithNoCircuitTripping(backend) caller, err := collectibles.NewCollectiblesCaller(id.ContractID.Address, backend) + if err != nil { return "", err } @@ -1162,3 +1172,32 @@ func createStatusNotifier(statuses *sync.Map, feed *event.Feed) *connection.Stat func getCircuitName(provider thirdparty.CollectibleProvider, chainID walletCommon.ChainID) string { return provider.ID() + chainID.String() } + +func getCircuitNameForTokenURI(mainCircuitName string) string { + return mainCircuitName + "_tokenURI" +} + +// As we don't use hystrix internal way of switching to another circuit, just its metrics, +// we still can switch to another provider without tripping the circuit. +func getClientWithNoCircuitTripping(backend chain.ClientInterface) chain.ClientInterface { + copyable := backend.(chain.Copyable) + if copyable != nil { + backendCopy := copyable.Copy().(chain.ClientInterface) + hm := backendCopy.(chain.HealthMonitor) + if hm != nil { + cb := circuitbreaker.NewCircuitBreaker(circuitbreaker.Config{ + Timeout: 20000, + MaxConcurrentRequests: 100, + SleepWindow: 300000, + ErrorPercentThreshold: 101, // Always healthy + }) + cb.SetOverrideCircuitNameHandler(func(circuitName string) string { + return getCircuitNameForTokenURI(circuitName) + }) + hm.SetCircuitBreaker(cb) + backend = backendCopy + } + } + + return backend +} diff --git a/services/wallet/collectibles/manager_test.go b/services/wallet/collectibles/manager_test.go new file mode 100644 index 000000000..74742fdab --- /dev/null +++ b/services/wallet/collectibles/manager_test.go @@ -0,0 +1,112 @@ +package collectibles + +import ( + "context" + "fmt" + "math/big" + "sync" + "testing" + "time" + + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + + "github.com/ethereum/go-ethereum/common" + "github.com/status-im/status-go/circuitbreaker" + mock_client "github.com/status-im/status-go/rpc/chain/mock/client" + mock_rpcclient "github.com/status-im/status-go/rpc/mock/client" + "github.com/status-im/status-go/services/wallet/bigint" + mock_collectibles "github.com/status-im/status-go/services/wallet/collectibles/mock" + walletCommon "github.com/status-im/status-go/services/wallet/common" + "github.com/status-im/status-go/services/wallet/thirdparty" + mock_thirdparty "github.com/status-im/status-go/services/wallet/thirdparty/mock" +) + +type CopyableMockChainClient struct { + *mock_client.MockClientInterface + cb *circuitbreaker.CircuitBreaker +} + +func (c *CopyableMockChainClient) Copy() interface{} { + return &CopyableMockChainClient{ + MockClientInterface: c.MockClientInterface, + } +} + +func (c *CopyableMockChainClient) GetCircuitBreaker() *circuitbreaker.CircuitBreaker { + return c.cb +} + +func (c *CopyableMockChainClient) SetCircuitBreaker(cb *circuitbreaker.CircuitBreaker) { + c.cb = cb +} + +func TestManager_FetchAllAssetsByOwner(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + + ctx := context.TODO() + chainID := walletCommon.ChainID(1) + owner := common.HexToAddress("0x1234567890abcdef") + cursor := "" + limit := 1 + timestamp := time.Now().Nanosecond() + providerID := fmt.Sprintf("circuit_%d", timestamp) + + chainClient := &CopyableMockChainClient{ + MockClientInterface: mock_client.NewMockClientInterface(mockCtrl), + } + chainClient.EXPECT().CallContract(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, nil).Times(limit) + chainClient.EXPECT().CodeAt(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, nil).Times(limit) + rpcClient := mock_rpcclient.NewMockClientInterface(mockCtrl) + rpcClient.EXPECT().EthClient(gomock.Any()).Return(chainClient, nil).AnyTimes() + mockProvider1 := mock_thirdparty.NewMockCollectibleAccountOwnershipProvider(mockCtrl) + + mockProviders := thirdparty.CollectibleProviders{ + AccountOwnershipProviders: []thirdparty.CollectibleAccountOwnershipProvider{mockProvider1}, + } + + // Generate many collectibles, but none support toeknURI method, but circuit must not be tripped + var items []thirdparty.FullCollectibleData + for i := 0; i < limit; i++ { + items = append(items, thirdparty.FullCollectibleData{ + CollectibleData: thirdparty.CollectibleData{ + ID: thirdparty.CollectibleUniqueID{ + ContractID: thirdparty.ContractID{ + Address: common.HexToAddress(fmt.Sprintf("0x%064x", i)), + }, + TokenID: &bigint.BigInt{ + Int: big.NewInt(int64(i)), + }, + }, + }, + }) + } + mockAssetContainer := &thirdparty.FullCollectibleDataContainer{ + Items: items, + } + + mockProvider1.EXPECT().IsChainSupported(chainID).Return(true).AnyTimes() + mockProvider1.EXPECT().IsConnected().Return(true).AnyTimes() + mockProvider1.EXPECT().ID().Return(providerID).AnyTimes() + mockProvider1.EXPECT().FetchAllAssetsByOwner(gomock.Any(), chainID, owner, cursor, limit).Return(mockAssetContainer, nil) + + manager := NewManager(nil, rpcClient, nil, mockProviders, nil, nil) + manager.statuses = &sync.Map{} + collectiblesDataDB := mock_collectibles.NewMockCollectibleDataStorage(mockCtrl) + collectiblesDataDB.EXPECT().SetData(gomock.Any(), gomock.Any()).Return(nil) + collectionsDataDB := mock_collectibles.NewMockCollectionDataStorage(mockCtrl) + collectionsDataDB.EXPECT().SetData(gomock.Any(), gomock.Any()).Return(nil) + manager.collectiblesDataDB = collectiblesDataDB + manager.collectionsDataDB = collectionsDataDB + + assetContainer, err := manager.FetchAllAssetsByOwner(ctx, chainID, owner, cursor, limit, providerID) + + assert.NoError(t, err) + assert.Equal(t, mockAssetContainer, assetContainer) + + // Make sure the main circuit is not tripped + circuitName := getCircuitName(mockProvider1, chainID) + assert.True(t, circuitbreaker.CircuitExists(circuitName)) + assert.False(t, circuitbreaker.IsCircuitOpen(circuitName)) +} diff --git a/services/wallet/collectibles/mock/collectible_data_db.go b/services/wallet/collectibles/mock/collectible_data_db.go new file mode 100644 index 000000000..5db870908 --- /dev/null +++ b/services/wallet/collectibles/mock/collectible_data_db.go @@ -0,0 +1,109 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: services/wallet/collectibles/collectible_data_db.go + +// Package mock_collectibles is a generated GoMock package. +package mock_collectibles + +import ( + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + + thirdparty "github.com/status-im/status-go/services/wallet/thirdparty" +) + +// MockCollectibleDataStorage is a mock of CollectibleDataStorage interface. +type MockCollectibleDataStorage struct { + ctrl *gomock.Controller + recorder *MockCollectibleDataStorageMockRecorder +} + +// MockCollectibleDataStorageMockRecorder is the mock recorder for MockCollectibleDataStorage. +type MockCollectibleDataStorageMockRecorder struct { + mock *MockCollectibleDataStorage +} + +// NewMockCollectibleDataStorage creates a new mock instance. +func NewMockCollectibleDataStorage(ctrl *gomock.Controller) *MockCollectibleDataStorage { + mock := &MockCollectibleDataStorage{ctrl: ctrl} + mock.recorder = &MockCollectibleDataStorageMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockCollectibleDataStorage) EXPECT() *MockCollectibleDataStorageMockRecorder { + return m.recorder +} + +// GetCommunityInfo mocks base method. +func (m *MockCollectibleDataStorage) GetCommunityInfo(id thirdparty.CollectibleUniqueID) (*thirdparty.CollectibleCommunityInfo, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCommunityInfo", id) + ret0, _ := ret[0].(*thirdparty.CollectibleCommunityInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCommunityInfo indicates an expected call of GetCommunityInfo. +func (mr *MockCollectibleDataStorageMockRecorder) GetCommunityInfo(id interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommunityInfo", reflect.TypeOf((*MockCollectibleDataStorage)(nil).GetCommunityInfo), id) +} + +// GetData mocks base method. +func (m *MockCollectibleDataStorage) GetData(ids []thirdparty.CollectibleUniqueID) (map[string]thirdparty.CollectibleData, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetData", ids) + ret0, _ := ret[0].(map[string]thirdparty.CollectibleData) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetData indicates an expected call of GetData. +func (mr *MockCollectibleDataStorageMockRecorder) GetData(ids interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetData", reflect.TypeOf((*MockCollectibleDataStorage)(nil).GetData), ids) +} + +// GetIDsNotInDB mocks base method. +func (m *MockCollectibleDataStorage) GetIDsNotInDB(ids []thirdparty.CollectibleUniqueID) ([]thirdparty.CollectibleUniqueID, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetIDsNotInDB", ids) + ret0, _ := ret[0].([]thirdparty.CollectibleUniqueID) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetIDsNotInDB indicates an expected call of GetIDsNotInDB. +func (mr *MockCollectibleDataStorageMockRecorder) GetIDsNotInDB(ids interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIDsNotInDB", reflect.TypeOf((*MockCollectibleDataStorage)(nil).GetIDsNotInDB), ids) +} + +// SetCommunityInfo mocks base method. +func (m *MockCollectibleDataStorage) SetCommunityInfo(id thirdparty.CollectibleUniqueID, communityInfo thirdparty.CollectibleCommunityInfo) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetCommunityInfo", id, communityInfo) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetCommunityInfo indicates an expected call of SetCommunityInfo. +func (mr *MockCollectibleDataStorageMockRecorder) SetCommunityInfo(id, communityInfo interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCommunityInfo", reflect.TypeOf((*MockCollectibleDataStorage)(nil).SetCommunityInfo), id, communityInfo) +} + +// SetData mocks base method. +func (m *MockCollectibleDataStorage) SetData(collectibles []thirdparty.CollectibleData, allowUpdate bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetData", collectibles, allowUpdate) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetData indicates an expected call of SetData. +func (mr *MockCollectibleDataStorageMockRecorder) SetData(collectibles, allowUpdate interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetData", reflect.TypeOf((*MockCollectibleDataStorage)(nil).SetData), collectibles, allowUpdate) +} diff --git a/services/wallet/collectibles/mock/collection_data_db.go b/services/wallet/collectibles/mock/collection_data_db.go new file mode 100644 index 000000000..877ba5a2c --- /dev/null +++ b/services/wallet/collectibles/mock/collection_data_db.go @@ -0,0 +1,109 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: services/wallet/collectibles/collection_data_db.go + +// Package mock_collectibles is a generated GoMock package. +package mock_collectibles + +import ( + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + + thirdparty "github.com/status-im/status-go/services/wallet/thirdparty" +) + +// MockCollectionDataStorage is a mock of CollectionDataStorage interface. +type MockCollectionDataStorage struct { + ctrl *gomock.Controller + recorder *MockCollectionDataStorageMockRecorder +} + +// MockCollectionDataStorageMockRecorder is the mock recorder for MockCollectionDataStorage. +type MockCollectionDataStorageMockRecorder struct { + mock *MockCollectionDataStorage +} + +// NewMockCollectionDataStorage creates a new mock instance. +func NewMockCollectionDataStorage(ctrl *gomock.Controller) *MockCollectionDataStorage { + mock := &MockCollectionDataStorage{ctrl: ctrl} + mock.recorder = &MockCollectionDataStorageMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockCollectionDataStorage) EXPECT() *MockCollectionDataStorageMockRecorder { + return m.recorder +} + +// GetData mocks base method. +func (m *MockCollectionDataStorage) GetData(ids []thirdparty.ContractID) (map[string]thirdparty.CollectionData, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetData", ids) + ret0, _ := ret[0].(map[string]thirdparty.CollectionData) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetData indicates an expected call of GetData. +func (mr *MockCollectionDataStorageMockRecorder) GetData(ids interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetData", reflect.TypeOf((*MockCollectionDataStorage)(nil).GetData), ids) +} + +// GetIDsNotInDB mocks base method. +func (m *MockCollectionDataStorage) GetIDsNotInDB(ids []thirdparty.ContractID) ([]thirdparty.ContractID, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetIDsNotInDB", ids) + ret0, _ := ret[0].([]thirdparty.ContractID) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetIDsNotInDB indicates an expected call of GetIDsNotInDB. +func (mr *MockCollectionDataStorageMockRecorder) GetIDsNotInDB(ids interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIDsNotInDB", reflect.TypeOf((*MockCollectionDataStorage)(nil).GetIDsNotInDB), ids) +} + +// GetSocialsForID mocks base method. +func (m *MockCollectionDataStorage) GetSocialsForID(contractID thirdparty.ContractID) (*thirdparty.CollectionSocials, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSocialsForID", contractID) + ret0, _ := ret[0].(*thirdparty.CollectionSocials) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetSocialsForID indicates an expected call of GetSocialsForID. +func (mr *MockCollectionDataStorageMockRecorder) GetSocialsForID(contractID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSocialsForID", reflect.TypeOf((*MockCollectionDataStorage)(nil).GetSocialsForID), contractID) +} + +// SetCollectionSocialsData mocks base method. +func (m *MockCollectionDataStorage) SetCollectionSocialsData(id thirdparty.ContractID, collectionSocials *thirdparty.CollectionSocials) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetCollectionSocialsData", id, collectionSocials) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetCollectionSocialsData indicates an expected call of SetCollectionSocialsData. +func (mr *MockCollectionDataStorageMockRecorder) SetCollectionSocialsData(id, collectionSocials interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCollectionSocialsData", reflect.TypeOf((*MockCollectionDataStorage)(nil).SetCollectionSocialsData), id, collectionSocials) +} + +// SetData mocks base method. +func (m *MockCollectionDataStorage) SetData(collections []thirdparty.CollectionData, allowUpdate bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetData", collections, allowUpdate) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetData indicates an expected call of SetData. +func (mr *MockCollectionDataStorageMockRecorder) SetData(collections, allowUpdate interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetData", reflect.TypeOf((*MockCollectionDataStorage)(nil).SetData), collections, allowUpdate) +} diff --git a/services/wallet/thirdparty/mock/collectible_types.go b/services/wallet/thirdparty/mock/collectible_types.go new file mode 100644 index 000000000..b4eb29fdd --- /dev/null +++ b/services/wallet/thirdparty/mock/collectible_types.go @@ -0,0 +1,526 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: services/wallet/thirdparty/collectible_types.go + +// Package mock_thirdparty is a generated GoMock package. +package mock_thirdparty + +import ( + context "context" + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + + common "github.com/ethereum/go-ethereum/common" + common0 "github.com/status-im/status-go/services/wallet/common" + thirdparty "github.com/status-im/status-go/services/wallet/thirdparty" +) + +// MockCollectibleProvider is a mock of CollectibleProvider interface. +type MockCollectibleProvider struct { + ctrl *gomock.Controller + recorder *MockCollectibleProviderMockRecorder +} + +// MockCollectibleProviderMockRecorder is the mock recorder for MockCollectibleProvider. +type MockCollectibleProviderMockRecorder struct { + mock *MockCollectibleProvider +} + +// NewMockCollectibleProvider creates a new mock instance. +func NewMockCollectibleProvider(ctrl *gomock.Controller) *MockCollectibleProvider { + mock := &MockCollectibleProvider{ctrl: ctrl} + mock.recorder = &MockCollectibleProviderMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockCollectibleProvider) EXPECT() *MockCollectibleProviderMockRecorder { + return m.recorder +} + +// ID mocks base method. +func (m *MockCollectibleProvider) ID() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ID") + ret0, _ := ret[0].(string) + return ret0 +} + +// ID indicates an expected call of ID. +func (mr *MockCollectibleProviderMockRecorder) ID() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockCollectibleProvider)(nil).ID)) +} + +// IsChainSupported mocks base method. +func (m *MockCollectibleProvider) IsChainSupported(chainID common0.ChainID) bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsChainSupported", chainID) + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsChainSupported indicates an expected call of IsChainSupported. +func (mr *MockCollectibleProviderMockRecorder) IsChainSupported(chainID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsChainSupported", reflect.TypeOf((*MockCollectibleProvider)(nil).IsChainSupported), chainID) +} + +// IsConnected mocks base method. +func (m *MockCollectibleProvider) IsConnected() bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsConnected") + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsConnected indicates an expected call of IsConnected. +func (mr *MockCollectibleProviderMockRecorder) IsConnected() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsConnected", reflect.TypeOf((*MockCollectibleProvider)(nil).IsConnected)) +} + +// MockCollectibleContractOwnershipProvider is a mock of CollectibleContractOwnershipProvider interface. +type MockCollectibleContractOwnershipProvider struct { + ctrl *gomock.Controller + recorder *MockCollectibleContractOwnershipProviderMockRecorder +} + +// MockCollectibleContractOwnershipProviderMockRecorder is the mock recorder for MockCollectibleContractOwnershipProvider. +type MockCollectibleContractOwnershipProviderMockRecorder struct { + mock *MockCollectibleContractOwnershipProvider +} + +// NewMockCollectibleContractOwnershipProvider creates a new mock instance. +func NewMockCollectibleContractOwnershipProvider(ctrl *gomock.Controller) *MockCollectibleContractOwnershipProvider { + mock := &MockCollectibleContractOwnershipProvider{ctrl: ctrl} + mock.recorder = &MockCollectibleContractOwnershipProviderMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockCollectibleContractOwnershipProvider) EXPECT() *MockCollectibleContractOwnershipProviderMockRecorder { + return m.recorder +} + +// FetchCollectibleOwnersByContractAddress mocks base method. +func (m *MockCollectibleContractOwnershipProvider) FetchCollectibleOwnersByContractAddress(ctx context.Context, chainID common0.ChainID, contractAddress common.Address) (*thirdparty.CollectibleContractOwnership, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchCollectibleOwnersByContractAddress", ctx, chainID, contractAddress) + ret0, _ := ret[0].(*thirdparty.CollectibleContractOwnership) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FetchCollectibleOwnersByContractAddress indicates an expected call of FetchCollectibleOwnersByContractAddress. +func (mr *MockCollectibleContractOwnershipProviderMockRecorder) FetchCollectibleOwnersByContractAddress(ctx, chainID, contractAddress interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchCollectibleOwnersByContractAddress", reflect.TypeOf((*MockCollectibleContractOwnershipProvider)(nil).FetchCollectibleOwnersByContractAddress), ctx, chainID, contractAddress) +} + +// ID mocks base method. +func (m *MockCollectibleContractOwnershipProvider) ID() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ID") + ret0, _ := ret[0].(string) + return ret0 +} + +// ID indicates an expected call of ID. +func (mr *MockCollectibleContractOwnershipProviderMockRecorder) ID() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockCollectibleContractOwnershipProvider)(nil).ID)) +} + +// IsChainSupported mocks base method. +func (m *MockCollectibleContractOwnershipProvider) IsChainSupported(chainID common0.ChainID) bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsChainSupported", chainID) + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsChainSupported indicates an expected call of IsChainSupported. +func (mr *MockCollectibleContractOwnershipProviderMockRecorder) IsChainSupported(chainID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsChainSupported", reflect.TypeOf((*MockCollectibleContractOwnershipProvider)(nil).IsChainSupported), chainID) +} + +// IsConnected mocks base method. +func (m *MockCollectibleContractOwnershipProvider) IsConnected() bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsConnected") + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsConnected indicates an expected call of IsConnected. +func (mr *MockCollectibleContractOwnershipProviderMockRecorder) IsConnected() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsConnected", reflect.TypeOf((*MockCollectibleContractOwnershipProvider)(nil).IsConnected)) +} + +// MockCollectibleAccountOwnershipProvider is a mock of CollectibleAccountOwnershipProvider interface. +type MockCollectibleAccountOwnershipProvider struct { + ctrl *gomock.Controller + recorder *MockCollectibleAccountOwnershipProviderMockRecorder +} + +// MockCollectibleAccountOwnershipProviderMockRecorder is the mock recorder for MockCollectibleAccountOwnershipProvider. +type MockCollectibleAccountOwnershipProviderMockRecorder struct { + mock *MockCollectibleAccountOwnershipProvider +} + +// NewMockCollectibleAccountOwnershipProvider creates a new mock instance. +func NewMockCollectibleAccountOwnershipProvider(ctrl *gomock.Controller) *MockCollectibleAccountOwnershipProvider { + mock := &MockCollectibleAccountOwnershipProvider{ctrl: ctrl} + mock.recorder = &MockCollectibleAccountOwnershipProviderMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockCollectibleAccountOwnershipProvider) EXPECT() *MockCollectibleAccountOwnershipProviderMockRecorder { + return m.recorder +} + +// FetchAllAssetsByOwner mocks base method. +func (m *MockCollectibleAccountOwnershipProvider) FetchAllAssetsByOwner(ctx context.Context, chainID common0.ChainID, owner common.Address, cursor string, limit int) (*thirdparty.FullCollectibleDataContainer, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchAllAssetsByOwner", ctx, chainID, owner, cursor, limit) + ret0, _ := ret[0].(*thirdparty.FullCollectibleDataContainer) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FetchAllAssetsByOwner indicates an expected call of FetchAllAssetsByOwner. +func (mr *MockCollectibleAccountOwnershipProviderMockRecorder) FetchAllAssetsByOwner(ctx, chainID, owner, cursor, limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchAllAssetsByOwner", reflect.TypeOf((*MockCollectibleAccountOwnershipProvider)(nil).FetchAllAssetsByOwner), ctx, chainID, owner, cursor, limit) +} + +// FetchAllAssetsByOwnerAndContractAddress mocks base method. +func (m *MockCollectibleAccountOwnershipProvider) FetchAllAssetsByOwnerAndContractAddress(ctx context.Context, chainID common0.ChainID, owner common.Address, contractAddresses []common.Address, cursor string, limit int) (*thirdparty.FullCollectibleDataContainer, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchAllAssetsByOwnerAndContractAddress", ctx, chainID, owner, contractAddresses, cursor, limit) + ret0, _ := ret[0].(*thirdparty.FullCollectibleDataContainer) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FetchAllAssetsByOwnerAndContractAddress indicates an expected call of FetchAllAssetsByOwnerAndContractAddress. +func (mr *MockCollectibleAccountOwnershipProviderMockRecorder) FetchAllAssetsByOwnerAndContractAddress(ctx, chainID, owner, contractAddresses, cursor, limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchAllAssetsByOwnerAndContractAddress", reflect.TypeOf((*MockCollectibleAccountOwnershipProvider)(nil).FetchAllAssetsByOwnerAndContractAddress), ctx, chainID, owner, contractAddresses, cursor, limit) +} + +// ID mocks base method. +func (m *MockCollectibleAccountOwnershipProvider) ID() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ID") + ret0, _ := ret[0].(string) + return ret0 +} + +// ID indicates an expected call of ID. +func (mr *MockCollectibleAccountOwnershipProviderMockRecorder) ID() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockCollectibleAccountOwnershipProvider)(nil).ID)) +} + +// IsChainSupported mocks base method. +func (m *MockCollectibleAccountOwnershipProvider) IsChainSupported(chainID common0.ChainID) bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsChainSupported", chainID) + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsChainSupported indicates an expected call of IsChainSupported. +func (mr *MockCollectibleAccountOwnershipProviderMockRecorder) IsChainSupported(chainID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsChainSupported", reflect.TypeOf((*MockCollectibleAccountOwnershipProvider)(nil).IsChainSupported), chainID) +} + +// IsConnected mocks base method. +func (m *MockCollectibleAccountOwnershipProvider) IsConnected() bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsConnected") + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsConnected indicates an expected call of IsConnected. +func (mr *MockCollectibleAccountOwnershipProviderMockRecorder) IsConnected() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsConnected", reflect.TypeOf((*MockCollectibleAccountOwnershipProvider)(nil).IsConnected)) +} + +// MockCollectibleDataProvider is a mock of CollectibleDataProvider interface. +type MockCollectibleDataProvider struct { + ctrl *gomock.Controller + recorder *MockCollectibleDataProviderMockRecorder +} + +// MockCollectibleDataProviderMockRecorder is the mock recorder for MockCollectibleDataProvider. +type MockCollectibleDataProviderMockRecorder struct { + mock *MockCollectibleDataProvider +} + +// NewMockCollectibleDataProvider creates a new mock instance. +func NewMockCollectibleDataProvider(ctrl *gomock.Controller) *MockCollectibleDataProvider { + mock := &MockCollectibleDataProvider{ctrl: ctrl} + mock.recorder = &MockCollectibleDataProviderMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockCollectibleDataProvider) EXPECT() *MockCollectibleDataProviderMockRecorder { + return m.recorder +} + +// FetchAssetsByCollectibleUniqueID mocks base method. +func (m *MockCollectibleDataProvider) FetchAssetsByCollectibleUniqueID(ctx context.Context, uniqueIDs []thirdparty.CollectibleUniqueID) ([]thirdparty.FullCollectibleData, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchAssetsByCollectibleUniqueID", ctx, uniqueIDs) + ret0, _ := ret[0].([]thirdparty.FullCollectibleData) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FetchAssetsByCollectibleUniqueID indicates an expected call of FetchAssetsByCollectibleUniqueID. +func (mr *MockCollectibleDataProviderMockRecorder) FetchAssetsByCollectibleUniqueID(ctx, uniqueIDs interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchAssetsByCollectibleUniqueID", reflect.TypeOf((*MockCollectibleDataProvider)(nil).FetchAssetsByCollectibleUniqueID), ctx, uniqueIDs) +} + +// FetchCollectionSocials mocks base method. +func (m *MockCollectibleDataProvider) FetchCollectionSocials(ctx context.Context, contractID thirdparty.ContractID) (*thirdparty.CollectionSocials, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchCollectionSocials", ctx, contractID) + ret0, _ := ret[0].(*thirdparty.CollectionSocials) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FetchCollectionSocials indicates an expected call of FetchCollectionSocials. +func (mr *MockCollectibleDataProviderMockRecorder) FetchCollectionSocials(ctx, contractID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchCollectionSocials", reflect.TypeOf((*MockCollectibleDataProvider)(nil).FetchCollectionSocials), ctx, contractID) +} + +// ID mocks base method. +func (m *MockCollectibleDataProvider) ID() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ID") + ret0, _ := ret[0].(string) + return ret0 +} + +// ID indicates an expected call of ID. +func (mr *MockCollectibleDataProviderMockRecorder) ID() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockCollectibleDataProvider)(nil).ID)) +} + +// IsChainSupported mocks base method. +func (m *MockCollectibleDataProvider) IsChainSupported(chainID common0.ChainID) bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsChainSupported", chainID) + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsChainSupported indicates an expected call of IsChainSupported. +func (mr *MockCollectibleDataProviderMockRecorder) IsChainSupported(chainID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsChainSupported", reflect.TypeOf((*MockCollectibleDataProvider)(nil).IsChainSupported), chainID) +} + +// IsConnected mocks base method. +func (m *MockCollectibleDataProvider) IsConnected() bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsConnected") + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsConnected indicates an expected call of IsConnected. +func (mr *MockCollectibleDataProviderMockRecorder) IsConnected() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsConnected", reflect.TypeOf((*MockCollectibleDataProvider)(nil).IsConnected)) +} + +// MockCollectionDataProvider is a mock of CollectionDataProvider interface. +type MockCollectionDataProvider struct { + ctrl *gomock.Controller + recorder *MockCollectionDataProviderMockRecorder +} + +// MockCollectionDataProviderMockRecorder is the mock recorder for MockCollectionDataProvider. +type MockCollectionDataProviderMockRecorder struct { + mock *MockCollectionDataProvider +} + +// NewMockCollectionDataProvider creates a new mock instance. +func NewMockCollectionDataProvider(ctrl *gomock.Controller) *MockCollectionDataProvider { + mock := &MockCollectionDataProvider{ctrl: ctrl} + mock.recorder = &MockCollectionDataProviderMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockCollectionDataProvider) EXPECT() *MockCollectionDataProviderMockRecorder { + return m.recorder +} + +// FetchCollectionsDataByContractID mocks base method. +func (m *MockCollectionDataProvider) FetchCollectionsDataByContractID(ctx context.Context, ids []thirdparty.ContractID) ([]thirdparty.CollectionData, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchCollectionsDataByContractID", ctx, ids) + ret0, _ := ret[0].([]thirdparty.CollectionData) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FetchCollectionsDataByContractID indicates an expected call of FetchCollectionsDataByContractID. +func (mr *MockCollectionDataProviderMockRecorder) FetchCollectionsDataByContractID(ctx, ids interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchCollectionsDataByContractID", reflect.TypeOf((*MockCollectionDataProvider)(nil).FetchCollectionsDataByContractID), ctx, ids) +} + +// ID mocks base method. +func (m *MockCollectionDataProvider) ID() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ID") + ret0, _ := ret[0].(string) + return ret0 +} + +// ID indicates an expected call of ID. +func (mr *MockCollectionDataProviderMockRecorder) ID() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockCollectionDataProvider)(nil).ID)) +} + +// IsChainSupported mocks base method. +func (m *MockCollectionDataProvider) IsChainSupported(chainID common0.ChainID) bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsChainSupported", chainID) + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsChainSupported indicates an expected call of IsChainSupported. +func (mr *MockCollectionDataProviderMockRecorder) IsChainSupported(chainID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsChainSupported", reflect.TypeOf((*MockCollectionDataProvider)(nil).IsChainSupported), chainID) +} + +// IsConnected mocks base method. +func (m *MockCollectionDataProvider) IsConnected() bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsConnected") + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsConnected indicates an expected call of IsConnected. +func (mr *MockCollectionDataProviderMockRecorder) IsConnected() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsConnected", reflect.TypeOf((*MockCollectionDataProvider)(nil).IsConnected)) +} + +// MockCollectibleSearchProvider is a mock of CollectibleSearchProvider interface. +type MockCollectibleSearchProvider struct { + ctrl *gomock.Controller + recorder *MockCollectibleSearchProviderMockRecorder +} + +// MockCollectibleSearchProviderMockRecorder is the mock recorder for MockCollectibleSearchProvider. +type MockCollectibleSearchProviderMockRecorder struct { + mock *MockCollectibleSearchProvider +} + +// NewMockCollectibleSearchProvider creates a new mock instance. +func NewMockCollectibleSearchProvider(ctrl *gomock.Controller) *MockCollectibleSearchProvider { + mock := &MockCollectibleSearchProvider{ctrl: ctrl} + mock.recorder = &MockCollectibleSearchProviderMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockCollectibleSearchProvider) EXPECT() *MockCollectibleSearchProviderMockRecorder { + return m.recorder +} + +// ID mocks base method. +func (m *MockCollectibleSearchProvider) ID() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ID") + ret0, _ := ret[0].(string) + return ret0 +} + +// ID indicates an expected call of ID. +func (mr *MockCollectibleSearchProviderMockRecorder) ID() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockCollectibleSearchProvider)(nil).ID)) +} + +// IsChainSupported mocks base method. +func (m *MockCollectibleSearchProvider) IsChainSupported(chainID common0.ChainID) bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsChainSupported", chainID) + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsChainSupported indicates an expected call of IsChainSupported. +func (mr *MockCollectibleSearchProviderMockRecorder) IsChainSupported(chainID interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsChainSupported", reflect.TypeOf((*MockCollectibleSearchProvider)(nil).IsChainSupported), chainID) +} + +// IsConnected mocks base method. +func (m *MockCollectibleSearchProvider) IsConnected() bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsConnected") + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsConnected indicates an expected call of IsConnected. +func (mr *MockCollectibleSearchProviderMockRecorder) IsConnected() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsConnected", reflect.TypeOf((*MockCollectibleSearchProvider)(nil).IsConnected)) +} + +// SearchCollectibles mocks base method. +func (m *MockCollectibleSearchProvider) SearchCollectibles(ctx context.Context, chainID common0.ChainID, collections []common.Address, text, cursor string, limit int) (*thirdparty.FullCollectibleDataContainer, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SearchCollectibles", ctx, chainID, collections, text, cursor, limit) + ret0, _ := ret[0].(*thirdparty.FullCollectibleDataContainer) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchCollectibles indicates an expected call of SearchCollectibles. +func (mr *MockCollectibleSearchProviderMockRecorder) SearchCollectibles(ctx, chainID, collections, text, cursor, limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchCollectibles", reflect.TypeOf((*MockCollectibleSearchProvider)(nil).SearchCollectibles), ctx, chainID, collections, text, cursor, limit) +} + +// SearchCollections mocks base method. +func (m *MockCollectibleSearchProvider) SearchCollections(ctx context.Context, chainID common0.ChainID, text, cursor string, limit int) (*thirdparty.CollectionDataContainer, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SearchCollections", ctx, chainID, text, cursor, limit) + ret0, _ := ret[0].(*thirdparty.CollectionDataContainer) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchCollections indicates an expected call of SearchCollections. +func (mr *MockCollectibleSearchProviderMockRecorder) SearchCollections(ctx, chainID, text, cursor, limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchCollections", reflect.TypeOf((*MockCollectibleSearchProvider)(nil).SearchCollections), ctx, chainID, text, cursor, limit) +}