feat: Custom Token Import UI and BLoC

assets/translations/en.json

@@ -606,6 +606,13 @@
     "mmBotFirstTradePreview": "Preview of the first order",
     "mmBotFirstTradeEstimate": "First trade estimate",
     "mmBotFirstOrderVolume": "This is an estimate of the first order only. Following orders will be placed automatically using the configured volume of the available {} balance.",
+    "importCustomToken": "Import Custom Token",
+    "importTokenWarning": "Ensure the token is trustworthy before you import it.",
+    "importToken": "Import Token",
+    "selectNetwork": "Select Network",
+    "tokenContractAddress": "Token Contract Address",
+    "tokenNotFound": "Token is not found.",
+    "decimals": "Decimals",
     "onlySendToThisAddress": "Only send {} to this address",
     "scanTheQrCode": "Scan the QR code on any mobile device wallet",
     "swapAddress": "Swap Address",

lib/bloc/auth_bloc/auth_bloc.dart

@@ -6,6 +6,7 @@ import 'package:komodo_defi_sdk/komodo_defi_sdk.dart';
 import 'package:komodo_defi_types/komodo_defi_types.dart';
 import 'package:web_dex/blocs/wallets_repository.dart';
 import 'package:web_dex/model/authorize_mode.dart';
+import 'package:web_dex/model/kdf_auth_metadata_extension.dart';
 import 'package:web_dex/model/wallet.dart';
 import 'package:web_dex/shared/utils/utils.dart';
 

lib/bloc/cex_market_data/mockup/generate_demo_data.dart

