fix: fetch metadata for unkown erc20 tokens spotted in Alchemy transactions

Author: vkjr

node/get_status_node.go

@@ -126,6 +126,7 @@ type StatusNode struct {
 
 	walletFeed        event.Feed
 	accountsPublisher *pubsub.Publisher
+	tokenPublisher    *pubsub.Publisher
 
 	localBackup *backup.Controller
 }
@@ -139,6 +140,7 @@ func New(transactor *transactions.Transactor, gethAccountsManager *accsmanagemen
 		logger:              logger,
 		publicMethods:       make(map[string]bool),
 		accountsPublisher:   pubsub.NewPublisher(),
+		tokenPublisher:      pubsub.NewPublisher(),
 		rpcServer:           gethrpc.NewServer(),
 	}
 }
@@ -370,7 +372,7 @@ func (n *StatusNode) createAndStartTokenManager() error {
 	}
 
 	n.tokenManager = token.NewTokenManager(n.walletDB, n.rpcClient, community.NewManager(n.appDB, n.mediaServer, nil),
-		n.rpcClient.GetNetworkManager(), n.appDB, n.mediaServer, &n.walletFeed, n.accountsPublisher, accDB,
+		n.rpcClient.GetNetworkManager(), n.appDB, n.mediaServer, &n.walletFeed, n.accountsPublisher, n.tokenPublisher, accDB,
 		token.NewPersistence(n.walletDB))
 
 	const (
@@ -430,6 +432,7 @@ func (n *StatusNode) Stop() error {
 	}
 
 	n.accountsPublisher.Close()
+	n.tokenPublisher.Close()
 
 	n.rpcClient.Stop()
 	n.rpcClient = nil

services/wallet/activity/activity_v2.go

@@ -8,6 +8,7 @@ import (
 
 	eth "github.com/ethereum/go-ethereum/common"
 
+	"github.com/status-im/status-go/pkg/pubsub"
 	ac "github.com/status-im/status-go/services/wallet/activity/common"
 	wCommon "github.com/status-im/status-go/services/wallet/common"
 )
@@ -20,6 +21,8 @@ type FilterDependencies struct {
 	tokenFromSymbol func(chainID *wCommon.ChainID, symbol string) *ac.Token
 	// use to get current timestamp
 	currentTimestamp func() int64
+	// tokenPublisher for async token discovery requests
+	tokenPublisher *pubsub.Publisher
 }
 
 type TransactionOrigin int

services/wallet/activity/fetched_entries.go

@@ -12,17 +12,18 @@ import (
 	eth "github.com/ethereum/go-ethereum/common"
 
 	"github.com/status-im/status-go/logutils"
+	"github.com/status-im/status-go/pkg/pubsub"
 	ac "github.com/status-im/status-go/services/wallet/activity/common"
 	wCommon "github.com/status-im/status-go/services/wallet/common"
 	"github.com/status-im/status-go/services/wallet/thirdparty"
 	"github.com/status-im/status-go/services/wallet/thirdparty/activity/alchemy"
+	"github.com/status-im/status-go/services/wallet/token/tokenevent"
 	"github.com/status-im/status-go/sqlite"
 )
 
 // getFetchedEntriesByIDs fetches Alchemy transaction details by IDs
 // Returns a map keyed by "chainID-hash-address" string
 func getFetchedEntriesByIDs(ctx context.Context, deps FilterDependencies, txIDs []OrderedTransactionID) (map[string]Entry, error) {
-
 	if len(txIDs) == 0 {
 		return make(map[string]Entry), nil
 	}
@@ -75,6 +76,22 @@ func getFetchedEntriesByIDs(ctx context.Context, deps FilterDependencies, txIDs
 		return nil, fmt.Errorf("failed to convert rows to transfers: %w", err)
 	}
 
+	// Request async token discovery for ERC20 transfers to make sure we have their metadata
+	if deps.tokenPublisher != nil {
+		for chainID, addressMap := range transfersMap {
+			for _, transfers := range addressMap {
+				for _, transfer := range transfers {
+					if transfer.Category == alchemy.TransferCategoryErc20 && transfer.RawContract.Address != nil {
+						pubsub.Publish(deps.tokenPublisher, tokenevent.TokenDiscoveryRequestEvent{
+							ChainID: uint64(chainID),
+							Address: *transfer.RawContract.Address,
+						})
+					}
+				}
+			}
+		}
+	}
+
 	result := make(map[string]Entry)
 	for chainID, addressMap := range transfersMap {
 		for address, transfers := range addressMap {
@@ -176,6 +193,7 @@ func thirdpartyActivityEntriesToEntries(deps FilterDependencies, activityEntries
 		}
 
 		entry.symbolOut, entry.symbolIn = lookupAndFillInTokens(deps, entry.tokenOut, entry.tokenIn)
+
 		entries = append(entries, entry)
 	}
 

services/wallet/activity/service.go

@@ -356,9 +356,10 @@ func (s *Service) getDeps() FilterDependencies {
 				Address:   t.Address,
 			}
 		},
-		currentTimestamp: func() int64 {
+			currentTimestamp: func() int64 {
 			return time.Now().Unix()
 		},
+		tokenPublisher: s.tokenManager.GetTokenPublisher(),
 	}
 }
 

services/wallet/activityfetcher/alchemy/manager.go

@@ -9,20 +9,24 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	geth_rpc "github.com/ethereum/go-ethereum/rpc"
 
+	"github.com/status-im/status-go/pkg/pubsub"
 	wc "github.com/status-im/status-go/services/wallet/common"
 	"github.com/status-im/status-go/services/wallet/thirdparty"
 	alchemy "github.com/status-im/status-go/services/wallet/thirdparty/activity/alchemy"
+	"github.com/status-im/status-go/services/wallet/token/tokenevent"
 )
 
 type Manager struct {
-	client      *alchemy.Client
-	persistence *alchemy.Persistence
+	client         *alchemy.Client
+	persistence    *alchemy.Persistence
+	tokenPublisher *pubsub.Publisher
 }
 
