feat(spl): auto-discover Solana tokens held by wallet

Author: sneurlax

lib/pages/add_wallet_views/add_token_view/edit_wallet_tokens_view.dart

@@ -27,8 +27,10 @@ import '../../../utilities/assets.dart';
 import '../../../utilities/constants.dart';
 import '../../../utilities/default_eth_tokens.dart';
 import '../../../utilities/default_sol_tokens.dart';
+import '../../../utilities/logger.dart';
 import '../../../utilities/text_styles.dart';
 import '../../../utilities/util.dart';
+import '../../../wallets/isar/providers/solana/discovered_sol_tokens_provider.dart';
 import '../../../wallets/isar/providers/wallet_info_provider.dart';
 import '../../../wallets/wallet/impl/ethereum_wallet.dart';
 import '../../../wallets/wallet/impl/solana_wallet.dart';
@@ -292,6 +294,73 @@ class _EditWalletTokensViewState extends ConsumerState<EditWalletTokensView> {
     }
 
     super.initState();
+
+    if (wallet is SolanaWallet) {
+      unawaited(_loadDiscoveredTokens(wallet));
+    }
+  }
+
+  /// Discover the SPL tokens held by [wallet] and merge them into the list.
+  ///
+  /// Tokens already present (e.g. defaults) are marked as selected, while
+  /// newly discovered tokens are added to the top of the list and selected.
+  Future<void> _loadDiscoveredTokens(SolanaWallet wallet) async {
+    try {
+      final address = await wallet.getCurrentReceivingAddress();
+      if (address == null) {
+        return;
+      }
+
+      final discovered = await ref.read(
+        pDiscoveredSolanaTokens((
+          walletId: widget.walletId,
+          walletAddress: address.value,
+        )).future,
+      );
+
+      if (discovered.isEmpty) {
+        return;
+      }
+
+      final newContracts = discovered
+          .where(
+            (token) =>
+                tokenEntities.every((e) => e.token.address != token.address),
+          )
+          .toList();
+
+      if (newContracts.isNotEmpty) {
+        await MainDB.instance.putSolContracts(newContracts);
+      }
+
+      if (!mounted) {
+        return;
+      }
+
+      setState(() {
+        var insertIndex = 0;
+        for (final token in discovered) {
+          final existing = tokenEntities
+              .where((e) => e.token.address == token.address)
+              .toList();
+          if (existing.isNotEmpty) {
+            existing.first.selected = true;
+          } else {
+            tokenEntities.insert(
+              insertIndex,
+              AddTokenListElementData(token)..selected = true,
+            );
+            insertIndex++;
+          }
+        }
+      });
+    } catch (e, s) {
+      Logging.instance.w(
+        "Failed to load discovered Solana tokens for ${widget.walletId}",
+        error: e,
+        stackTrace: s,
+      );
+    }
   }
 
   @override

lib/services/solana/solana_token_api.dart

@@ -10,6 +10,16 @@
 import 'package:solana/dto.dart';
 import 'package:solana/solana.dart';
 