@@ -141,18 +141,7 @@ class DemoDataGenerator {
       final totalAmount = transaction.balanceChanges.totalAmount;
 
       adjustedTransactions.add(
-        Transaction(
-          id: transaction.id,
-          timestamp: transaction.timestamp,
-          assetId: transaction.assetId,
-          blockHeight: transaction.blockHeight,
-          from: transaction.from,
-          internalId: transaction.internalId,
-          confirmations: transaction.confirmations,
-          to: transaction.to,
-          txHash: transaction.txHash,
-          fee: transaction.fee,
-          memo: transaction.memo,
+        transaction.copyWith(
           balanceChanges: BalanceChanges(
             netChange: netChange * adjustmentFactor,
             receivedByMe: received * adjustmentFactor,

lib/bloc/coins_bloc/asset_coin_extension.dart

@@ -12,24 +12,23 @@ extension AssetCoinExtension on Asset {
       contractAddress: '',
     );
 
-    final CoinType? type = _getCoinTypeFromProtocol(protocol);
-    if (type == null) {
-      throw ArgumentError.value(
-        protocol.subClass,
-        'protocol type',
-        'Unsupported protocol type',
-      );
-    }
-
+    final CoinType type = protocol.subClass.toCoinType();
     // temporary measure to get metadata, like `wallet_only`, that isn't exposed
     // by the SDK (and might be phased out completely later on)
+    // TODO: Remove this once the SDK exposes all the necessary metadata
     final config = protocol.config;
+    final logoImageUrl = config.valueOrNull<String>('logo_image_url');
+    final isCustomToken =
+        (config.valueOrNull<bool>('is_custom_token') ?? false) ||
+            logoImageUrl != null;
 
     return Coin(
       type: type,
       abbr: id.id,
       id: id,
       name: id.name,
+      logoImageUrl: logoImageUrl ?? '',
+      isCustomCoin: isCustomToken,
       explorerUrl: config.valueOrNull<String>('explorer_url') ?? '',
       explorerTxUrl: config.valueOrNull<String>('explorer_tx_url') ?? '',
       explorerAddressUrl:
@@ -49,13 +48,17 @@ extension AssetCoinExtension on Asset {
     );
   }
 
-  CoinType? _getCoinTypeFromProtocol(ProtocolClass protocol) {
-    switch (protocol.subClass) {
+  String? get contractAddress => protocol.config
+      .valueOrNull('protocol', 'protocol_data', 'contract_address');
+}
+
+extension CoinTypeExtension on CoinSubClass {
+  CoinType toCoinType() {
+    switch (this) {
       case CoinSubClass.ftm20:
         return CoinType.ftm20;
       case CoinSubClass.arbitrum:
         return CoinType.arb20;
-      // ignore: deprecated_member_use
       case CoinSubClass.slp:
         return CoinType.slp;
       case CoinSubClass.qrc20:
@@ -94,6 +97,29 @@ extension AssetCoinExtension on Asset {
         return CoinType.utxo;
     }
   }
+
+  bool isEvmProtocol() {
+    switch (this) {
+      case CoinSubClass.avx20:
+      case CoinSubClass.bep20:
+      case CoinSubClass.ftm20:
+      case CoinSubClass.matic:
+      case CoinSubClass.hrc20:
+      case CoinSubClass.arbitrum:
+      case CoinSubClass.moonriver:
+      case CoinSubClass.moonbeam:
+      case CoinSubClass.ethereumClassic:
+      case CoinSubClass.ubiq:
+      case CoinSubClass.krc20:
+      case CoinSubClass.ewt:
+      case CoinSubClass.hecoChain:
+      case CoinSubClass.rskSmartBitcoin:
+      case CoinSubClass.erc20:
+        return true;
+      default:
+        return false;
+    }
+  }
 }
 
 extension CoinSubClassExtension on CoinType {

lib/bloc/coins_bloc/coins_bloc.dart

@@ -11,6 +11,7 @@ import 'package:web_dex/blocs/trezor_coins_bloc.dart';
 import 'package:web_dex/mm2/mm2_api/mm2_api.dart';
 import 'package:web_dex/model/cex_price.dart';
 import 'package:web_dex/model/coin.dart';
+import 'package:web_dex/model/kdf_auth_metadata_extension.dart';
 import 'package:web_dex/model/wallet.dart';
 import 'package:web_dex/shared/utils/utils.dart';
 
@@ -265,24 +266,22 @@ class CoinsBloc extends Bloc<CoinsEvent, CoinsState> {
         changed = true;
         // Create new coin instance with updated price
         coins[entry.key] = coin.copyWith(usdPrice: usdPrice);
-
-        // Update wallet coins if exists
-        if (state.walletCoins.containsKey(coin.abbr)) {
-          emit(
-            state.copyWith(
-              walletCoins: {
-                ...state.walletCoins,
-                coin.abbr:
-                    state.walletCoins[entry.key]!.copyWith(usdPrice: usdPrice),
-              },
-            ),
-          );
-        }
       }
     }
 
     if (changed) {
-      emit(state.copyWith(coins: coins));
+      final newWalletCoins = state.walletCoins.map(
+        (String coinId, Coin coin) => MapEntry<String, Coin>(
+          coinId,
+          coin.copyWith(usdPrice: coins[coinId]!.usdPrice),
+        ),
+      );
+      emit(
+        state.copyWith(
+          coins: coins,
+          walletCoins: {...state.walletCoins, ...newWalletCoins},
+        ),
+      );
     }
 
     log('CEX prices updated', path: 'coins_bloc => updateCoinsCexPrices')
@@ -353,7 +352,12 @@ class CoinsBloc extends Bloc<CoinsEvent, CoinsState> {
     try {
       await _kdfSdk.addActivatedCoins(coins);
       await Future.wait(
-        coins.map((coin) => _currentWalletBloc.addCoin(state.coins[coin]!)),
+        coins.map((coin) async {
+          final sdkCoin = state.coins[coin] ?? _coinsRepo.getCoin(coin);
+          if (sdkCoin != null) {
+            await _currentWalletBloc.addCoin(sdkCoin);
+          }
+        }),
       );
     } catch (e, s) {
       log(
@@ -366,7 +370,12 @@ class CoinsBloc extends Bloc<CoinsEvent, CoinsState> {
       return [];
     }
 
-    final enableFutures = coins.map((coin) => _activateCoin(coin)).toList();
+    final enabledAssets = await _kdfSdk.assets.getEnabledCoins();
+    final coinsToActivate =
+        coins.where((coin) => !enabledAssets.contains(coin));
+
+    final enableFutures =
+        coinsToActivate.map((coin) => _activateCoin(coin)).toList();
     final results = <Coin>[];
     await for (final coin
         in Stream<Coin>.fromFutures(enableFutures).asBroadcastStream()) {
@@ -389,10 +398,13 @@ class CoinsBloc extends Bloc<CoinsEvent, CoinsState> {
     final activatingCoins = Map<String, Coin>.fromIterable(
       coins
           .map(
-            (coin) => state.coins[coin]?.copyWith(
-              state: CoinState.activating,
-              enabledType: _currentUserCache?.wallet.config.type,
-            ),
+            (coin) {
+              final sdkCoin = state.coins[coin] ?? _coinsRepo.getCoin(coin);
+              return sdkCoin?.copyWith(
+                state: CoinState.activating,
+                enabledType: _currentUserCache?.wallet.config.type,
+              );
+            },
           )
           .where((coin) => coin != null)
           .cast<Coin>(),
@@ -407,35 +419,50 @@ class CoinsBloc extends Bloc<CoinsEvent, CoinsState> {
   }
 
   Future<Coin> _activateCoin(String coinId) async {
-    Coin coin = state.coins[coinId]!;
-    final isLoggedIn = _currentUserCache != null;
-    if (!isLoggedIn || coin.isActive) {
-      return coin;
+    Coin? coin = state.coins[coinId] ?? _coinsRepo.getCoin(coinId);
+    if (coin == null) {
+      throw ArgumentError.value(coinId, 'coinId', 'Coin not found');
     }
 
-    switch (_currentUserCache?.wallet.config.type) {
-      case WalletType.iguana:
-      case WalletType.hdwallet:
-        coin = await _activateIguanaCoin(coin);
-      case WalletType.trezor:
-        final asset = _kdfSdk.assets.available[coin.id];
-        if (asset == null) {
-          log('Failed to find asset for coin: ${coin.id}', isError: true);
-          return coin.copyWith(state: CoinState.suspended);
-        }
-        final accounts = await _trezorBloc.activateCoin(asset);
-        final state =
-            accounts.isNotEmpty ? CoinState.active : CoinState.suspended;
-        coin = coin.copyWith(state: state, accounts: accounts);
-      case WalletType.metamask:
-      case WalletType.keplr:
-      case null:
-        break;
+    try {
+      final isLoggedIn = _currentUserCache != null;
+      if (!isLoggedIn || coin.isActive) {
+        return coin;
+      }
+
+      switch (_currentUserCache?.wallet.config.type) {
+        case WalletType.iguana:
+        case WalletType.hdwallet:
+          coin = await _activateIguanaCoin(coin);
+        case WalletType.trezor:
+          coin = await _activateTrezorCoin(coin, coinId);
+        case WalletType.metamask:
+        case WalletType.keplr:
+        case null:
+          break;
+      }
+    } catch (e, s) {
+      log(
+        'Error activating coin ${coin!.id.toString()}',
+        isError: true,
+        trace: s,
+      );
     }
 
     return coin;
   }
 
+  Future<Coin> _activateTrezorCoin(Coin coin, String coinId) async {
+    final asset = _kdfSdk.assets.available[coin.id];
+    if (asset == null) {
+      log('Failed to find asset for coin: ${coin.id}', isError: true);
+      return coin.copyWith(state: CoinState.suspended);
+    }
+    final accounts = await _trezorBloc.activateCoin(asset);
+    final state = accounts.isNotEmpty ? CoinState.active : CoinState.suspended;
+    return coin.copyWith(state: state, accounts: accounts);
+  }
+
   Future<Coin> _activateIguanaCoin(Coin coin) async {
     try {
       log('Enabling a ${coin.name}', path: 'coins_bloc => enable').ignore();
@@ -460,28 +487,38 @@ class CoinsBloc extends Bloc<CoinsEvent, CoinsState> {
       return List.empty();
     }
 
-    final List<String> coins = currentWallet.config.activatedCoins
-        .map((abbr) => state.coins[abbr])
-        .whereType<Coin>()
-        .map((coin) => coin.abbr)
-        .toList();
-
-    return _activateCoins(coins, emit);
+    return _activateCoins(currentWallet.config.activatedCoins, emit);
   }
 
   Stream<List<Coin>> _reActivateSuspended(
     Emitter<CoinsState> emit, {
     int attempts = 1,
   }) async* {
+    final List<String> coinsToBeActivated = [];
+
     for (int i = 0; i < attempts; i++) {
       final List<String> suspended = state.walletCoins.values
           .where((coin) => coin.isSuspended)
           .map((coin) => coin.abbr)
           .toList();
-      if (suspended.isEmpty) return;
 
-      yield await _activateCoins(suspended, emit);
+      coinsToBeActivated.addAll(suspended);
+      coinsToBeActivated.addAll(_getUnactivatedWalletCoins());
+
+      if (coinsToBeActivated.isEmpty) return;
+      yield await _activateCoins(coinsToBeActivated, emit);
+    }
+  }
+
+  List<String> _getUnactivatedWalletCoins() {
+    final Wallet? currentWallet = _currentUserCache?.wallet;
+    if (currentWallet == null) {
+      return List.empty();
     }
+
+    return currentWallet.config.activatedCoins
+        .where((coinId) => !state.walletCoins.containsKey(coinId))
+        .toList();
   }
 
   /// yields one coin at a time to provide visual feedback to the user as
@@ -507,10 +544,13 @@ class CoinsBloc extends Bloc<CoinsEvent, CoinsState> {
         yield coin.copyWith(state: CoinState.suspended);
       }
 
-      for (final Coin apiCoin in await _coinsRepo.getEnabledCoins()) {
-        if (!walletCoins.containsKey(apiCoin.abbr)) {
+      for (final String apiCoinId in await _kdfSdk.assets.getEnabledCoins()) {
+        if (!walletCoins.containsKey(apiCoinId)) {
           // enabled on api side, but not on gui side - enable on gui side
-          yield apiCoin;
+          final apiCoin = await _coinsRepo.getEnabledCoin(apiCoinId);
+          if (apiCoin != null) {
+            yield apiCoin;
+          }
         }
       }
     }