@ledgerhq/hw-app-eth 7.0.0-next.0 → 7.0.0-nightly.1

package/src/modules/Uniswap/index.ts

@@ -0,0 +1,168 @@
+import { log } from "@ledgerhq/logs";
+import { utils, Transaction } from "ethers";
+import { byContractAddressAndChainId, findERC20SignaturesInfo } from "../../services/ledger/erc20";
+import { LoadConfig } from "../../services/types";
+import { UniswapDecoders } from "./decoders";
+import { CommandsAndTokens } from "./types";
+import {
+  SWAP_COMMANDS,
+  UNISWAP_EXECUTE_SELECTOR,
+  UNISWAP_UNIVERSAL_ROUTER_ADDRESS,
+  UNISWAP_COMMANDS,
+} from "./constants";
+
+/**
+ * @ignore for external documentation
+ *
+ * Indicates if the given calldata is supported by the Uniswap plugin
+ * applying some basic checks and testing some assumptions
+ * specific to the Uniswap plugin internals
+ *
+ * @param {`0x${string}`} calldata
+ * @param {string | undefined} to
+ * @param {number} chainId
+ * @param {CommandsAndTokens} commandsAndTokens
+ * @returns {boolean}
+ */
+export const isSupported = (
+  calldata: `0x${string}`,
+  to: string | undefined,
+  chainId: number,
+  commandsAndTokens: CommandsAndTokens,
+): boolean => {
+  const selector = calldata.slice(0, 10);
+  const contractAddress = to?.toLowerCase();
+  if (
+    selector !== UNISWAP_EXECUTE_SELECTOR ||
+    contractAddress !== UNISWAP_UNIVERSAL_ROUTER_ADDRESS ||
+    !commandsAndTokens.length
+  ) {
+    return false;
+  }
+
+  let endingAsset;
+  for (let i = 0; i < commandsAndTokens.length; i++) {
+    const [command, tokens] = commandsAndTokens[i];
+
+    if (!command) return false;
+    if (!SWAP_COMMANDS.includes(command)) continue;
+
+    const poolVersion = command.slice(0, 2) as "V2" | "V3";
+    if (
+      endingAsset &&
+      // Chained swaps should work as a pipe regarding the traded assets:
+      // The last asset of swap 1 should be the first asset of swap 2
+      // and the same pool version should be used for both swaps
+      (endingAsset.asset !== tokens[0] || endingAsset.poolVersion !== poolVersion)
+    ) {
+      return false;
+    } else {
+      endingAsset = {
+        poolVersion,
+        asset: tokens[tokens.length - 1],
+      };
+    }
+  }
+
+  return true;
+};
+
+/**
+ * @ignore for external documentation
+ *
+ * Provides a list of commands and associated tokens for a given Uniswap calldata
+ *
+ * @param {`0x${string}`} calldata
+ * @param {number} chainId
+ * @returns {CommandsAndTokens}
+ */
+export const getCommandsAndTokensFromUniswapCalldata = (
+  calldata: `0x${string}`,
+  chainId: number,
+): CommandsAndTokens => {
+  try {
+    const [commands, inputs] = new utils.Interface([
+      "function execute(bytes calldata commands, bytes[] calldata inputs, uint256 deadline) external payable",
+    ]).decodeFunctionData("execute", calldata) as [`0x${string}`, `0x${string}`[]];
+
+    const commandsBuffer = Buffer.from(commands.slice(2), "hex");
+    return commandsBuffer.reduce((acc, curr, i) => {
+      const commandName = UNISWAP_COMMANDS[`0x${curr.toString(16).padStart(2, "0")}`];
+      if (!commandName) return [...acc, [undefined, []]];
+
+      const commandDecoder = UniswapDecoders[commandName];
+      return [...acc, [commandName, commandDecoder(inputs[i], chainId)]];
+    }, [] as CommandsAndTokens);
+  } catch (e) {
+    log("Uniswap", "Error decoding Uniswap calldata", e);
+    return [];
+  }
+};
+
+/**
+ * @ignore for external documentation
+ *
+ * Returns the necessary APDUs to load the Uniswap plugin
+ * and the token descriptors for a transaction
+ *
+ * @param {Transaction} transaction
+ * @param {number} chainId
+ * @param {LoadConfig} userConfig
+ * @returns {Promise<{ pluginData?: Buffer; tokenDescriptors?: Buffer[] }>}
+ */
+export const loadInfosForUniswap = async (
+  transaction: Transaction,
+  chainId: number,
+  userConfig?: LoadConfig,
+): Promise<{ pluginData?: Buffer; tokenDescriptors?: Buffer[] }> => {
+  const selector = transaction.data.slice(0, 10) as `0x${string}`;
+  const commandsAndTokens = getCommandsAndTokensFromUniswapCalldata(
+    transaction.data as `0x${string}`,
+    chainId,
+  );
+  if (!isSupported(selector, transaction.to, chainId, commandsAndTokens)) {
+    return {};
+  }
+
+  const tokenDescriptorsPromises = Promise.all(
+    commandsAndTokens.flatMap(([, tokens]) =>
+      tokens.map(async token => {
+        const erc20SignaturesBlob = await findERC20SignaturesInfo(userConfig || {}, chainId);
+        return byContractAddressAndChainId(token, chainId, erc20SignaturesBlob)?.data;
+      }),
+    ),
+  );
+  const tokenDescriptors = await tokenDescriptorsPromises.then(descriptors =>
+    descriptors.filter((descriptor): descriptor is Buffer => !!descriptor),
+  );
+
+  const pluginName = "Uniswap";
+  // 1 byte for the length of the plugin name
+  const lengthBuff = Buffer.alloc(1);
+  lengthBuff.writeUIntBE(pluginName.length, 0, 1);
+  // dynamic length bytes for the plugin name
+  const pluginNameBuff = Buffer.from(pluginName);
+  // 20 bytes for the contract address
+  const contractAddressBuff = Buffer.from(UNISWAP_UNIVERSAL_ROUTER_ADDRESS.slice(2), "hex");
+  // 4 bytes for the selector
+  const selectorBuff = Buffer.from(UNISWAP_EXECUTE_SELECTOR.slice(2), "hex");
+  // 70 bytes for the signature
+  const signature = Buffer.from(
+    // Signature is hardcoded as it would create issues by being in the CAL ethereum.json file
+    "3044022014391e8f355867a57fe88f6a5a4dbcb8bf8f888a9db3ff3449caf72d120396bd02200c13d9c3f79400fe0aa0434ac54d59b79503c9964a4abc3e8cd22763e0242935",
+    "hex",
+  );
+
+  const pluginData = Buffer.concat([
+    lengthBuff,
+    pluginNameBuff,
+    contractAddressBuff,
+    selectorBuff,
+    signature,
+  ]);
+
+  return {
+    pluginData,
+    tokenDescriptors,
+  };
+};

package/src/modules/Uniswap/types.ts

@@ -0,0 +1,14 @@
+export type UniswapSupportedCommand =
+  | "V2_SWAP_EXACT_IN"
+  | "V2_SWAP_EXACT_OUT"
+  | "V3_SWAP_EXACT_IN"
+  | "V3_SWAP_EXACT_OUT"
+  | "WRAP_ETH"
+  | "UNWRAP_ETH"
+  | "PERMIT2_PERMIT"
+  | "PERMIT2_TRANSFER_FROM"
+  | "PERMIT2_PERMIT_BATCH"
+  | "PERMIT2_TRANSFER_FROM_BATCH"
+  | "PAY_PORTION";
+
+export type CommandsAndTokens = [UniswapSupportedCommand | undefined, `0x${string}`[]][];

package/src/services/ledger/index.ts

@@ -1,20 +1,22 @@
-// This implements the resolution of a Transaction using Ledger's own API
+import { utils } from "ethers";
 import { log } from "@ledgerhq/logs";
-import { Interface } from "@ethersproject/abi";
 import {
   signDomainResolution,
   signAddressResolution,
 } from "@ledgerhq/domain-service/signers/index";
 import { LedgerEthTransactionResolution, LedgerEthTransactionService, LoadConfig } from "../types";
+import { decodeTxInfo, tokenSelectors, nftSelectors, mergeResolutions } from "../../utils";
+import { UNISWAP_UNIVERSAL_ROUTER_ADDRESS } from "../../modules/Uniswap/constants";
 import { byContractAddressAndChainId, findERC20SignaturesInfo } from "./erc20";
+import { loadInfosForUniswap } from "../../modules/Uniswap";
 import { loadInfosForContractMethod } from "./contracts";
 import { getNFTInfo, loadNftPlugin } from "./nfts";
-import { decodeTxInfo, tokenSelectors, nftSelectors, mergeResolutions } from "../../utils";
 
 type PotentialResolutions = {
   token: boolean | undefined;
   nft: boolean | undefined;
   externalPlugins: boolean | undefined;
+  uniswapV3: boolean | undefined;
 };
 
 /**
@@ -112,7 +114,9 @@ const loadNanoAppPlugins = async (
     }
   }
 
-  if (shouldResolve.externalPlugins) {
+  // Uniswap has its own way of working, so we need to handle it separately
+  // This will prevent an error if we add Uniswap to the CAL service
+  if (shouldResolve.externalPlugins && contractAddress !== UNISWAP_UNIVERSAL_ROUTER_ADDRESS) {
     const contractMethodInfos = await loadInfosForContractMethod(
       contractAddress,
       selector,
@@ -129,7 +133,7 @@ const loadNanoAppPlugins = async (
       }
 
       if (erc20OfInterest && erc20OfInterest.length && abi) {
-        const contract = new Interface(abi);
+        const contract = new utils.Interface(abi);
         const args = contract.parseTransaction(decodedTx).args;
 
         for (const path of erc20OfInterest) {
@@ -148,6 +152,7 @@ const loadNanoAppPlugins = async (
               nft: false,
               externalPlugins: false,
               token: true, // enforcing resolution of tokens for external plugins that need info on assets (e.g. for a swap)
+              uniswapV3: false,
             },
           );
           resolution = mergeResolutions([resolution, externalPluginResolution]);
@@ -158,6 +163,17 @@ const loadNanoAppPlugins = async (
     }
   }
 
+  if (shouldResolve.uniswapV3) {
+    const { pluginData, tokenDescriptors } = await loadInfosForUniswap(decodedTx, chainIdTruncated);
+    if (pluginData && tokenDescriptors) {
+      resolution.externalPlugin.push({
+        payload: pluginData.toString("hex"),
+        signature: "",
+      });
+      resolution.erc20Tokens.push(...tokenDescriptors.map(d => d.toString("hex")));
+    }
+  }
+
   return resolution;
 };
 
@@ -185,6 +201,7 @@ const resolveTransaction: LedgerEthTransactionService["resolveTransaction"] = as
       token: resolutionConfig.erc20 && tokenSelectors.includes(selector),
       nft: resolutionConfig.nft && nftSelectors.includes(selector),
       externalPlugins: resolutionConfig.externalPlugins,
+      uniswapV3: resolutionConfig.uniswapV3,
     };
 
     const pluginsResolution = await loadNanoAppPlugins(

package/src/services/types.ts

@@ -44,6 +44,8 @@ export type ResolutionConfig = {
   erc20?: boolean;
   // List of trusted names (ENS for now) to clear sign
   domains?: DomainDescriptor[];
+  // activate uniswap v3 plugin resolution
+  uniswapV3?: boolean;
 };
 
 export type LedgerEthTransactionService = {

package/src/utils.ts

@@ -72,7 +72,7 @@ export const decodeTxInfo = (rawTx: Buffer) => {
       data: rlpDecoded[5],
       to: rlpDecoded[3],
       // Default to 1 for non EIP 155 txs
-      chainId: rlpTx.length > 6 ? rlpTx[6] : Buffer.from("0x01", "hex"),
+      chainId: rlpTx.length > 6 ? rlpTx[6] : Buffer.from("01", "hex"),
     };
   }
 

package/tests/Eth.unit.test.ts

@@ -1,3 +1,4 @@
+import nock from "nock";
 import axios from "axios";
 import { fail } from "assert";
 import { ethers } from "ethers";
@@ -11,10 +12,11 @@ import ERC1155_ABI from "./fixtures/ABI/ERC1155.json";
 import PARASWAP_ABI from "./fixtures/ABI/PARASWAP.json";
 import { ResolutionConfig } from "../src/services/types";
 import ParaswapJSON from "./fixtures/REST/Paraswap-Plugin.json";
+import { transactionContracts, transactionData } from "./fixtures/utils";
 import { byContractAddressAndChainId } from "../src/services/ledger/erc20";
 import { ERC1155_CLEAR_SIGNED_SELECTORS, ERC721_CLEAR_SIGNED_SELECTORS } from "../src/utils";
 
-jest.mock("axios");
+nock.disableNetConnect();
 
 describe("Eth app biding", () => {
   describe("clearSignTransaction", () => {
@@ -293,7 +295,7 @@ describe("Eth app biding", () => {
         "44'/60'/0'/0/0",
         ethers.utils
           .serializeTransaction({
-            to: "0xdef171fe48cf0115b1d80b88dc8eab59176fee57",
+            to: transactionContracts.paraswap,
             value: ethers.BigNumber.from("0"),
             gasLimit: ethers.BigNumber.from("298891"),
             maxPriorityFeePerGas: ethers.BigNumber.from("1150000000"),
@@ -322,7 +324,7 @@ describe("Eth app biding", () => {
             type: 2,
           })
           .substring(2),
-        { erc20: true, externalPlugins: true, nft: true },
+        { erc20: true, externalPlugins: true, nft: true, uniswapV3: true },
         true,
       );
       expect(result).toEqual({
@@ -333,6 +335,66 @@ describe("Eth app biding", () => {
       expect(spy).toHaveBeenCalledTimes(3); // 1 time plugin json file + 2 times CAL signatures <-- FIXME 1 time should be enough
     });
 
+    it("should clear sign the Uniswap Universal Router transaction", async () => {
+      const spy = jest.spyOn(axios, "get");
+      spy.mockImplementation(async url => {
+        if (url?.includes("erc20-signatures")) {
+          return { data: CAL_ETH } as any;
+        }
+        return Promise.reject({ response: { status: 404 } }) as any;
+      });
+      const transport = await openTransportReplayer(
+        RecordStore.fromString(`
+        => e01200006607556e69737761703fc91a3afd70395cd496c647d5a6cc9d4b2b7fad3593564c3044022014391e8f355867a57fe88f6a5a4dbcb8bf8f888a9db3ff3449caf72d120396bd02200c13d9c3f79400fe0aa0434ac54d59b79503c9964a4abc3e8cd22763e0242935
+        <= 9000
+        => e00a0000680457455448c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000012000000013045022100b47ee8551c15a2cf681c649651e987d7e527c481d27c38da1f971a8242792bd3022069c3f688ac5493a23dab5798e3c9b07484765069e1d4be14321aae4d92cb8cbe
+        <= 009000
+        => e00a0000680457455448c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000012000000013045022100b47ee8551c15a2cf681c649651e987d7e527c481d27c38da1f971a8242792bd3022069c3f688ac5493a23dab5798e3c9b07484765069e1d4be14321aae4d92cb8cbe
+        <= 019000
+        => e004000096058000002c8000003c80000000000000000000000002f9044f018084448b9b8085143fc44a5883048f8b943fc91a3afd70395cd496c647d5a6cc9d4b2b7fad80b904243593564c000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000
+        <= 9000
+        => e00480009600000000000000000000000000669ba25a00000000000000000000000000000000000000000000000000000000000000030a010c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000600000000000
+        <= 9000
+        => e0048000960000000000000000000000000000000000000000000000000001e00000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000016000000000000000000000000055747be9f9f5beb232ad59fe7af013b81d95fd5e000000000000000000000000ffffffffffffffffffffffffffffff
+        <= 9000
+        => e004800096ffffffffff0000000000000000000000000000000000000000000000000000000066c32ea60000000000000000000000000000000000000000000000000000000000000006000000000000000000000000ef1c6e67703c7bd7107eed8303fbe6ec2554bf6b00000000000000000000000000000000000000000000000000000000669ba25a0000000000000000000000000000000000
+        <= 9000
+        => e0048000960000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000413cbf00ab90b6d1b17401cbf49e00c40f98bcb3f39461ca65e26009f9e9f77029279a4587efa2d792ea61ede56e0fbd7c1305007bc59d09bc60eaba46efa23edd1c0000000000000000000000000000000000000000000000000000000000000000000000000000
+        <= 9000
+        => e0048000960000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000233a3559d9da00000000000000000000000000000000000000000000000062e76d8ff4b926e80000000000000000000000000000000000000000000000000000000000000
+        <= 9000
+        => e0048000960000a00000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002bc02aaa39b223fe8d0a0e5c4f27ead9083c756cc200271055747be9f9f5beb232ad59fe7af013b81d95fd5e00000000000000000000000000000000000000000000000000000000000000000000000000000000
+        <= 9000
+        => e00480004e0000000000000000000000004000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000233a3559d9da000c0
+        <= 00a42d6ead5539eb1ac552b65b46df4e8fd87c37da54a280d33dc7a78992b56bb02244776870b31cfb50ea71c0ea31a30e6e513bd9766f74d61dc52b523ac256879000
+        `),
+      );
+      const eth = new Eth(transport);
+      const result = await eth.clearSignTransaction(
+        "44'/60'/0'/0/0",
+        ethers.utils
+          .serializeTransaction({
+            to: transactionContracts.uniswapUniversaRouter,
+            value: ethers.BigNumber.from("0"),
+            gasLimit: ethers.BigNumber.from("298891"),
+            maxPriorityFeePerGas: ethers.BigNumber.from("1150000000"),
+            maxFeePerGas: ethers.BigNumber.from("86969174616"),
+            data: transactionData.uniswap["permit2>swap-out-v3>unwrap"],
+            chainId: 1,
+            nonce: 0,
+            type: 2,
+          })
+          .substring(2),
+        { erc20: true, externalPlugins: true, nft: true, uniswapV3: true },
+        true,
+      );
+      expect(result).toEqual({
+        v: "00",
+        r: "a42d6ead5539eb1ac552b65b46df4e8fd87c37da54a280d33dc7a78992b56bb0",
+        s: "2244776870b31cfb50ea71c0ea31a30e6e513bd9766f74d61dc52b523ac25687",
+      });
+    });
+
     it("should throw in case of error with strict mode", async () => {
       const err = new Error("strictModeCatchThis");
       jest.spyOn(ledgerService, "resolveTransaction").mockRejectedValue(err);

package/tests/Uniswap/decoders.unit.test.ts

@@ -0,0 +1,101 @@
+import { WETH_PER_CHAIN_ID } from "../../src/modules/Uniswap/constants";
+import { UniswapDecoders } from "../../src/modules/Uniswap/decoders";
+
+describe("Uniswap", () => {
+  describe("decoders", () => {
+    it("should decode a V2_SWAP_EXACT_IN command input", () => {
+      // see tx 0x9d032ce73fb2c10432186087dae1b77f05fdd125982bfd04dfa47a23229dcd7f
+      const input =
+        "0x000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000008ef059372e0e255c6f18185b00000000000000000000000000000000000000000000000002520ee13087c56000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000200000000000000000000000069ee720c120ec7c9c52a625c04414459b3185f23000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
+      expect(UniswapDecoders["V2_SWAP_EXACT_IN"](input, 1)).toEqual([
+        "0x69ee720c120ec7c9c52a625c04414459b3185f23", // PEEZY
+        "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", // WETH
+      ]);
+    });
+
+    it("should decode a V2_SWAP_EXACT_OUT command input", () => {
+      // see tx 0x6fcd1f97b5c7d365b7b3c3d426c7039f45f40bdb4e7f6ac7b7fbe45c7ffe2846
+      const input =
+        "0x00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000060a24181e400000000000000000000000000000000000000000000000000000d0853f8cc9607b000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000200000000000000000000000036b25341b2ff1bbc1b019b041ec7423a6cb21969000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
+      expect(UniswapDecoders["V2_SWAP_EXACT_OUT"](input, 1)).toEqual([
+        "0x36b25341b2ff1bbc1b019b041ec7423a6cb21969", // LAMBEAU
+        "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", // WETH
+      ]);
+    });
+
+    it("should decode a V3_SWAP_EXACT_IN command input", () => {
+      // see tx 0xf70e9fd3397af35a01d99ec33eb2652baf9de4cbe2bc042ddfb693dacb2184f2
+      const input =
+        "0x00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000274d48fed3e800000000000000000000000000000000000000000000000064e8c5a11639f40000000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002bc02aaa39b223fe8d0a0e5c4f27ead9083c756cc200271055747be9f9f5beb232ad59fe7af013b81d95fd5e000000000000000000000000000000000000000000";
+      expect(UniswapDecoders["V3_SWAP_EXACT_IN"](input, 1)).toEqual([
+        "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", // WETH
+        "0x55747be9f9f5beb232ad59fe7af013b81d95fd5e", // TBO
+      ]);
+    });
+
+    it("should decode a V3_SWAP_EXACT_OUT command input", () => {
+      // see tx 0x12522daaa016979bf86c8732e2d86b975629c99ddacc86ca935d84a48a00988f
+      const input =
+        "0x00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000233a3559d9da00000000000000000000000000000000000000000000000062e76d8ff4b926e800000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002bc02aaa39b223fe8d0a0e5c4f27ead9083c756cc200271055747be9f9f5beb232ad59fe7af013b81d95fd5e000000000000000000000000000000000000000000";
+      expect(UniswapDecoders["V3_SWAP_EXACT_OUT"](input, 1)).toEqual([
+        "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", // WETH
+        "0x55747be9f9f5beb232ad59fe7af013b81d95fd5e", // TBO
+      ]);
+    });
+
+    it("should decode a WRAP_ETH command input", () => {
+      // see tx 0xf9b0b54a822bae7df4826016661eb213ec934147b7a226ecf88c49cf6ba3ef0d
+      const input =
+        "0x0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000032a04cac0ca0000";
+
+      const supportedChainIds = Object.keys(WETH_PER_CHAIN_ID);
+
+      for (const chainId of supportedChainIds) {
+        const expectedAddress = WETH_PER_CHAIN_ID[chainId];
+        expect(UniswapDecoders["WRAP_ETH"](input, chainId)).toEqual([
+          expectedAddress instanceof Error ? undefined : expectedAddress.toLowerCase(),
+        ]);
+      }
+    });
+
+    it("should decode a UNWRAP_ETH command input", () => {
+      // see tx 0xd2a99d50c3c2bb70040ec94e10aef6d558f8babc92474cfcc2a1aa29da9afdc5
+      const input =
+        "0x0000000000000000000000009580d04543fb19860925c649bb3a7741d7ec75d9000000000000000000000000000000000000000000000000011f162a2bc89bc4";
+
+      const supportedChainIds = Object.keys(WETH_PER_CHAIN_ID);
+
+      for (const chainId of supportedChainIds) {
+        const expectedAddress = WETH_PER_CHAIN_ID[chainId];
+        expect(UniswapDecoders["UNWRAP_ETH"](input, chainId)).toEqual([
+          expectedAddress instanceof Error ? undefined : expectedAddress.toLowerCase(),
+        ]);
+      }
+    });
+
+    it("should return an empty array for other supported commands", () => {
+      const input =
+        "0x00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000204fce5e3e2502611000000000000000000000000000000000000000000000000000000001f942ac9a54ae2700000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000030000000000000000000000003ffeea07a27fab7ad1df5297fa75e77a43cb5790000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc20000000000000000000000000ccae1bc46fb018dd396ed4c45565d4cb9d41098";
+      const otherCommandDecoders = Object.entries(UniswapDecoders)
+        .map(([command, decoder]) => {
+          if (
+            ![
+              "V2_SWAP_EXACT_IN",
+              "V2_SWAP_EXACT_OUT",
+              "V3_SWAP_EXACT_IN",
+              "V3_SWAP_EXACT_OUT",
+              "WRAP_ETH",
+              "UNWRAP_ETH",
+            ].includes(command)
+          ) {
+            return decoder;
+          }
+        })
+        .filter(Boolean);
+
+      for (const decoder of otherCommandDecoders) {
+        expect(decoder!(input, 1)).toEqual([]);
+      }
+    });
+  });
+});