@ledgerhq/hw-app-eth 7.0.0-nightly.2 → 7.0.0-nightly.20251120135143

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

@@ -73,6 +73,15 @@ describe("Uniswap", () => {
       }
     });
 
+    it("should decode a SWEEP command input", () => {
+      // see tx 0xcc3a651b4f962576ed8f2142326271d090dcb701b754429f99e9b77d38cedc30
+      const input =
+        "0x000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb480000000000000000000000001125ffbea29018485cc228e39aade004a359fe990000000000000000000000000000000000000000000000000000000000000000";
+      expect(UniswapDecoders["SWEEP"](input, 1)).toEqual([
+        "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", // USDC
+      ]);
+    });
+
     it("should return an empty array for other supported commands", () => {
       const input =
         "0x00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000204fce5e3e2502611000000000000000000000000000000000000000000000000000000001f942ac9a54ae2700000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000030000000000000000000000003ffeea07a27fab7ad1df5297fa75e77a43cb5790000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc20000000000000000000000000ccae1bc46fb018dd396ed4c45565d4cb9d41098";
@@ -86,6 +95,7 @@ describe("Uniswap", () => {
               "V3_SWAP_EXACT_OUT",
               "WRAP_ETH",
               "UNWRAP_ETH",
+              "SWEEP",
             ].includes(command)
           ) {
             return decoder;

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

@@ -1,30 +1,25 @@
 import nock from "nock";
-import { ethers } from "ethers";
+import { BigNumber } from "@ethersproject/bignumber";
+import { AddressZero } from "@ethersproject/constants";
+import { type Transaction } from "@ethersproject/transactions";
+import SignatureCALEth from "../fixtures/SignatureCALEth";
+import {
+  UNISWAP_EXECUTE_SELECTOR,
+  UNISWAP_UNIVERSAL_ROUTER_ADDRESS,
+} from "../../src/modules/Uniswap/constants";
 import {
   getCommandsAndTokensFromUniswapCalldata,
   isSupported,
   loadInfosForUniswap,
 } from "../../src/modules/Uniswap";
-import {
-  UNISWAP_EXECUTE_SELECTOR,
-  UNISWAP_UNIVERSAL_ROUTER_ADDRESS,
-} from "../../src/modules/Uniswap/constants";
-import SignatureCALEth from "../fixtures/SignatureCALEth";
 
 nock.disableNetConnect();
-jest.mock("@ledgerhq/cryptoassets-evm-signatures/data/evm/index", () => ({
-  get signatures() {
-    return {
-      1: SignatureCALEth,
-    };
-  },
-}));
 
 describe("Uniswap", () => {
   describe("index", () => {
     describe("isSupported", () => {
       it("should return false for a non-Uniswap transaction", () => {
-        expect(isSupported("0x", ethers.constants.AddressZero, 1, [])).toBe(false);
+        expect(isSupported("0x", AddressZero, 1, [])).toBe(false);
       });
 
       it("should return false for a Uniswap transaction with an invalid selector", () => {
@@ -142,16 +137,16 @@ describe("Uniswap", () => {
         const calldata =
           "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";
 
-        const transaction: ethers.Transaction = {
+        const transaction: Transaction = {
           to: UNISWAP_UNIVERSAL_ROUTER_ADDRESS,
           data: calldata,
-          gasLimit: ethers.BigNumber.from(21_000),
+          gasLimit: BigNumber.from(21_000),
           nonce: 0,
-          value: ethers.BigNumber.from(0),
+          value: BigNumber.from(0),
           chainId: 1,
         };
 
-        const res = await loadInfosForUniswap(transaction, 1);
+        const res = await loadInfosForUniswap(transaction, 1, { staticERC20Signatures: { 1: SignatureCALEth } });
         expect(res).toEqual({
           pluginData: Buffer.from(
             "07556e69737761703fc91a3afd70395cd496c647d5a6cc9d4b2b7fad3593564c3044022014391e8f355867a57fe88f6a5a4dbcb8bf8f888a9db3ff3449caf72d120396bd02200c13d9c3f79400fe0aa0434ac54d59b79503c9964a4abc3e8cd22763e0242935",
@@ -162,21 +157,17 @@ describe("Uniswap", () => {
               "0457455448c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000012000000013045022100b47ee8551c15a2cf681c649651e987d7e527c481d27c38da1f971a8242792bd3022069c3f688ac5493a23dab5798e3c9b07484765069e1d4be14321aae4d92cb8cbe",
               "hex",
             ),
-            Buffer.from(
-              "0457455448c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000012000000013045022100b47ee8551c15a2cf681c649651e987d7e527c481d27c38da1f971a8242792bd3022069c3f688ac5493a23dab5798e3c9b07484765069e1d4be14321aae4d92cb8cbe",
-              "hex",
-            ),
           ],
         });
       });
 
       it("should return an empty object for an unsupported Uniswap transaction", async () => {
-        const transaction: ethers.Transaction = {
-          to: ethers.constants.AddressZero,
+        const transaction: Transaction = {
+          to: AddressZero,
           data: "0x",
-          gasLimit: ethers.BigNumber.from(21_000),
+          gasLimit: BigNumber.from(21_000),
           nonce: 0,
-          value: ethers.BigNumber.from(0),
+          value: BigNumber.from(0),
           chainId: 1,
         };
 

package/tests/fixtures/messages/15-permit.json

@@ -8,10 +8,10 @@
   "primaryType": "Permit",
   "message": {
     "deadline": 1718992051,
-    "nonce": 0,
     "spender": "0x111111125421ca6dc452d289314280a0f8842a65",
-    "owner": "0x6cbcd73cd8e8a42844662f0a0e76d7f79afd933d",
-    "value": "115792089237316195423570985008687907853269984665640564039457584007913129639935"
+    "nonce": 0,
+    "value": "115792089237316195423570985008687907853269984665640564039457584007913129639935",
+    "owner": "0x6cbcd73cd8e8a42844662f0a0e76d7f79afd933d"
   },
   "types": {
     "EIP712Domain": [

package/tests/fixtures/messages/16-permit2.json

@@ -7,10 +7,10 @@
   "primaryType": "PermitSingle",
   "message": {
     "details": {
-      "token": "0x7ceb23fd6bc0add59e62ac25578270cff1b9f619",
-      "amount": "69420000000000000000",
       "expiration": "1718184249",
-      "nonce": "0"
+      "amount": "69420000000000000000",
+      "nonce": "0",
+      "token": "0x7ceb23fd6bc0add59e62ac25578270cff1b9f619"
     },
     "spender": "0xec7be89e9d109e7e3fec59c222cf297125fefda2",
     "sigDeadline": "1715594049"

package/tests/fixtures/messages/17-uniswapx.json

@@ -15,11 +15,11 @@
     "deadline": "1718467096",
     "witness": {
       "info": {
-        "reactor": "0x6000da47483062a0d734ba3dc7576ce6a0b645c4",
-        "swapper": "0x224cbc440944c72e951507e97d8bf5ffa2e3d2b9",
         "nonce": "1993354326232431306240697018571020274189859638820531235067341608173853199105",
-        "deadline": "1718467096",
+        "swapper": "0x224cbc440944c72e951507e97d8bf5ffa2e3d2b9",
         "additionalValidationContract": "0x0000000000000000000000000000000000000000",
+        "reactor": "0x6000da47483062a0d734ba3dc7576ce6a0b645c4",
+        "deadline": "1718467096",
         "additionalValidationData": "0x"
       },
       "decayStartTime": "1718467024",
@@ -31,15 +31,15 @@
       "inputEndAmount": "100000000000000000",
       "outputs": [
         {
-          "token": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
           "startAmount": "348572327",
+          "token": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
           "endAmount": "332452012",
           "recipient": "0x224cbc440944c72e951507e97d8bf5ffa2e3d2b9"
         },
         {
+          "endAmount": "833213",
           "token": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
           "startAmount": "873614",
-          "endAmount": "833213",
           "recipient": "0x27213e28d7fda5c57fe9e5dd923818dbccf71c47"
         }
       ]

package/tests/fixtures/utils.ts

@@ -1,13 +1,14 @@
-import { ethers } from "ethers";
+import { Interface } from "@ethersproject/abi";
+import { serialize as serializeTransaction } from "@ethersproject/transactions";
 import ERC20Abi from "./ABI/ERC20.json";
 import ERC721Abi from "./ABI/ERC721.json";
 import ERC1155Abi from "./ABI/ERC1155.json";
 import PARASWAPAbi from "./ABI/PARASWAP.json";
 
-const ERC20Interface = new ethers.utils.Interface(ERC20Abi);
-const ERC721Interface = new ethers.utils.Interface(ERC721Abi);
-const ERC1155Interface = new ethers.utils.Interface(ERC1155Abi);
-const PARASWAPInterface = new ethers.utils.Interface(PARASWAPAbi);
+const ERC20Interface = new Interface(ERC20Abi);
+const ERC721Interface = new Interface(ERC721Abi);
+const ERC1155Interface = new Interface(ERC1155Abi);
+const PARASWAPInterface = new Interface(PARASWAPAbi);
 
 export const transactionContracts = {
   erc20: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
@@ -102,16 +103,14 @@ export const transactionData = {
 };
 
 export const getSerializedTransaction = (to: string, data: string): string =>
-  ethers.utils
-    .serializeTransaction({
-      to,
-      nonce: 0,
-      gasLimit: 21000,
-      data,
-      value: 1,
-      chainId: 1,
-      maxPriorityFeePerGas: 10000,
-      maxFeePerGas: 1000000,
-      type: 2,
-    })
-    .substring(2);
+  serializeTransaction({
+    to,
+    nonce: 0,
+    gasLimit: 21000,
+    data,
+    value: 1,
+    chainId: 1,
+    maxPriorityFeePerGas: 10000,
+    maxFeePerGas: 1000000,
+    type: 2,
+  }).substring(2);

package/tests/ledgerService.unit.test.ts

@@ -11,7 +11,7 @@ import * as uniswapModule from "../src/modules/Uniswap";
 import { ResolutionConfig } from "../src/services/types";
 import { ledgerService } from "../src/Eth";
 
-const loadConfig = getLoadConfig();
+const loadConfig = getLoadConfig({ staticERC20Signatures: { 1: signatureCALEth } });
 const resolutionConfig: ResolutionConfig = {
   nft: true,
   erc20: true,
@@ -676,7 +676,6 @@ describe("Ledger Service", () => {
           domains: [],
           erc20Tokens: [
             "0457455448c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000012000000013045022100b47ee8551c15a2cf681c649651e987d7e527c481d27c38da1f971a8242792bd3022069c3f688ac5493a23dab5798e3c9b07484765069e1d4be14321aae4d92cb8cbe",
-            "0457455448c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000012000000013045022100b47ee8551c15a2cf681c649651e987d7e527c481d27c38da1f971a8242792bd3022069c3f688ac5493a23dab5798e3c9b07484765069e1d4be14321aae4d92cb8cbe",
           ],
           nfts: [],
           externalPlugin: [
@@ -689,8 +688,8 @@ describe("Ledger Service", () => {
           plugin: [],
         });
         expect(contractServices.loadInfosForContractMethod).toHaveBeenCalledTimes(0);
-        expect(erc20Services.findERC20SignaturesInfo).toHaveBeenCalledTimes(3);
-        expect(erc20Services.byContractAddressAndChainId).toHaveBeenCalledTimes(3);
+        expect(erc20Services.findERC20SignaturesInfo).toHaveBeenCalledTimes(2);
+        expect(erc20Services.byContractAddressAndChainId).toHaveBeenCalledTimes(2);
         expect(uniswapModule.loadInfosForUniswap).toHaveBeenCalledTimes(1);
         expect(uniswapModule.getCommandsAndTokensFromUniswapCalldata).toHaveBeenCalledTimes(1);
         expect(nftServices.getNFTInfo).not.toHaveBeenCalled();
@@ -719,7 +718,6 @@ describe("Ledger Service", () => {
           domains: [],
           erc20Tokens: [
             "0457455448c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000012000000013045022100b47ee8551c15a2cf681c649651e987d7e527c481d27c38da1f971a8242792bd3022069c3f688ac5493a23dab5798e3c9b07484765069e1d4be14321aae4d92cb8cbe",
-            "0457455448c02aaa39b223fe8d0a0e5c4f27ead9083c756cc200000012000000013045022100b47ee8551c15a2cf681c649651e987d7e527c481d27c38da1f971a8242792bd3022069c3f688ac5493a23dab5798e3c9b07484765069e1d4be14321aae4d92cb8cbe",
           ],
           nfts: [],
           externalPlugin: [
@@ -732,8 +730,8 @@ describe("Ledger Service", () => {
           plugin: [],
         });
         expect(contractServices.loadInfosForContractMethod).toHaveBeenCalledTimes(0);
-        expect(erc20Services.findERC20SignaturesInfo).toHaveBeenCalledTimes(3);
-        expect(erc20Services.byContractAddressAndChainId).toHaveBeenCalledTimes(3);
+        expect(erc20Services.findERC20SignaturesInfo).toHaveBeenCalledTimes(2);
+        expect(erc20Services.byContractAddressAndChainId).toHaveBeenCalledTimes(2);
         expect(uniswapModule.loadInfosForUniswap).toHaveBeenCalledTimes(1);
         expect(uniswapModule.getCommandsAndTokensFromUniswapCalldata).toHaveBeenCalledTimes(1);
         expect(nftServices.getNFTInfo).not.toHaveBeenCalled();

package/tests/utils.unit.test.ts

@@ -0,0 +1,341 @@
+import BigNumber from "bignumber.js";
+import * as rlp from "@ethersproject/rlp";
+import { AddressZero } from "@ethersproject/constants";
+import { BigNumber as EthersBigNumber } from "@ethersproject/bignumber";
+import { type Transaction, serialize as serializeTransaction } from "@ethersproject/transactions";
+import {
+  getChainIdAsUint32,
+  getParity,
+  getV,
+  hexBuffer,
+  intAsHexBytes,
+  maybeHexBuffer,
+  mergeResolutions,
+  padHexString,
+  safeChunkTransaction,
+  splitPath,
+} from "../src/utils";
+
+const chainIdsToTest = [
+  "1", // Always test Ethereum mainnet
+  "56", // Binance Smart Chain
+  "134", // Polygon
+  "109", // just under the limit for the EIP-155 operation to potentially be more than 1 byte
+  "110", // floor limit for the EIP-155 operation to be more than 1 byte if v is 1
+  "111", // floor limit for the EIP-155 operation to be more than 1 byte even if v is 0
+  "10000", // Random high value
+  "2716446429837000", // highest chainId known
+];
+
+describe("Eth app biding", () => {
+  describe("Utils", () => {
+    describe("padHexString", () => {
+      it("should prevent hex string from being odd length", () => {
+        expect(padHexString("123")).toEqual("0123");
+      });
+    });
+
+    describe("splitPath", () => {
+      it("should split derivation path correctly and respect hardened paths", () => {
+        expect(splitPath("44'/60'/123/456/789")).toEqual([
+          44 + 0x80000000,
+          60 + 0x80000000,
+          123,
+          456,
+          789,
+        ]);
+      });
+    });
+
+    describe("hexBuffer", () => {
+      it("should convert hex string to buffer", () => {
+        const buff = Buffer.from("0123", "hex");
+        expect(hexBuffer("0x123")).toEqual(buff);
+        expect(hexBuffer("123")).toEqual(buff);
+        expect(hexBuffer("0123")).toEqual(buff);
+      });
+    });
+
+    describe("maybeHexBuffer", () => {
+      it("should bufferize hex string and return null for empty input", () => {
+        expect(maybeHexBuffer("0x123")).toEqual(Buffer.from("0123", "hex"));
+        expect(maybeHexBuffer("")).toEqual(null);
+      });
+    });
+
+    describe("intAsHexBytes", () => {
+      it("should convert integer to hex string with correct number of bytes", () => {
+        expect(intAsHexBytes(123, 1)).toEqual("7b");
+        expect(intAsHexBytes(123, 2)).toEqual("007b");
+        expect(intAsHexBytes(123, 4)).toEqual("0000007b");
+      });
+    });
+
+    describe("mergeResolutions", () => {
+      it("should merge resolutions", () => {
+        const resolutions1 = {
+          nfts: ["nft1", "nft2"],
+          erc20Tokens: ["erc20Token1", "erc20Token2"],
+          externalPlugin: [{ payload: "payload1", signature: "signature1" }],
+          plugin: ["plugin1", "plugin2"],
+          domains: [
+            {
+              registry: "ens" as const,
+              domain: "dev.0xkvn.eth",
+              address: "0x6cBCD73CD8e8a42844662f0A0e76D7F79Afd933d",
+              type: "forward" as const,
+            },
+          ],
+        };
+        const resolutions2 = {
+          nfts: ["nft3", "nft4"],
+          erc20Tokens: ["erc20Token3", "erc20Token4"],
+          externalPlugin: [{ payload: "payload2", signature: "signature2" }],
+          plugin: ["plugin3", "plugin4"],
+          domains: [
+            {
+              registry: "ens" as const,
+              domain: "0xkvn.eth",
+              address: "0xB0xB0b5B0106D69fE64545A60A68C014f7570D3F861",
+              type: "reverse" as const,
+            },
+          ],
+        };
+        expect(mergeResolutions([resolutions1, resolutions2])).toEqual({
+          nfts: ["nft1", "nft2", "nft3", "nft4"],
+          erc20Tokens: ["erc20Token1", "erc20Token2", "erc20Token3", "erc20Token4"],
+          externalPlugin: [
+            { payload: "payload1", signature: "signature1" },
+            { payload: "payload2", signature: "signature2" },
+          ],
+          plugin: ["plugin1", "plugin2", "plugin3", "plugin4"],
+          domains: [
+            {
+              registry: "ens",
+              domain: "dev.0xkvn.eth",
+              address: "0x6cBCD73CD8e8a42844662f0A0e76D7F79Afd933d",
+              type: "forward",
+            },
+            {
+              registry: "ens",
+              domain: "0xkvn.eth",
+              address: "0xB0xB0b5B0106D69fE64545A60A68C014f7570D3F861",
+              type: "reverse",
+            },
+          ],
+        });
+      });
+    });
+
+    describe("getParity", () => {
+      it("should return the v from the device for typed transactions (EIP-2718)", () => {
+        expect(getParity(0, new BigNumber(1), 1)).toEqual(0);
+        expect(getParity(1, new BigNumber(1), 1)).toEqual(1);
+        expect(getParity(0, new BigNumber(1), 2)).toEqual(0);
+        expect(getParity(1, new BigNumber(1), 2)).toEqual(1);
+      });
+
+      it.each(chainIdsToTest)(
+        "should return the v from the device for legacy transactions (EIP-155) with chainId: %s",
+        (chainId: string) => {
+          const chainIdBN = new BigNumber(chainId);
+          const chainIdUint4 = parseInt(
+            Buffer.from(padHexString(chainIdBN.toString(16)), "hex")
+              .subarray(0, 4)
+              .toString("hex"),
+            16,
+          );
+          const chainIdWithEIP155 = chainIdUint4 * 2 + 35;
+
+          expect([
+            getParity(chainIdWithEIP155 % 256, chainIdBN, null),
+            getParity((chainIdWithEIP155 + 1) % 256, chainIdBN, null),
+          ]).toEqual([0, 1]);
+        },
+      );
+    });
+
+    describe("getChainIdAsUint32", () => {
+      it("should return the chainId as a 4 bytes integer", () => {
+        expect(getChainIdAsUint32(1)).toEqual(1);
+        expect(getChainIdAsUint32(134)).toEqual(134);
+        expect(getChainIdAsUint32(new BigNumber(134))).toEqual(134);
+        expect(getChainIdAsUint32(new BigNumber(10_000_000_000))).toEqual(39062500);
+        expect(getChainIdAsUint32(10_000_000_000)).toEqual(39062500);
+      });
+    });
+
+    describe("getV", () => {
+      it("should return the v value from the device for legacy transactions non providing a chainId", () => {
+        expect(getV(27, new BigNumber(0), null)).toEqual((27).toString(16));
+        expect(getV(28, new BigNumber(0), null)).toEqual((28).toString(16));
+      });
+
+      it.each(chainIdsToTest)(
+        "should return the v with EIP-155 applied for legacy transactions providing chainId: %s",
+        (chainId: string) => {
+          const chainIdBN = new BigNumber(chainId);
+          const chainIdUint4 = parseInt(
+            Buffer.from(padHexString(chainIdBN.toString(16)), "hex")
+              .subarray(0, 4)
+              .toString("hex"),
+            16,
+          );
+          const chainIdWithEIP155 = chainIdUint4 * 2 + 35;
+          const vEven = chainIdWithEIP155 % 256;
+          const vOdd = (chainIdWithEIP155 + 1) % 256;
+
+          expect(getV(vEven, chainIdBN, null)).toEqual(
+            padHexString(chainIdBN.multipliedBy(2).plus(35).toString(16)),
+          );
+          expect(getV(vOdd, chainIdBN, null)).toEqual(
+            padHexString(chainIdBN.multipliedBy(2).plus(35).plus(1).toString(16)),
+          );
+        },
+      );
+
+      it.each(chainIdsToTest)(
+        "should return the parity for transactions using EIP-2718 and no matter the chainId: %s",
+        (chainId: string) => {
+          const chainIdBN = new BigNumber(chainId);
+          expect(getV(0, chainIdBN, 1)).toEqual("00");
+          expect(getV(1, chainIdBN, 1)).toEqual("01");
+          expect(getV(0, chainIdBN, 2)).toEqual("00");
+          expect(getV(1, chainIdBN, 2)).toEqual("01");
+        },
+      );
+
+      it("should throw an error if the v value is invalid", () => {
+        expect(() => getV(26, new BigNumber(10_000), null)).toThrow("Invalid v value");
+      });
+    });
+
+    describe("safeChunkTransaction", () => {
+      // Derivation of 44'/60'/0'/0'/0
+      // 21B
+      const derivationPathBuff = Buffer.from("058000002c8000003c800000008000000000000000", "hex");
+
+      it("should return a single chunk if the transaction is small enough", () => {
+        const rawTx: Transaction = {
+          to: AddressZero,
+          nonce: 0,
+          value: EthersBigNumber.from(0),
+          gasPrice: EthersBigNumber.from(1),
+          gasLimit: EthersBigNumber.from(2),
+          data: "0x",
+          chainId: 1,
+        };
+        const serialized = serializeTransaction(rawTx);
+        const rlpBuff = Buffer.from(serialized.slice(2), "hex");
+
+        if (rlpBuff.length + derivationPathBuff.length > 255)
+          throw new Error("Transaction too big");
+
+        const payload = Buffer.concat([derivationPathBuff, rlpBuff]);
+        expect(safeChunkTransaction(rlpBuff, derivationPathBuff, rawTx.type)).toEqual([payload]);
+      });
+
+      it("should return multiple 255B chunks for typed transactions (EIP-2718)", () => {
+        const rawTx: Transaction = {
+          to: AddressZero,
+          nonce: 0,
+          value: EthersBigNumber.from(0),
+          gasPrice: EthersBigNumber.from(1),
+          gasLimit: EthersBigNumber.from(2),
+          data: "0x" + new Array(256).fill("00").join(""),
+          chainId: 1,
+          type: 1,
+        };
+        const serialized = serializeTransaction(rawTx);
+        const rlpBuff = Buffer.from(serialized.slice(2), "hex");
+
+        if (rlpBuff.length + derivationPathBuff.length < 255)
+          throw new Error("Transaction too small");
+
+        // Chunk size should be 255B
+        const payload = Buffer.concat([derivationPathBuff, rlpBuff]);
+        const chunks = safeChunkTransaction(rlpBuff, derivationPathBuff, rawTx.type);
+        expect(chunks.length).toEqual(2);
+        expect(chunks).toEqual([payload.subarray(0, 255), payload.subarray(255)]);
+      });
+
+      it("should return multiple variable chunks for legacy transactions to prevent chunking just before the [r,s,v] for a 1 byte chainId", () => {
+        const rawTx: Transaction = {
+          to: AddressZero,
+          nonce: 0,
+          value: EthersBigNumber.from(0),
+          gasPrice: EthersBigNumber.from(1),
+          gasLimit: EthersBigNumber.from(2),
+          data: "0x" + new Array(458).fill("00").join(""),
+          chainId: 127, // RLP of VRS should be only 3B as this value is <= 0x7f
+          type: 0,
+        };
+        const serialized = serializeTransaction(rawTx);
+        const rlpBuff = Buffer.from(serialized.slice(2), "hex");
+
+        if (rlpBuff.length + derivationPathBuff.length !== 513)
+          throw new Error("Transaction not chunking before the [r,s,v]");
+
+        // Chunk size should be 254B to avoid chunking just before the [r,s,v]
+        const payload = Buffer.concat([derivationPathBuff, rlpBuff]);
+        const chunks = safeChunkTransaction(rlpBuff, derivationPathBuff, rawTx.type);
+        expect(chunks.length).toEqual(3);
+        expect(chunks).toEqual([
+          payload.subarray(0, 254),
+          payload.subarray(254, 508),
+          payload.subarray(508),
+        ]);
+      });
+
+      // Above 6 bytes values, ethers will simply fail parsing/serializing the transaction
+      it.each([1, 2, 3, 4, 5, 6])(
+        "should return multiple variable chunks for legacy transactions to prevent chunking just before the [r,s,v] for a %s byte(s) chainId",
+        (chainIdSizeInBytes: number) => {
+          const chainId = new BigNumber("0x" + new Array(chainIdSizeInBytes).fill("81").join(""));
+          const encodedVrs = hexBuffer(
+            rlp.encode(["0x" + chainId.toString(16), "0x", "0x"]),
+          ).subarray(1);
+
+          for (let i = 1; i <= encodedVrs.length; i++) {
+            const rawTx: Transaction = {
+              to: AddressZero,
+              nonce: 0,
+              value: EthersBigNumber.from(0),
+              gasPrice: EthersBigNumber.from(1),
+              gasLimit: EthersBigNumber.from(2),
+              data: "0x" + new Array(458 - chainIdSizeInBytes).fill("00").join(""), // This should make a 492B long rlp
+              chainId: chainId.toNumber(),
+              type: 0,
+            };
+            const serialized = serializeTransaction(rawTx);
+            const rlpBuff = Buffer.from(serialized.slice(2), "hex");
+
+            if (rlpBuff.length + derivationPathBuff.length !== 513)
+              throw new Error("Transaction not chunking before the [r,s,v]");
+
+            // Just made from observation, don't treat this as a general rule
+            const chunkSize =
+              chainIdSizeInBytes < 3
+                ? 255 - chainIdSizeInBytes
+                : chainIdSizeInBytes < 5
+                  ? 256 - chainIdSizeInBytes
+                  : 257 - chainIdSizeInBytes;
+            const chunks = safeChunkTransaction(rlpBuff, derivationPathBuff, rawTx.type);
+            expect(chunks.length).toEqual(3);
+            expect(
+              [`0000` + encodedVrs.toString("hex"), `00` + encodedVrs.toString("hex")].includes(
+                chunks[2].toString("hex"),
+              ),
+            ).toBe(true);
+            const payload = Buffer.concat([derivationPathBuff, rlpBuff]);
+            expect(safeChunkTransaction(rlpBuff, derivationPathBuff, rawTx.type)).toEqual([
+              payload.subarray(0, chunkSize),
+              payload.subarray(chunkSize, chunkSize * 2),
+              payload.subarray(chunkSize * 2),
+            ]);
+          }
+        },
+      );
+    });
+  });
+});