fix: anypay (#3507)

* fix android CI

* fix: handle the parser seeing chainless QRs in the old flow as belonging to the current wallet, causing the error jack reported

* fix: handle network switch when anypay is interrupted mid flow and currency is changed

test/utils/anypay_matrix_test.dart

@@ -0,0 +1,344 @@
+import "package:cake_wallet/core/universal_address_detector.dart";
+import "package:cake_wallet/utils/payment_request.dart";
+import "package:cw_core/erc20_token.dart";
+import "package:cw_core/payment_uris.dart";
+import "package:cw_core/wallet_type.dart";
+import "package:flutter_test/flutter_test.dart";
+
+void main() {
+  const recipient = "0xCfc1650da7C961FD82998e7e30ca5f699D0aBf41";
+  const usdtEthContract = "0xdAC17F958D2ee523a2206206994597C13D831ec7";
+  const daiEthContract = "0x6B175474E89094C44Da98b954EedeAC495271d0F";
+  const usdtBaseContract = "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2";
+
+  final usdt = Erc20Token(
+    name: "Tether",
+    symbol: "USDT",
+    contractAddress: usdtEthContract,
+    decimal: 6,
+  );
+  final dai = Erc20Token(
+    name: "Dai",
+    symbol: "DAI",
+    contractAddress: daiEthContract,
+    decimal: 18,
+  );
+
+  group("cross generation QR matrix", () {
+    test("new app mainnet USDT QR parses with explicit chain and amount", () {
+      final uri = ERC681URI(
+        chainId: 1,
+        address: recipient,
+        amount: "200.172148",
+        contractAddress: usdtEthContract,
+        tokenDecimals: 6,
+      ).toString();
+
+      final request = PaymentRequest.fromUri(Uri.parse(uri));
+      expect(request.chainId, 1);
+      expect(request.contractAddress, usdtEthContract);
+      expect(request.resolveTokenAmount(usdt), "200.172148");
+    });
+
+    test("new app mainnet DAI QR emits both params and the amount wins", () {
+      final uri = ERC681URI(
+        chainId: 1,
+        address: recipient,
+        amount: "1.5",
+        contractAddress: daiEthContract,
+      ).toString();
+
+      expect(uri.contains("uint256=1500000000000000000"), true);
+      expect(uri.contains("amount=1.5"), true);
+
+      final request = PaymentRequest.fromUri(Uri.parse(uri));
+      expect(request.chainId, 1);
+      expect(request.resolveTokenAmount(dai), "1.5");
+    });
+
+    test("old app chainless USDT QR resolves through the legacy fallback", () {
+      final request = PaymentRequest.fromUri(
+        Uri.parse(
+          "ethereum:$usdtEthContract/transfer?address=$recipient&uint256=2000000000000000000",
+        ),
+      );
+
+      expect(request.chainId, null);
+      expect(request.resolveTokenAmount(usdt), "2");
+    });
+
+    test("team lead legacy URI resolves to the intended two USDT", () {
+      final request = PaymentRequest.fromUri(
+        Uri.parse(
+          "ethereum:$usdtEthContract@1/transfer?address=$recipient&uint256=2013999999999999744",
+        ),
+      );
+
+      expect(request.chainId, 1);
+      expect(request.resolveTokenAmount(usdt), "2.013999999999999744");
+    });
+
+    test("external QR with a true six decimal uint256 resolves directly", () {
+      final request = PaymentRequest.fromUri(
+        Uri.parse("ethereum:$usdtEthContract@1/transfer?address=$recipient&uint256=1000000"),
+      );
+
+      expect(request.resolveTokenAmount(usdt), "1");
+    });
+
+    test("old app native scientific value parses without a chain", () {
+      final request = PaymentRequest.fromUri(Uri.parse("ethereum:$recipient?value=2.014e18"));
+
+      expect(request.chainId, null);
+      expect(request.amount, "2.014");
+    });
+
+    test("new app native QR round trips with the explicit chain", () {
+      final uri = ERC681URI(chainId: 1, address: recipient, amount: "2.5", contractAddress: null)
+          .toString();
+      expect(uri, "ethereum:$recipient@1?value=2.5e18");
+
+      final request = PaymentRequest.fromUri(Uri.parse(uri));
+      expect(request.chainId, 1);
+      expect(request.amount, "2.5");
+    });
+
+    test("new app base token QR carries the base chain", () {
+      final uri = ERC681URI(
+        chainId: 8453,
+        address: recipient,
+        amount: "3",
+        contractAddress: usdtBaseContract,
+        tokenDecimals: 6,
+      ).toString();
+
+      final request = PaymentRequest.fromUri(Uri.parse(uri));
+      expect(request.chainId, 8453);
+      expect(request.contractAddress, usdtBaseContract);
+      expect(request.amount, "3");
+    });
+  });
+
+  group("emitter invariants", () {
+    test("every emitted ethereum URI names its chain", () {
+      final uris = [
+        ERC681URI(chainId: 1, address: recipient, amount: "", contractAddress: null),
+        ERC681URI(chainId: 1, address: recipient, amount: "1", contractAddress: null),
+        ERC681URI(
+          chainId: 1,
+          address: recipient,
+          amount: "1",
+          contractAddress: usdtEthContract,
+          tokenDecimals: 6,
+        ),
+        ERC681URI(chainId: 8453, address: recipient, amount: "", contractAddress: usdtBaseContract),
+      ];
+
+      for (final uri in uris) {
+        expect(uri.toString().contains("@"), true, reason: uri.toString());
+      }
+    });
+
+    test("six decimal tokens emit no uint256", () {
+      final uri = ERC681URI(
+        chainId: 1,
+        address: recipient,
+        amount: "1.5",
+        contractAddress: usdtEthContract,
+        tokenDecimals: 6,
+      ).toString();
+
+      expect(uri.contains("uint256"), false);
+      expect(uri.contains("amount=1.5"), true);
+    });
+
+    test("a stored raw amount is passed through verbatim", () {
+      final uri = ERC681URI(
+        chainId: 1,
+        address: recipient,
+        amount: "",
+        contractAddress: usdtEthContract,
+        tokenDecimals: 6,
+        rawTokenAmount: "1000000",
+      ).toString();
+
+      expect(uri, "ethereum:$usdtEthContract@1/transfer?address=$recipient&uint256=1000000");
+    });
+
+    test("comma decimal separators are normalized", () {
+      final uri = ERC681URI(
+        chainId: 1,
+        address: recipient,
+        amount: "2,5",
+        contractAddress: usdtEthContract,
+        tokenDecimals: 6,
+      ).toString();
+
+      expect(uri.contains("amount=2.5"), true);
+    });
+  });
+
+  group("hostile and external input", () {
+    test("EIP681 pay- prefix parses for native transfers", () {
+      final request = PaymentRequest.fromUri(Uri.parse("ethereum:pay-$recipient@1?value=1e18"));
+
+      expect(request.address, recipient);
+      expect(request.chainId, 1);
+      expect(request.amount, "1");
+    });
+
+    test("EIP681 pay- prefix parses for token transfers", () {
+      final request = PaymentRequest.fromUri(
+        Uri.parse("ethereum:pay-$usdtEthContract@1/transfer?address=$recipient&uint256=1000000"),
+      );
+
+      expect(request.contractAddress, usdtEthContract);
+      expect(request.address, recipient);
+      expect(request.resolveTokenAmount(usdt), "1");
+    });
+
+    test("a trailing chain separator defaults to mainnet", () {
+      final request = PaymentRequest.fromUri(Uri.parse("ethereum:$recipient@?value=1e18"));
+
+      expect(request.address, recipient);
+      expect(request.chainId, 1);
+    });
+
+    test("a non numeric chain id defaults to mainnet", () {
+      final request = PaymentRequest.fromUri(Uri.parse("ethereum:$recipient@abc"));
+
+      expect(request.address, recipient);
+      expect(request.chainId, 1);
+    });
+
+    test("an ENS style target degrades to the raw name without throwing", () {
+      final request = PaymentRequest.fromUri(Uri.parse("ethereum:vitalik.eth?amount=1"));
+
+      expect(request.address, "vitalik.eth");
+      expect(request.amount, "1");
+    });
+
+    test("junk after the scheme does not throw", () {
+      final request = PaymentRequest.fromUri(Uri.parse("ethereum:junk"));
+
+      expect(request.address, "junk");
+    });
+
+    test("an empty ethereum URI does not throw", () {
+      final request = PaymentRequest.fromUri(Uri.parse("ethereum:"));
+
+      expect(request.address, "");
+    });
+
+    test("a non numeric native value yields no amount", () {
+      final request = PaymentRequest.fromUri(Uri.parse("ethereum:$recipient?value=abc"));
+
+      expect(request.address, recipient);
+      expect(request.amount, "");
+    });
+
+    test("an unknown contract function still extracts the contract", () {
+      final request = PaymentRequest.fromUri(
+        Uri.parse("ethereum:$usdtEthContract@1/approve?address=$recipient"),
+      );
+
+      expect(request.contractAddress, usdtEthContract);
+      expect(request.address, recipient);
+    });
+
+    test("plain text input falls back to an address passthrough", () {
+      final request = PaymentRequest.fromString("definitelynotauri");
+
+      expect(request.address, "definitelynotauri");
+      expect(request.scheme, "");
+    });
+  });
+
+  group("resolveTokenAmount boundaries", () {
+    test("one billion whole tokens is still read with the token decimals", () {
+      final request =
+          PaymentRequest("addr", "", "", "ethereum", null, rawTokenAmount: "1000000000000000");
+
+      expect(request.resolveTokenAmount(usdt), "1000000000");
+    });
+
+    test("just past the plausibility bound flips to the legacy reading", () {
+      final request =
+          PaymentRequest("addr", "", "", "ethereum", null, rawTokenAmount: "1000000000000001");
+
+      expect(request.resolveTokenAmount(usdt), "0.001000000000000001");
+    });
+
+    test("eighteen decimal tokens never take the legacy branch", () {
+      final request =
+          PaymentRequest("addr", "", "", "ethereum", null, rawTokenAmount: "50000000000000000000");
+
+      expect(request.resolveTokenAmount(dai), "50");
+    });
+
+    test("garbage raw amounts resolve to null", () {
+      final request =
+          PaymentRequest("addr", "", "", "ethereum", null, rawTokenAmount: "not a number");
+
+      expect(request.resolveTokenAmount(usdt), null);
+    });
+  });
+
+  group("send page reconstruction round trip", () {
+    test("an explicit chain request rebuilds into the same payment", () {
+      final original = PaymentRequest.fromUri(
+        Uri.parse("ethereum:$usdtBaseContract@8453/transfer?address=$recipient&uint256=3000000"),
+      );
+
+      final rebuilt = ERC681URI(
+        address: original.address,
+        amount: original.amount,
+        contractAddress: original.contractAddress,
+        chainId: original.chainId ?? 1,
+        rawTokenAmount: original.rawTokenAmount,
+      ).toString();
+
+      final reparsed = PaymentRequest.fromUri(Uri.parse(rebuilt));
+      expect(reparsed.chainId, 8453);
+      expect(reparsed.contractAddress, usdtBaseContract);
+      expect(reparsed.rawTokenAmount, "3000000");
+      expect(reparsed.address, recipient);
+    });
+
+    test("a dual param request survives reconstruction with the raw intact", () {
+      final original = PaymentRequest.fromUri(
+        Uri.parse(
+          "ethereum:$daiEthContract@1/transfer?address=$recipient&uint256=1500000000000000000&amount=1.5",
+        ),
+      );
+
+      final rebuilt = ERC681URI(
+        address: original.address,
+        amount: original.amount,
+        contractAddress: original.contractAddress,
+        chainId: original.chainId ?? 1,
+        rawTokenAmount: original.rawTokenAmount,
+      ).toString();
+
+      final reparsed = PaymentRequest.fromUri(Uri.parse(rebuilt));
+      expect(reparsed.amount, "1.5");
+      expect(reparsed.rawTokenAmount, "1500000000000000000");
+    });
+  });
+
+  group("detector supplements", () {
+    test("pay- prefixed URIs are detected as EVM payments", () {
+      final result = UniversalAddressDetector.detectAddress("ethereum:pay-$recipient@1?value=1e18");
+
+      expect(result.isValid, true);
+      expect(result.detectedWalletType, WalletType.ethereum);
+    });
+
+    test("an unsupported chain id is still surfaced for routing", () {
+      final result = UniversalAddressDetector.detectAddress("ethereum:$recipient@10?value=1e18");
+
+      expect(result.isValid, true);
+      expect(result.chainId, 10);
+    });
+  });
+}

test/utils/payment_request_test.dart

@@ -7,7 +7,8 @@ void main() {
     group("Ethereum URIs", () {
       test("extract address and raw token amount from EIP681 Uri with contract", () {
         final uri = Uri.parse(
-            "ethereum:0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174@1/transfer?address=0xCfc1650da7C961FD82998e7e30ca5f699D0aBf41&uint256=2000000000000000000");
+          "ethereum:0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174@1/transfer?address=0xCfc1650da7C961FD82998e7e30ca5f699D0aBf41&uint256=2000000000000000000",
+        );
         final paymentRequest = PaymentRequest.fromUri(uri);
 
         expect(paymentRequest.address, "0xCfc1650da7C961FD82998e7e30ca5f699D0aBf41");
@@ -17,7 +18,8 @@ void main() {
 
       test("extract address and amount from EIP681 Uri", () {
         final uri = Uri.parse(
-            "ethereum:0xCfc1650da7C961FD82998e7e30ca5f699D0aBf41@1?value=2000000000000000000");
+          "ethereum:0xCfc1650da7C961FD82998e7e30ca5f699D0aBf41@1?value=2000000000000000000",
+        );
         final paymentRequest = PaymentRequest.fromUri(uri);
 
         expect(paymentRequest.address, "0xCfc1650da7C961FD82998e7e30ca5f699D0aBf41");
@@ -34,7 +36,8 @@ void main() {
 
       test("extract address from EIP681 Uri with contract", () {
         final uri = Uri.parse(
-            "ethereum:0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174@1/transfer?address=0xCfc1650da7C961FD82998e7e30ca5f699D0aBf41");
+          "ethereum:0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174@1/transfer?address=0xCfc1650da7C961FD82998e7e30ca5f699D0aBf41",
+        );
         final paymentRequest = PaymentRequest.fromUri(uri);
 
         expect(paymentRequest.address, "0xCfc1650da7C961FD82998e7e30ca5f699D0aBf41");
@@ -43,7 +46,8 @@ void main() {
 
       test("extract address and raw token amount from EIP681 Uri with contract and no chainId", () {
         final uri = Uri.parse(
-            "ethereum:0x1234567890abcdef1234567890abcdef12345678/transfer?address=0xabcdef1234567890abcdef1234567890abcdef12&uint256=1000000000000000000");
+          "ethereum:0x1234567890abcdef1234567890abcdef12345678/transfer?address=0xabcdef1234567890abcdef1234567890abcdef12&uint256=1000000000000000000",
+        );
         final paymentRequest = PaymentRequest.fromUri(uri);
 
         expect(paymentRequest.address, "0xabcdef1234567890abcdef1234567890abcdef12");
@@ -76,7 +80,8 @@ void main() {
 
       test("converts the raw uint256 using the token decimals", () {
         final uri = Uri.parse(
-            "ethereum:0xdAC17F958D2ee523a2206206994597C13D831ec7@1/transfer?address=0xCfc1650da7C961FD82998e7e30ca5f699D0aBf41&uint256=1000000");
+          "ethereum:0xdAC17F958D2ee523a2206206994597C13D831ec7@1/transfer?address=0xCfc1650da7C961FD82998e7e30ca5f699D0aBf41&uint256=1000000",
+        );
         final paymentRequest = PaymentRequest.fromUri(uri);
 
         expect(paymentRequest.resolveTokenAmount(usdt), "1");
@@ -90,8 +95,14 @@ void main() {
       });
 
       test("falls back to the legacy 18 decimal reading for implausibly large amounts", () {
-        final paymentRequest = PaymentRequest("addr", "", "", "ethereum", null,
-            rawTokenAmount: "50000000000000000000");
+        final paymentRequest = PaymentRequest(
+          "addr",
+          "",
+          "",
+          "ethereum",
+          null,
+          rawTokenAmount: "50000000000000000000",
+        );
 
         expect(paymentRequest.resolveTokenAmount(usdt), "50");
       });