-func NewManager(client *alchemy.Client, persistence *alchemy.Persistence) *Manager {
+func NewManager(client *alchemy.Client, persistence *alchemy.Persistence, tokenPublisher *pubsub.Publisher) *Manager {
 	return &Manager{
-		client:      client,
-		persistence: persistence,
+		client:         client,
+		persistence:    persistence,
+		tokenPublisher: tokenPublisher,
 	}
 }
 
@@ -44,7 +48,6 @@ func (m *Manager) GetLastFetchedBlockAndTimestamp(ctx context.Context, chainID u
 
 // FetchActivity orchestrates fetching, persistence, and type conversion.
 func (m *Manager) FetchActivity(ctx context.Context, chainID uint64, parameters thirdparty.ActivityFetchParameters, cursor string, limit int) (thirdparty.ActivityEntryContainer, error) {
-
 	transfers, nextCursor, err := m.client.FetchTransfers(ctx, chainID, parameters, cursor, limit)
 	if err != nil {
 		return thirdparty.ActivityEntryContainer{}, err
@@ -55,6 +58,18 @@ func (m *Manager) FetchActivity(ctx context.Context, chainID uint64, parameters
 		return thirdparty.ActivityEntryContainer{}, err
 	}
 
+	// Request async token discovery for ERC20 transfers to make sure we have their metadata
+	if m.tokenPublisher != nil {
+		for _, transfer := range transfers {
+			if transfer.Category == alchemy.TransferCategoryErc20 && transfer.RawContract.Address != nil {
+				pubsub.Publish(m.tokenPublisher, tokenevent.TokenDiscoveryRequestEvent{
+					ChainID: chainID,
+					Address: *transfer.RawContract.Address,
+				})
+			}
+		}
+	}
+
 	items := alchemy.TransfersToThirdpartyActivityEntries(transfers, chainID, parameters.Address)
 
 	return thirdparty.ActivityEntryContainer{

services/wallet/service.go

@@ -261,7 +261,7 @@ func NewService(
 	alchemyEthClientGetter := rpc.NewProviderChainClientGetter(common.SmartProxyAlchemy, rpcClient)
 	alchemyFetcherDb := activityfetcher_alchemy.NewPersistence(db)
 	alchemyFetcherClient := activityfetcher_alchemy.NewClient(alchemyEthClientGetter)
-	alchemyFetcherManager := alchemymanager.NewManager(alchemyFetcherClient, alchemyFetcherDb)
+	alchemyFetcherManager := alchemymanager.NewManager(alchemyFetcherClient, alchemyFetcherDb, tokenManager.GetTokenPublisher())
 	activityFetcherManager := activityfetcher.NewManager(alchemyFetcherManager)
 	activityFetcherService := activityfetcher.NewService(activityFetcherManager, rpcClient.GetNetworkManager(), accountsDB, accountsPublisher, rpcClient, feed)
 

services/wallet/thirdparty/activity/alchemy/conversions.go

@@ -172,22 +172,30 @@ func extractTransferTokenAndValue(t Transfer, chainID uint64) []transferTokenAnd
 			Value: (*hexutil.Big)(t.RawContract.Value.Int),
 		})
 	case TransferCategoryErc721:
+		var tokenID *hexutil.Big
+		if t.TokenID != nil && t.TokenID.Int != nil {
+			tokenID = (*hexutil.Big)(t.TokenID.Int)
+		}
 		transfersData = append(transfersData, transferTokenAndValue{
 			Token: ac.Token{
 				TokenType: ac.Erc721,
 				ChainID:   wCommon.ChainID(chainID),
 				Address:   *t.RawContract.Address,
-				TokenID:   (*hexutil.Big)(t.TokenID.Int),
+				TokenID:   tokenID,
 			},
 		})
 	case TransferCategoryErc1155:
 		for _, m := range t.Erc1155Metadata {
+			var tokenID *hexutil.Big
+			if m.TokenID != nil && m.TokenID.Int != nil {
+				tokenID = (*hexutil.Big)(m.TokenID.Int)
+			}
 			transfersData = append(transfersData, transferTokenAndValue{
 				Token: ac.Token{
 					TokenType: ac.Erc1155,
 					ChainID:   wCommon.ChainID(chainID),
 					Address:   *t.RawContract.Address,
-					TokenID:   (*hexutil.Big)(m.TokenID.Int),
+					TokenID:   tokenID,
 				},
 				Value: (*hexutil.Big)(m.Value.Int),
 			})

services/wallet/thirdparty/activity/alchemy/types.go

@@ -19,7 +19,7 @@ const MaxAssetTransfersCount = 1000
 // AlchemyBigInt wraps VarHexBigInt to handle Alchemy API inconsistency
 // it sometimes returns plain decimal numbers instead of hexadecimal
 type AlchemyBigInt struct {
-	*bigint.VarHexBigInt
+	bigint.VarHexBigInt
 }
 
 func (a *AlchemyBigInt) UnmarshalJSON(data []byte) error {
@@ -31,16 +31,15 @@ func (a *AlchemyBigInt) UnmarshalJSON(data []byte) error {
 	// alchemy sometimes returns plain numbers like "0" or "1" without "0x" prefix
 	// so we need to take this into account
 	if len(str) >= 2 && str[0:2] == "0x" {
-		// hex string case
-		a.VarHexBigInt = &bigint.VarHexBigInt{}
+		// hex string case - unmarshal directly into embedded struct
 		return a.VarHexBigInt.UnmarshalJSON(data)
 	} else {
 		// plain decimal number
 		val := new(big.Int)
 		if _, ok := val.SetString(str, 10); !ok {
 			return fmt.Errorf("invalid decimal number: %s", str)
 		}
-		a.VarHexBigInt = &bigint.VarHexBigInt{Int: val}
+		a.VarHexBigInt.Int = val
 		return nil
 	}
 }

services/wallet/token/token.go

@@ -38,8 +38,10 @@ import (
 	"github.com/status-im/status-go/services/wallet/community"
 	tokenlists "github.com/status-im/status-go/services/wallet/token/token-lists"
 	"github.com/status-im/status-go/services/wallet/token/token-lists/fetcher"
+	"github.com/status-im/status-go/services/wallet/token/tokenevent"
 	tokenTypes "github.com/status-im/status-go/services/wallet/token/types"
 	"github.com/status-im/status-go/services/wallet/walletevent"
+	"github.com/status-im/status-go/signal"
 )
 
 const (
@@ -76,6 +78,7 @@ type ManagerInterface interface {
 	FindOrCreateTokenByAddress(ctx context.Context, chainID uint64, address common.Address) *tokenTypes.Token
 	MarkAsPreviouslyOwnedToken(token *tokenTypes.Token, owner common.Address) (bool, error)
 	SignalCommunityTokenReceived(address common.Address, txHash common.Hash, value *big.Int, t *tokenTypes.Token, isFirst bool)
+	GetTokenPublisher() *pubsub.Publisher
 }
 
 // Manager is used for accessing token store. It changes the token store based on overridden tokens
@@ -90,6 +93,7 @@ type Manager struct {
 	walletFeed           *event.Feed
 	accountsDB           *accounts.Database
 	accountsPublisher    *pubsub.Publisher
+	tokenPublisher       *pubsub.Publisher
 	tokenBalancesStorage TokenBalancesStorage
 
 	tokenLists *tokenlists.TokenLists
@@ -106,6 +110,7 @@ func NewTokenManager(
 	mediaServer *server.MediaServer,
 	walletFeed *event.Feed,
 	accountsPublisher *pubsub.Publisher,
+	tokenPublisher *pubsub.Publisher,
 	accountsDB *accounts.Database,
 	tokenBalancesStorage TokenBalancesStorage,
 ) *Manager {
@@ -127,6 +132,7 @@ func NewTokenManager(
 		mediaServer:          mediaServer,
 		walletFeed:           walletFeed,
 		accountsPublisher:    accountsPublisher,
+		tokenPublisher:       tokenPublisher,
 		accountsDB:           accountsDB,
 		tokenBalancesStorage: tokenBalancesStorage,
 		tokenLists:           tokensLists,
@@ -136,6 +142,7 @@ func NewTokenManager(
 func (tm *Manager) Start(ctx context.Context, autoRefreshInterval time.Duration, autoRefreshCheckInterval time.Duration) {
 	tm.stopCh = make(chan struct{})
 	tm.startAccountsWatcher()
+	tm.startTokenDiscoveryWatcher()
 
 	// For now we don't have the list of tokens lists remotely set so we're uisng the harcoded default lists. Once we have it
 	//we will just need to update the empty string with the correct URL.
@@ -165,6 +172,35 @@ func (tm *Manager) startAccountsWatcher() {
 	}()
 }
 
+func (tm *Manager) startTokenDiscoveryWatcher() {
+	if tm.tokenPublisher == nil {
+		return
+	}
+
+	ch, unsubFn := pubsub.Subscribe[tokenevent.TokenDiscoveryRequestEvent](tm.tokenPublisher, 100)
+	go func() {
+		defer gocommon.LogOnPanic()
+		defer unsubFn()
+		for {
+			select {
+			case <-tm.stopCh:
+				return
+			case event, ok := <-ch:
+				if !ok {
+					return
+				}
+				tm.handleTokenDiscoveryRequest(context.Background(), event)
+			}
+		}
+	}()
+}
+
+func (tm *Manager) handleTokenDiscoveryRequest(ctx context.Context, event tokenevent.TokenDiscoveryRequestEvent) {
+	// Use existing FindOrCreateTokenByAddress logic
+	// This will fetch token metadata and send TokenListsUpdated signal to frontend
+	tm.FindOrCreateTokenByAddress(ctx, event.ChainID, event.Address)
+}
+
 func (tm *Manager) Stop() {
 	if tm.stopCh != nil {
 		close(tm.stopCh)
@@ -173,6 +209,10 @@ func (tm *Manager) Stop() {
 	tm.tokenLists.Stop()
 }
 
+func (tm *Manager) GetTokenPublisher() *pubsub.Publisher {
+	return tm.tokenPublisher
+}
+
 // overrideTokensInPlace overrides tokens in the store with the ones from the networks
 // BEWARE: overridden tokens will have their original address removed and replaced by the one in networks
 func overrideTokensInPlace(networks []params.Network, tokens []*tokenTypes.Token) {
@@ -298,6 +338,8 @@ func (tm *Manager) FindOrCreateTokenByAddress(ctx context.Context, chainID uint6
 	}
 
 	tm.discoverTokenCommunityID(ctx, token, address)
+	signal.SendWalletEvent(signal.TokenListsUpdated, nil)
+
 	return token
 }
 
@@ -437,7 +479,7 @@ func (tm *Manager) getNativeTokens() ([]*tokenTypes.Token, error) {
 }
 
 func (tm *Manager) GetAllTokens() ([]*tokenTypes.Token, error) {
-	allTokens, err := tm.GetCustoms(true)
+	allTokens, err := tm.GetCustoms(false)
 	if err != nil {
 		logutils.ZapLogger().Error("can't fetch custom tokens", zap.Error(err))
 	}

services/wallet/token/tokenevent/events.go

@@ -0,0 +1,12 @@
+package tokenevent
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+)
+
+// TokenDiscoveryRequestEvent is emitted when a component needs token metadata.
+// The TokenManager will asynchronously discover the token.
+type TokenDiscoveryRequestEvent struct {
+	ChainID uint64
+	Address common.Address
+}