+import '../../utilities/default_sol_tokens.dart';
+
+/// A token mint discovered in a wallet, with its decimals when known.
+class DiscoveredSolMint {
+  final String mint;
+  final int? decimals;
+
+  const DiscoveredSolMint({this.mint = '', this.decimals});
+}
+
 /// Exception for Solana token API errors.
 class SolanaTokenApiException implements Exception {
   final String message;
@@ -338,19 +348,28 @@ class SolanaTokenAPI {
     try {
       _checkClient();
 
-      // TODO: Implement proper metadata PDA derivation when solana package
-      // exposes findProgramAddress() utilities.
-      //
-      // The Solana Token Metadata program (metaqbxxUerdq28cj1RbAqWwTRiWLs6nshmbbuP3xqb)
-      // stores token metadata at a PDA derived from the mint address using:
-      // findProgramAddress(
-      //   ["metadata", metadataProgram, mintPubkey],
-      //   metadataProgram
-      // )
-      //
-      // Until then, return null to allow users to enter custom token details.
+      // Resolve name/symbol/logo from the bundled known token list when the
+      // mint matches a well known token.
+      for (final token in DefaultSolTokens.list) {
+        if (token.address == mintAddress) {
+          return SolanaTokenApiResponse<Map<String, dynamic>?>(
+            value: {
+              "name": token.name,
+              "symbol": token.symbol,
+              "decimals": token.decimals,
+              "logoUri": token.logoUri,
+            },
+          );
+        }
+      }
 
-      // Metadata PDA derivation not yet implemented
+      // On-chain metadata lookup is not implemented here: it would require
+      // deriving the Token Metadata program PDA
+      // (metaqbxxUerdq28cj1RbAqWwTRiWLs6nshmbbuP3xqb) from the mint and
+      // decoding the Metaplex account, which the solana package does not yet
+      // expose helpers for. Returning null lets callers fall back to a
+      // mint-derived placeholder name/symbol while still using the correct
+      // on-chain decimals.
       return SolanaTokenApiResponse<Map<String, dynamic>?>(
         value: null,
       );
@@ -362,6 +381,187 @@ class SolanaTokenAPI {
     }
   }
 
+  /// Discover all SPL token mints held by a wallet.
+  ///
+  /// Queries the wallet's token accounts for both the standard SPL Token
+  /// program and the Token2022 program, then extracts the unique mint
+  /// addresses from those accounts along with the number of decimals each
+  /// mint is configured with. The decimals are read directly from the parsed
+  /// token account data ('tokenAmount.decimals'), which mirrors the value
+  /// stored on the mint account, so balances are scaled correctly.
+  Future<SolanaTokenApiResponse<List<DiscoveredSolMint>>>
+      discoverTokensForWallet({
+    required String walletAddress,
+  }) async {
+    try {
+      _checkClient();
+
+      const splTokenProgramId = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA';
+      const token2022ProgramId = 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb';
+
+      final splResponse = await _rpcClient!.getTokenAccountsByOwner(
+        walletAddress,
+        TokenAccountsFilter.byProgramId(splTokenProgramId),
+        encoding: Encoding.jsonParsed,
+      );
+
+      final token2022Response = await _rpcClient!.getTokenAccountsByOwner(
+        walletAddress,
+        TokenAccountsFilter.byProgramId(token2022ProgramId),
+        encoding: Encoding.jsonParsed,
+      );
+
+      final accounts = [
+        ...splResponse.value,
+        ...token2022Response.value,
+      ];
+
+      final byMint = <String, DiscoveredSolMint>{};
+      for (final account in accounts) {
+        final extracted =
+            _extractMintFromParsedTokenAccount(account.account.data);
+        final mint = extracted.mint;
+        if (mint.isEmpty) {
+          continue;
+        }
+
+        // Prefer an entry that already has decimals resolved.
+        final existing = byMint[mint];
+        if (existing == null || existing.decimals == null) {
+          byMint[mint] = extracted;
+        }
+      }
+
+      // For any mint whose decimals could not be read from the token account
+      // data, fetch the mint account directly and read its decimals.
+      final resolved = <DiscoveredSolMint>[];
+      for (final entry in byMint.values) {
+        if (entry.decimals != null) {
+          resolved.add(entry);
+        } else {
+          final decimals = await _fetchMintDecimals(entry.mint);
+          resolved.add(
+            DiscoveredSolMint(mint: entry.mint, decimals: decimals),
+          );
+        }
+      }
+
+      return SolanaTokenApiResponse<List<DiscoveredSolMint>>(value: resolved);
+    } on Exception catch (e) {
+      return SolanaTokenApiResponse<List<DiscoveredSolMint>>(
+        exception: SolanaTokenApiException(
+          'Failed to discover tokens: ${e.toString()}',
+          originalException: e,
+        ),
+      );
+    }
+  }
+
+  /// Fetch the number of decimals configured on a token's mint account.
+  ///
+  /// Used as a fallback when the decimals could not be read from a parsed
+  /// token account. Returns null if the mint account cannot be read or parsed.
+  Future<int?> _fetchMintDecimals(String mintAddress) async {
+    try {
+      final response = await _rpcClient!.getAccountInfo(
+        mintAddress,
+        encoding: Encoding.jsonParsed,
+      );
+
+      final data = response.value?.data;
+      if (data is ParsedAccountData) {
+        return data.when(
+          splToken: (spl) => spl.when(
+            account: (info, type, accountType) => null,
+            mint: (info, type, accountType) => info.decimals,
+            unknown: (type) => null,
+          ),
+          token2022: (token2022data) => token2022data.when(
+            account: (info, type, accountType) => null,
+            mint: (info, type, accountType) => info.decimals,
+            unknown: (type) => null,
+          ),
+          stake: (_) => null,
+          unsupported: (_) => null,
+        );
+      }
+
+      if (data is Map<String, dynamic>) {
+        final parsed = data['parsed'];
+        if (parsed is Map<String, dynamic>) {
+          final info = parsed['info'];
+          if (info is Map<String, dynamic>) {
+            final decimals = info['decimals'];
+            if (decimals is int) {
+              return decimals;
+            }
+            return int.tryParse(decimals?.toString() ?? '');
+          }
+        }
+      }
+    } catch (_) {
+      // Ignore and report unknown decimals.
+    }
+
+    return null;
+  }
+
+  /// Extract the mint address and decimals from a parsed token account's data.
+  ///
+  /// Handles both standard SPL Token and Token2022 account data. The decimals
+  /// come from 'tokenAmount.decimals' on the holding, which matches the value
+  /// stored on the mint account. Returns an empty mint when the data is not a
+  /// token account or cannot be parsed, and null decimals when unavailable.
+  DiscoveredSolMint _extractMintFromParsedTokenAccount(dynamic data) {
+    try {
+      if (data is ParsedAccountData) {
+        return data.when(
+          splToken: (spl) => spl.when(
+            account: (info, type, accountType) => DiscoveredSolMint(
+              mint: info.mint,
+              decimals: info.tokenAmount.decimals,
+            ),
+            mint: (info, type, accountType) => const DiscoveredSolMint(),
+            unknown: (type) => const DiscoveredSolMint(),
+          ),
+          token2022: (token2022data) => token2022data.when(
+            account: (info, type, accountType) => DiscoveredSolMint(
+              mint: info.mint,
+              decimals: info.tokenAmount.decimals,
+            ),
+            mint: (info, type, accountType) => const DiscoveredSolMint(),
+            unknown: (type) => const DiscoveredSolMint(),
+          ),
+          stake: (_) => const DiscoveredSolMint(),
+          unsupported: (_) => const DiscoveredSolMint(),
+        );
+      }
+
+      if (data is Map<String, dynamic>) {
+        final parsed = data['parsed'];
+        if (parsed is Map<String, dynamic>) {
+          final info = parsed['info'];
+          if (info is Map<String, dynamic>) {
+            final mint = info['mint'];
+            if (mint is String) {
+              int? decimals;
+              final tokenAmount = info['tokenAmount'];
+              if (tokenAmount is Map) {
+                final d = tokenAmount['decimals'];
+                decimals = d is int ? d : int.tryParse(d?.toString() ?? '');
+              }
+              return DiscoveredSolMint(mint: mint, decimals: decimals);
+            }
+          }
+        }
+      }
+    } catch (_) {
+      // Ignore parsing errors and treat as no mint found.
+    }
+
+    return const DiscoveredSolMint();
+  }
+
   /// Validate if a string is a valid Solana mint address.
   ///
   /// A valid Solana address must: