feat(open_crypto_pay): support enabled Ethereum tokens

Add EIP-681 parsing and route Ethereum mainnet ERC-20 OCP payments through the existing token send flow, using enabled token contract addresses as the authority.

Author: reubenyap

lib/pages/open_crypto_pay/open_crypto_pay_confirm_view.dart

@@ -5,8 +5,12 @@ import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:tuple/tuple.dart';
 
+import '../../models/isar/models/ethereum/eth_contract.dart';
 import '../../models/send_view_auto_fill_data.dart';
 import '../../notifications/show_flush_bar.dart';
+import '../../providers/db/main_db_provider.dart';
+import '../../providers/providers.dart';
+import '../../services/open_crypto_pay/evm_uri.dart';
 import '../../services/open_crypto_pay/method_support.dart';
 import '../../services/open_crypto_pay/models.dart';
 import '../../services/open_crypto_pay/open_crypto_pay_api.dart';
@@ -15,12 +19,18 @@ import '../../utilities/address_utils.dart';
 import '../../utilities/logger.dart';
 import '../../utilities/text_styles.dart';
 import '../../wallets/crypto_currency/crypto_currency.dart';
+import '../../wallets/isar/providers/eth/current_token_wallet_provider.dart';
+import '../../wallets/isar/providers/wallet_info_provider.dart';
+import '../../wallets/wallet/impl/ethereum_wallet.dart';
+import '../../wallets/wallet/impl/sub_wallets/eth_token_wallet.dart';
+import '../../wallets/wallet/wallet.dart';
 import '../../widgets/background.dart';
 import '../../widgets/custom_buttons/app_bar_icon_button.dart';
 import '../../widgets/desktop/primary_button.dart';
 import '../../widgets/loading_indicator.dart';
 import '../../widgets/rounded_white_container.dart';
 import '../send_view/send_view.dart';
+import '../send_view/token_send_view.dart';
 
 enum OpenCryptoPayConfirmResult { quoteExpired }
 
@@ -102,6 +112,18 @@ class _OpenCryptoPayConfirmViewState
   /// attached to the address.
   ({String? address, Decimal? amount, int? chainId, String? scheme})
   _parseTransactionUri(String uri) {
+    final evmUri = OpenCryptoPayEvmUri.tryParse(uri);
+    if (evmUri != null && !evmUri.isTokenTransfer) {
+      return (
+        address: evmUri.targetAddress,
+        amount: evmUri.isNativeTransfer
+            ? evmUri.amount(fractionDigits: widget.coin.fractionDigits)
+            : Decimal.tryParse(widget.selectedAsset.amount),
+        chainId: evmUri.chainId,
+        scheme: evmUri.scheme,
+      );
+    }
+
     final parsedUri = Uri.tryParse(uri);
     final data = AddressUtils.parsePaymentUri(uri, logging: Logging.instance);
     var address = data?.address ?? parsedUri?.path;
@@ -125,6 +147,37 @@ class _OpenCryptoPayConfirmViewState
     );
   }
 
+  EthContract? _enabledErc20Token(String contractAddress) {
+    final normalized = contractAddress.toLowerCase();
+    final mainDB = ref.read(mainDBProvider);
+    for (final address in ref.read(pWalletTokenAddresses(widget.walletId))) {
+      final contract = mainDB.getEthContractSync(address);
+      if (contract == null || contract.type != EthContractType.erc20) {
+        continue;
+      }
+      if (contract.address.toLowerCase() == normalized) {
+        return contract;
+      }
+    }
+    return null;
+  }
+
+  Future<EthTokenWallet> _loadTokenWallet(EthContract contract) async {
+    final wallet = ref.read(pWallets).getWallet(widget.walletId);
+    if (wallet is! EthereumWallet) {
+      throw Exception("Ethereum wallet not loaded");
+    }
+
+    final old = ref.read(tokenServiceStateProvider);
+    final tokenWallet =
+        Wallet.loadTokenWallet(ethWallet: wallet, contract: contract)
+            as EthTokenWallet;
+    await tokenWallet.init();
+    unawaited(old?.exit());
+    ref.read(tokenServiceStateProvider.state).state = tokenWallet;
+    return tokenWallet;
+  }
+
   Future<void> _proceedToSend() async {
     if (_isExpired) {
       _warn("Quote expired, refreshing...");
@@ -140,32 +193,11 @@ class _OpenCryptoPayConfirmViewState
       return;
     }
 
-    final parsed = _parseTransactionUri(uri);
-    if (parsed.address == null) {
-      _warn("Could not parse payment address");
-      return;
-    }
-    if (parsed.amount == null) {
-      _warn("Could not parse payment amount");
-      return;
-    }
-    if (parsed.scheme != null &&
-        parsed.scheme!.isNotEmpty &&
-        parsed.scheme != widget.coin.uriScheme) {
-      _warn("Payment URI does not match this wallet");
-      return;
-    }
     if (_txDetails?.blockchain != null &&
         _txDetails!.blockchain != widget.selectedMethod.method) {
       _warn("Payment details do not match the selected method");
       return;
     }
-    if (widget.selectedMethod.method == 'Ethereum' &&
-        parsed.chainId != null &&
-        parsed.chainId != 1) {
-      _warn("Payment URI is for a different Ethereum network");
-      return;
-    }
 
     final submissionFlow = OpenCryptoPayMethodSupport.submissionFlowFor(
       widget.selectedMethod.method,
@@ -187,6 +219,63 @@ class _OpenCryptoPayConfirmViewState
         widget.paymentDetails.displayName ??
         "OpenCryptoPay";
 
+    final evmUri = widget.selectedMethod.method == 'Ethereum'
+        ? OpenCryptoPayEvmUri.tryParse(uri)
+        : null;
+    if (widget.selectedMethod.method == 'Ethereum') {
+      if (evmUri == null) {
+        _warn("Could not parse Ethereum payment details");
+        return;
+      }
+      if (evmUri.chainId != null && evmUri.chainId != 1) {
+        _warn("Payment URI is for a different Ethereum network");
+        return;
+      }
+      if (evmUri.functionName != null && !evmUri.isTokenTransfer) {
+        _warn("Unsupported Ethereum payment request");
+        return;
+      }
+      if (evmUri.isTokenTransfer) {
+        if (evmUri.chainId != 1) {
+          _warn("Payment URI is for a different Ethereum network");
+          return;
+        }
+        if (widget.selectedAsset.asset.toUpperCase() ==
+            widget.coin.ticker.toUpperCase()) {
+          _warn("Payment token details are invalid");
+          return;
+        }
+        await _proceedToTokenSend(
+          evmUri: evmUri,
+          expiresAt: expiresAt,
+          recipient: recipient,
+          submissionFlow: submissionFlow,
+        );
+        return;
+      }
+      if (widget.selectedAsset.asset.toUpperCase() !=
+          widget.coin.ticker.toUpperCase()) {
+        _warn("Payment token details are invalid");
+        return;
+      }
+    }
+
+    final parsed = _parseTransactionUri(uri);
+    if (parsed.address == null) {
+      _warn("Could not parse payment address");
+      return;
+    }
+    if (parsed.amount == null) {
+      _warn("Could not parse payment amount");
+      return;
+    }
+    if (parsed.scheme != null &&
+        parsed.scheme!.isNotEmpty &&
+        parsed.scheme != widget.coin.uriScheme) {
+      _warn("Payment URI does not match this wallet");
+      return;
+    }
+
     if (!mounted) return;
     await Navigator.of(context).pushNamed(
       SendView.routeName,
@@ -214,6 +303,65 @@ class _OpenCryptoPayConfirmViewState
     );
   }
 
+  Future<void> _proceedToTokenSend({
+    required OpenCryptoPayEvmUri evmUri,
+    required DateTime expiresAt,
+    required String recipient,
+    required OpenCryptoPaySubmissionFlow submissionFlow,
+  }) async {
+    final contract = _enabledErc20Token(evmUri.targetAddress);
+    if (contract == null) {
+      _warn("This token is not enabled in this wallet");
+      return;
+    }
+    if (contract.symbol.toUpperCase() !=
+        widget.selectedAsset.asset.toUpperCase()) {
+      _warn("Payment token does not match the selected asset");
+      return;
+    }
+
+    try {
+      await _loadTokenWallet(contract);
+    } catch (e, s) {
+      Logging.instance.e(
+        "OpenCryptoPay token wallet load failed",
+        error: e,
+        stackTrace: s,
+      );
+      _warn("Could not load token wallet");
+      return;
+    }
+
+    final amount = evmUri.amount(fractionDigits: contract.decimals);
+    if (!mounted) return;
+    await Navigator.of(context).pushNamed(
+      TokenSendView.routeName,
+      arguments: Tuple4(
+        widget.walletId,
+        widget.coin,
+        contract,
+        SendViewAutoFillData(
+          address: evmUri.recipientAddress!,
+          contactLabel: recipient,
+          amount: amount,
+          note: "OpenCryptoPay: $recipient",
+          openCryptoPayCommit: OpenCryptoPayCommit(
+            callbackUrl: widget.paymentDetails.callback,
+            quoteId: widget.paymentDetails.quote!.id,
+            method: widget.selectedMethod.method,
+            asset: widget.selectedAsset.asset,
+            expiresAt: expiresAt,
+            submissionFlow: submissionFlow,
+            minFee: widget.selectedMethod.minFee,
+            recipientAddress: evmUri.recipientAddress!,
+            amount: amount,
+            tokenContractAddress: contract.address,
+          ),
+        ),
+      ),
+    );
+  }
+
   void _warn(String message) {
     unawaited(
       showFloatingFlushBar(

lib/pages/open_crypto_pay/open_crypto_pay_view.dart

@@ -3,14 +3,17 @@ import 'dart:async';
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 
+import '../../models/isar/models/ethereum/eth_contract.dart';
 import '../../notifications/show_flush_bar.dart';
+import '../../providers/db/main_db_provider.dart';
 import '../../services/open_crypto_pay/method_support.dart';
 import '../../services/open_crypto_pay/models.dart';
 import '../../services/open_crypto_pay/open_crypto_pay_api.dart';
 import '../../themes/stack_colors.dart';
 import '../../utilities/logger.dart';
 import '../../utilities/text_styles.dart';
 import '../../wallets/crypto_currency/crypto_currency.dart';
+import '../../wallets/isar/providers/wallet_info_provider.dart';
 import '../../widgets/background.dart';
 import '../../widgets/custom_buttons/app_bar_icon_button.dart';
 import '../../widgets/desktop/primary_button.dart';
@@ -75,11 +78,26 @@ class _OpenCryptoPayViewState extends ConsumerState<OpenCryptoPayView> {
   bool _isSupportedOption(
     OpenCryptoPayTransferMethod method,
     OpenCryptoPayAsset asset,
-  ) => OpenCryptoPayMethodSupport.isSupportedWalletOption(
-    coin: widget.coin,
-    method: method,
-    asset: asset,
-  );
+    Iterable<EthContract> enabledErc20Tokens,
+  ) {
+    return OpenCryptoPayMethodSupport.isSupportedWalletOption(
+      coin: widget.coin,
+      method: method,
+      asset: asset,
+      enabledErc20Symbols: enabledErc20Tokens.map((e) => e.symbol),
+    );
+  }
+
+  List<EthContract> _enabledErc20Tokens() {
+    if (widget.coin is! Ethereum) return const [];
+    final mainDB = ref.watch(mainDBProvider);
+    return ref
+        .watch(pWalletTokenAddresses(widget.walletId))
+        .map(mainDB.getEthContractSync)
+        .whereType<EthContract>()
+        .where((e) => e.type == EthContractType.erc20)
+        .toList();
+  }
 
   Future<void> _onSelected(
     OpenCryptoPayTransferMethod method,
@@ -164,11 +182,14 @@ class _OpenCryptoPayViewState extends ConsumerState<OpenCryptoPayView> {
       return const Center(child: Text("No payment data"));
     }
 
+    final enabledErc20Tokens = _enabledErc20Tokens();
+
     // Flatten into (method, asset) pairs that this wallet can safely settle.
     final options = [
       for (final m in details.availableMethods)
         for (final a in m.assets)
-          if (_isSupportedOption(m, a)) (method: m, asset: a),
+          if (_isSupportedOption(m, a, enabledErc20Tokens))
+            (method: m, asset: a),
     ];
 
     return SingleChildScrollView(

lib/pages/send_view/confirm_transaction_view.dart

@@ -54,6 +54,7 @@ import '../../wallets/wallet/impl/ethereum_wallet.dart';
 import '../../wallets/wallet/impl/firo_wallet.dart';
 import '../../wallets/wallet/impl/mimblewimblecoin_wallet.dart';
 import '../../wallets/wallet/impl/solana_wallet.dart';
+import '../../wallets/wallet/impl/sub_wallets/eth_token_wallet.dart';
 import '../../wallets/wallet/wallet_mixin_interfaces/ordinals_interface.dart';
 import '../../wallets/wallet/wallet_mixin_interfaces/paynym_interface.dart';
 import '../../wallets/wallet/wallet.dart';
@@ -472,8 +473,11 @@ class _ConfirmTransactionViewState
     try {
       if (openCryptoPayCommit?.submissionFlow ==
           OpenCryptoPaySubmissionFlow.rawHexToProvider) {
+        final submitWallet = widget.isTokenTx
+            ? ref.read(pCurrentTokenWallet)!
+            : wallet;
         txDataFuture = _submitOpenCryptoPayRawHex(
-          wallet,
+          submitWallet,
           widget.txData,
           openCryptoPayCommit!,
         );
@@ -904,6 +908,9 @@ class _ConfirmTransactionViewState
     );
     if (transactionError != null) return transactionError;
 
+    final tokenError = _validateOpenCryptoPayToken(commit);
+    if (tokenError != null) return tokenError;
+
     switch (commit.submissionFlow) {
       case OpenCryptoPaySubmissionFlow.txIdAfterLocalBroadcast:
         return null;
@@ -950,6 +957,32 @@ class _ConfirmTransactionViewState
     return null;
   }
 
+  String? _validateOpenCryptoPayToken(OpenCryptoPayCommit commit) {
+    final tokenContractAddress = commit.tokenContractAddress;
+    if (tokenContractAddress == null) return null;
+
+    if (!widget.isTokenTx || commit.method != 'Ethereum') {
+      return "Open CryptoPay token payment is not supported here";
+    }
+
+    final tokenWallet = ref.read(pCurrentTokenWallet);
+    if (tokenWallet == null) {
+      return "Could not verify Open CryptoPay token wallet";
+    }
+
+    if (tokenWallet.tokenContract.address.toLowerCase() !=
+        tokenContractAddress.toLowerCase()) {
+      return "Open CryptoPay token contract changed. Please scan again.";
+    }
+
+    if (tokenWallet.tokenContract.symbol.toUpperCase() !=
+        commit.asset.toUpperCase()) {
+      return "Open CryptoPay token asset changed. Please scan again.";
+    }
+
+    return null;
+  }
+
   String? _validateOpenCryptoPayMinFee(
     Wallet wallet,
     OpenCryptoPayCommit commit,
@@ -1113,6 +1146,9 @@ class _ConfirmTransactionViewState
     Wallet wallet,
     TxData txData,
   ) async {
+    if (wallet is EthTokenWallet) {
+      return await wallet.signSendWithoutBroadcast(txData: txData);
+    }
     if (wallet is EthereumWallet) {
       return await wallet.signSendWithoutBroadcast(txData: txData);
     }