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

package/src/modules/Uniswap/index.ts

@@ -1,5 +1,6 @@
 import { log } from "@ledgerhq/logs";
-import { utils, Transaction } from "ethers";
+import { Interface } from "@ethersproject/abi";
+import type { Transaction } from "@ethersproject/transactions";
 import { byContractAddressAndChainId, findERC20SignaturesInfo } from "../../services/ledger/erc20";
 import { LoadConfig } from "../../services/types";
 import { UniswapDecoders } from "./decoders";
@@ -81,7 +82,7 @@ export const getCommandsAndTokensFromUniswapCalldata = (
   chainId: number,
 ): CommandsAndTokens => {
   try {
-    const [commands, inputs] = new utils.Interface([
+    const [commands, inputs] = new Interface([
       "function execute(bytes calldata commands, bytes[] calldata inputs, uint256 deadline) external payable",
     ]).decodeFunctionData("execute", calldata) as [`0x${string}`, `0x${string}`[]];
 
@@ -124,14 +125,14 @@ export const loadInfosForUniswap = async (
     return {};
   }
 
+  const uniqueTokens = Array.from(new Set(commandsAndTokens.flatMap(([, tokens]) => tokens)));
   const tokenDescriptorsPromises = Promise.all(
-    commandsAndTokens.flatMap(([, tokens]) =>
-      tokens.map(async token => {
-        const erc20SignaturesBlob = await findERC20SignaturesInfo(userConfig || {}, chainId);
-        return byContractAddressAndChainId(token, chainId, erc20SignaturesBlob)?.data;
-      }),
-    ),
+    uniqueTokens.map(async token => {
+      const erc20SignaturesBlob = await findERC20SignaturesInfo(userConfig || {}, chainId);
+      return byContractAddressAndChainId(token, chainId, erc20SignaturesBlob, userConfig)?.data;
+    }),
   );
+
   const tokenDescriptors = await tokenDescriptorsPromises.then(descriptors =>
     descriptors.filter((descriptor): descriptor is Buffer => !!descriptor),
   );

package/src/modules/Uniswap/types.ts

@@ -9,6 +9,7 @@ export type UniswapSupportedCommand =
   | "PERMIT2_TRANSFER_FROM"
   | "PERMIT2_PERMIT_BATCH"
   | "PERMIT2_TRANSFER_FROM_BATCH"
-  | "PAY_PORTION";
+  | "PAY_PORTION"
+  | "SWEEP";
 
 export type CommandsAndTokens = [UniswapSupportedCommand | undefined, `0x${string}`[]][];

package/src/services/ledger/erc20.ts

@@ -1,6 +1,5 @@
 import axios from "axios";
 import { log } from "@ledgerhq/logs";
-import { signatures as signaturesByChainId } from "@ledgerhq/cryptoassets-evm-signatures/data/evm/index";
 import { getLoadConfig } from "./loadConfig";
 import { LoadConfig } from "../types";
 
@@ -40,18 +39,31 @@ export const byContractAddressAndChainId = (
   contract: string,
   chainId: number,
   erc20SignaturesBlob?: string | null,
+  userLoadConfig?: LoadConfig,
 ): ReturnType<API["byContractAndChainId"]> => {
   // If we are able to fetch data from s3 bucket that contains dynamic CAL
   if (erc20SignaturesBlob) {
     try {
       return parse(erc20SignaturesBlob).byContractAndChainId(asContractAddress(contract), chainId);
     } catch (e) {
-      return get(chainId)?.byContractAndChainId(asContractAddress(contract), chainId);
+      // Fall through to static fallback if dynamic CAL parsing fails
     }
   }
 
-  // the static fallback when dynamic cal is not provided
-  return get(chainId)?.byContractAndChainId(asContractAddress(contract), chainId);
+  // Static fallback from injected signatures (for external library users)
+  const loadConfig = userLoadConfig ? getLoadConfig(userLoadConfig) : null;
+  if (loadConfig?.staticERC20Signatures?.[chainId]) {
+    try {
+      return parse(loadConfig.staticERC20Signatures[chainId]).byContractAndChainId(
+        asContractAddress(contract),
+        chainId,
+      );
+    } catch (e) {
+      log("error", `Failed to parse static ERC20 signatures for chainId ${chainId}: ${String(e)}`);
+    }
+  }
+
+  return null;
 };
 
 export type TokenInfo = {
@@ -108,18 +120,3 @@ const parse = (erc20SignaturesBlob: string): API => {
       map[String(chainId) + ":" + contractAddress],
   };
 };
-
-// this internal get() will lazy load and cache the data from the erc20 data blob
-const get: (chainId: number) => API | null = (() => {
-  const cache: Record<number, API> = {};
-  return chainId => {
-    if (cache[chainId]) return cache[chainId];
-
-    const signatureBlob: string | undefined = signaturesByChainId[chainId];
-    if (!signatureBlob) return null;
-
-    const api = parse(signatureBlob);
-    cache[chainId] = api;
-    return api;
-  };
-})();

package/src/services/ledger/index.ts

@@ -1,16 +1,25 @@
-import { utils } from "ethers";
+import { parse as parseTransaction } from "@ethersproject/transactions";
+import { Interface } from "@ethersproject/abi";
 import { log } from "@ledgerhq/logs";
 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 {
+  tokenSelectors,
+  nftSelectors,
+  mergeResolutions,
+  ERC20_CLEAR_SIGNED_SELECTORS,
+  ERC1155_CLEAR_SIGNED_SELECTORS,
+  ERC721_CLEAR_SIGNED_SELECTORS,
+  getChainIdAsUint32,
+} from "../../utils";
 
 type PotentialResolutions = {
   token: boolean | undefined;
@@ -28,7 +37,7 @@ type PotentialResolutions = {
  */
 const getAdditionalDataForContract = async (
   contractAddress: string,
-  chainIdTruncated: number,
+  chainIdUint32: number,
   loadConfig: LoadConfig,
   shouldResolve: PotentialResolutions,
 ): Promise<Pick<LedgerEthTransactionResolution, "nfts" | "erc20Tokens">> => {
@@ -38,7 +47,7 @@ const getAdditionalDataForContract = async (
   };
 
   if (shouldResolve.nft) {
-    const nftInfo = await getNFTInfo(contractAddress, chainIdTruncated, loadConfig);
+    const nftInfo = await getNFTInfo(contractAddress, chainIdUint32, loadConfig);
 
     if (nftInfo) {
       log(
@@ -52,11 +61,12 @@ const getAdditionalDataForContract = async (
   }
 
   if (shouldResolve.token) {
-    const erc20SignaturesBlob = await findERC20SignaturesInfo(loadConfig, chainIdTruncated);
+    const erc20SignaturesBlob = await findERC20SignaturesInfo(loadConfig, chainIdUint32);
     const erc20Info = byContractAddressAndChainId(
       contractAddress,
-      chainIdTruncated,
+      chainIdUint32,
       erc20SignaturesBlob,
+      loadConfig,
     );
 
     if (erc20Info) {
@@ -83,8 +93,8 @@ const getAdditionalDataForContract = async (
 const loadNanoAppPlugins = async (
   contractAddress: string,
   selector: string,
-  decodedTx,
-  chainIdTruncated: number,
+  parsedTransaction,
+  chainIdUint32: number,
   loadConfig: LoadConfig,
   shouldResolve: PotentialResolutions,
 ): Promise<LedgerEthTransactionResolution> => {
@@ -100,7 +110,7 @@ const loadNanoAppPlugins = async (
     const nftPluginPayload = await loadNftPlugin(
       contractAddress,
       selector,
-      chainIdTruncated,
+      chainIdUint32,
       loadConfig,
     );
 
@@ -120,7 +130,7 @@ const loadNanoAppPlugins = async (
     const contractMethodInfos = await loadInfosForContractMethod(
       contractAddress,
       selector,
-      chainIdTruncated,
+      chainIdUint32,
       loadConfig,
     );
 
@@ -133,8 +143,8 @@ const loadNanoAppPlugins = async (
       }
 
       if (erc20OfInterest && erc20OfInterest.length && abi) {
-        const contract = new utils.Interface(abi);
-        const args = contract.parseTransaction(decodedTx).args;
+        const contract = new Interface(abi);
+        const args = contract.parseTransaction(parsedTransaction).args;
 
         for (const path of erc20OfInterest) {
           const erc20ContractAddress = path.split(".").reduce((value, seg) => {
@@ -146,7 +156,7 @@ const loadNanoAppPlugins = async (
 
           const externalPluginResolution = await getAdditionalDataForContract(
             erc20ContractAddress,
-            chainIdTruncated,
+            chainIdUint32,
             loadConfig,
             {
               nft: false,
@@ -164,7 +174,10 @@ const loadNanoAppPlugins = async (
   }
 
   if (shouldResolve.uniswapV3) {
-    const { pluginData, tokenDescriptors } = await loadInfosForUniswap(decodedTx, chainIdTruncated);
+    const { pluginData, tokenDescriptors } = await loadInfosForUniswap(
+      parsedTransaction,
+      chainIdUint32,
+    );
     if (pluginData && tokenDescriptors) {
       resolution.externalPlugin.push({
         payload: pluginData.toString("hex"),
@@ -189,17 +202,32 @@ const resolveTransaction: LedgerEthTransactionService["resolveTransaction"] = as
   resolutionConfig,
 ) => {
   const rawTx = Buffer.from(rawTxHex, "hex");
-  const { decodedTx, chainIdTruncated } = decodeTxInfo(rawTx);
+  const parsedTransaction = parseTransaction(`0x${rawTx.toString("hex")}`);
+  const chainIdUint32 = getChainIdAsUint32(parsedTransaction.chainId);
   const { domains } = resolutionConfig;
 
-  const contractAddress = decodedTx.to;
-  const selector = decodedTx.data.length >= 10 && decodedTx.data.substring(0, 10);
+  const contractAddress = parsedTransaction.to?.toLowerCase();
+  if (!contractAddress)
+    return {
+      nfts: [],
+      erc20Tokens: [],
+      externalPlugin: [],
+      plugin: [],
+      domains: [],
+    };
+
+  const selector = parsedTransaction.data.length >= 10 && parsedTransaction.data.substring(0, 10);
 
   const resolutions: Partial<LedgerEthTransactionResolution>[] = [];
   if (selector) {
     const shouldResolve: PotentialResolutions = {
-      token: resolutionConfig.erc20 && tokenSelectors.includes(selector),
-      nft: resolutionConfig.nft && nftSelectors.includes(selector),
+      token:
+        resolutionConfig.erc20 && tokenSelectors.includes(selector as ERC20_CLEAR_SIGNED_SELECTORS),
+      nft:
+        resolutionConfig.nft &&
+        nftSelectors.includes(
+          selector as ERC721_CLEAR_SIGNED_SELECTORS | ERC1155_CLEAR_SIGNED_SELECTORS,
+        ),
       externalPlugins: resolutionConfig.externalPlugins,
       uniswapV3: resolutionConfig.uniswapV3,
     };
@@ -207,8 +235,8 @@ const resolveTransaction: LedgerEthTransactionService["resolveTransaction"] = as
     const pluginsResolution = await loadNanoAppPlugins(
       contractAddress,
       selector,
-      decodedTx,
-      chainIdTruncated,
+      parsedTransaction,
+      chainIdUint32,
       loadConfig,
       shouldResolve,
     );
@@ -218,7 +246,7 @@ const resolveTransaction: LedgerEthTransactionService["resolveTransaction"] = as
 
     const contractResolution = await getAdditionalDataForContract(
       contractAddress,
-      chainIdTruncated,
+      chainIdUint32,
       loadConfig,
       shouldResolve,
     );

package/src/services/ledger/loadConfig.ts

@@ -1,11 +1,14 @@
 import type { LoadConfig } from "../types";
 
-const defaultLoadConfig: Required<LoadConfig> = {
+const defaultLoadConfig: LoadConfig = {
   nftExplorerBaseURL: "https://nft.api.live.ledger.com/v1/ethereum",
   pluginBaseURL: "https://cdn.live.ledger.com",
   extraPlugins: null,
   cryptoassetsBaseURL: "https://cdn.live.ledger.com/cryptoassets",
   calServiceURL: "https://crypto-assets-service.api.ledger.com",
+  staticERC20Signatures: null,
+  staticEIP712SignaturesV1: null,
+  staticEIP712SignaturesV2: null,
 };
 
 export function getLoadConfig(userLoadConfig?: LoadConfig): LoadConfig {

package/src/services/ledger/nfts.ts

@@ -40,7 +40,7 @@ export const getNFTInfo = async (
     ?.reduce((acc, curr) => (acc += String.fromCharCode(parseInt(curr, 16))), ""); // convert hex to string
 
   return {
-    contractAddress: contractAddress,
+    contractAddress,
     collectionName: collectionName || "",
     data: payload,
   };

package/src/services/types.ts

@@ -29,6 +29,18 @@ export type LoadConfig = {
   extraPlugins?: any | null;
   cryptoassetsBaseURL?: string | null;
   calServiceURL?: string | null;
+  // Static ERC20 signatures fallback (base64 encoded blobs by chainId)
+  // Can be provided from @ledgerhq/cryptoassets-evm-signatures/data/evm/index
+  // Example: { 1: "base64blob...", 137: "base64blob..." }
+  staticERC20Signatures?: Record<number, string> | null;
+  // Static EIP712 signatures fallback (v1 format)
+  // Can be provided from @ledgerhq/cryptoassets-evm-signatures/data/eip712
+  // Example: { "1:0xcontract:hash": { fields: [...] }, ... }
+  staticEIP712SignaturesV1?: Record<string, any> | null;
+  // Static EIP712 signatures fallback (v2 format)
+  // Can be provided from @ledgerhq/cryptoassets-evm-signatures/data/eip712_v2
+  // Example: { "1:0xcontract:hash": { fields: [...] }, ... }
+  staticEIP712SignaturesV2?: Record<string, any> | null;
 };
 
 /**

package/src/utils.ts

@@ -1,16 +1,19 @@
 import { BigNumber } from "bignumber.js";
+import * as rlp from "@ethersproject/rlp";
 import {
   ERC20_CLEAR_SIGNED_SELECTORS,
   ERC721_CLEAR_SIGNED_SELECTORS,
   ERC1155_CLEAR_SIGNED_SELECTORS,
+  DAPP_SELECTORS,
 } from "@ledgerhq/evm-tools/selectors/index";
-import { encode, decode } from "@ethersproject/rlp";
+import type { Transaction } from "@ethersproject/transactions";
 import { LedgerEthTransactionResolution } from "./services/types";
 
 export {
   ERC20_CLEAR_SIGNED_SELECTORS,
   ERC721_CLEAR_SIGNED_SELECTORS,
   ERC1155_CLEAR_SIGNED_SELECTORS,
+  DAPP_SELECTORS,
 };
 
 export const padHexString = (str: string) => {
@@ -18,22 +21,27 @@ export const padHexString = (str: string) => {
 };
 
 export function splitPath(path: string): number[] {
-  const result: number[] = [];
-  const components = path.split("/");
-  components.forEach(element => {
-    let number = parseInt(element, 10);
-    if (isNaN(number)) {
+  const splittedPath: number[] = [];
+
+  const paths = path.split("/");
+  paths.forEach(path => {
+    let value = parseInt(path, 10);
+    if (isNaN(value)) {
       return; // FIXME shouldn't it throws instead?
     }
-    if (element.length > 1 && element[element.length - 1] === "'") {
-      number += 0x80000000;
+    // Detect hardened paths
+    if (path.length > 1 && path[path.length - 1] === "'") {
+      value += 0x80000000;
     }
-    result.push(number);
+    splittedPath.push(value);
   });
-  return result;
+
+  return splittedPath;
 }
 
 export function hexBuffer(str: string): Buffer {
+  if (!str) return Buffer.alloc(0);
+
   const strWithoutPrefix = str.startsWith("0x") ? str.slice(2) : str;
   return Buffer.from(padHexString(strWithoutPrefix), "hex");
 }
@@ -43,81 +51,6 @@ export function maybeHexBuffer(str: string | null | undefined): Buffer | null |
   return hexBuffer(str);
 }
 
-export const decodeTxInfo = (rawTx: Buffer) => {
-  const VALID_TYPES = [1, 2];
-  const txType = VALID_TYPES.includes(rawTx[0]) ? rawTx[0] : null;
-  const rlpData = txType === null ? rawTx : rawTx.slice(1);
-  const rlpTx = decode(rlpData).map(hex => Buffer.from(hex.slice(2), "hex"));
-  let chainIdTruncated = 0;
-  const rlpDecoded = decode(rlpData);
-
-  let decodedTx;
-  if (txType === 2) {
-    // EIP1559
-    decodedTx = {
-      data: rlpDecoded[7],
-      to: rlpDecoded[5],
-      chainId: rlpTx[0],
-    };
-  } else if (txType === 1) {
-    // EIP2930
-    decodedTx = {
-      data: rlpDecoded[6],
-      to: rlpDecoded[4],
-      chainId: rlpTx[0],
-    };
-  } else {
-    // Legacy tx
-    decodedTx = {
-      data: rlpDecoded[5],
-      to: rlpDecoded[3],
-      // Default to 1 for non EIP 155 txs
-      chainId: rlpTx.length > 6 ? rlpTx[6] : Buffer.from("01", "hex"),
-    };
-  }
-
-  const chainIdSrc = decodedTx.chainId;
-  let chainId = new BigNumber(0);
-  if (chainIdSrc) {
-    // Using BigNumber because chainID could be any uint256.
-    chainId = new BigNumber(chainIdSrc.toString("hex"), 16);
-    const chainIdTruncatedBuf = Buffer.alloc(4);
-    if (chainIdSrc.length > 4) {
-      chainIdSrc.copy(chainIdTruncatedBuf);
-    } else {
-      chainIdSrc.copy(chainIdTruncatedBuf, 4 - chainIdSrc.length);
-    }
-    chainIdTruncated = chainIdTruncatedBuf.readUInt32BE(0);
-  }
-
-  let vrsOffset = 0;
-  if (txType === null && rlpTx.length > 6) {
-    const rlpVrs = Buffer.from(encode(rlpTx.slice(-3)).slice(2), "hex");
-
-    vrsOffset = rawTx.length - (rlpVrs.length - 1);
-
-    // First byte > 0xf7 means the length of the list length doesn't fit in a single byte.
-    if (rlpVrs[0] > 0xf7) {
-      // Increment vrsOffset to account for that extra byte.
-      vrsOffset++;
-
-      // Compute size of the list length.
-      const sizeOfListLen = rlpVrs[0] - 0xf7;
-
-      // Increase rlpOffset by the size of the list length.
-      vrsOffset += sizeOfListLen - 1;
-    }
-  }
-
-  return {
-    decodedTx,
-    txType,
-    chainId,
-    chainIdTruncated,
-    vrsOffset,
-  };
-};
-
 /**
  * @ignore for the README
  *
@@ -156,3 +89,155 @@ export const mergeResolutions = (
 
   return mergedResolutions;
 };
+
+/**
+ * @ignore for the README
+ *
+ * Ledger devices are returning v with potentially EIP-155 already applied when using legacy transactions.
+ * Because that v value is only represented as a single byte, we need to replicate what would be the
+ * overflow happening on the device while applying EIP-155 and recover the original parity.
+ *
+ * @param vFromDevice
+ * @param chainIdUint32
+ * @returns
+ */
+export const getParity = (
+  vFromDevice: number,
+  chainId: BigNumber,
+  transactionType: Transaction["type"],
+): 0 | 1 => {
+  if (transactionType) return vFromDevice as 0 | 1;
+
+  // The device use a 4 bytes integer to represent the chainId and keeps the highest bytes
+  const chainIdUint32 = getChainIdAsUint32(chainId);
+
+  // Then applies EIP-155 to this chainId
+  const chainIdWithEIP155 = chainIdUint32 * 2 + 35;
+  // Since it's a single byte, we need to apply the overflow after reaching the max 0xff value and starting again to 0x00
+  // for both possible values, the chainId with EIP155 and a 0 or 1 parity included
+  const chainIdWithOverflowZero = chainIdWithEIP155 % 256;
+  const chainIdWithOverflowOne = (chainIdWithEIP155 + 1) % 256;
+
+  if (chainIdWithOverflowZero === vFromDevice) {
+    return 0;
+  } else if (chainIdWithOverflowOne === vFromDevice) {
+    return 1;
+  }
+  throw new Error("Invalid v value");
+};
+
+/**
+ * @ignore for the README
+ *
+ * Helper to convert a chainId from a BigNumber to a 4 bytes integer.
+ * ChainIds are uint256, but the device limits them to 4 bytes
+ *
+ * @param {Number|BigNumber} chainId
+ * @returns {Number}
+ */
+export const getChainIdAsUint32 = (chainId: BigNumber | number): number => {
+  const chainIdBuff = Buffer.from(padHexString(new BigNumber(chainId).toString(16)), "hex");
+  const chainIdUint32 = chainIdBuff.subarray(0, 4);
+
+  return parseInt(chainIdUint32.toString("hex"), 16);
+};
+
+/**
+ * @ignore for the README
+ *
+ * Depending on the transaction type you're trying to sign with the device, the v value will be different.
+ * For legacy transactions, the v value is used to store the chainId, and that chainId can be a uint256,
+ * and some math operation should be applied to it in order to comply with EIP-155 for replay attacks.
+ *
+ * In order to prevent breaking changes at the time, the `v` value has been kept as a single byte
+ * which forces us to replicate an overflow happening on the device to get the correct `v` value
+ *
+ * @param {number} vFromDevice
+ * @param {BigNumber} chainId
+ * @param {Transaction["type"]} transactionType
+ * @returns {string} hexa string of the v value
+ */
+export const getV = (
+  vFromDevice: number,
+  chainId: BigNumber,
+  transactionType: Transaction["type"],
+): string => {
+  if (chainId.isZero()) return vFromDevice.toString(16);
+
+  const parity = getParity(vFromDevice, chainId, transactionType);
+  return !transactionType
+    ? // Legacy transactions (type 0) should apply EIP-155
+      // EIP-155: rlp[(nonce, gasprice, startgas, to, value, data, chainid, 0, 0)]
+      padHexString(chainId.times(2).plus(35).plus(parity).toString(16))
+    : // Transactions after type 1 should only use partity (00/01) as their v value
+      // EIP-2930: 0x01 || rlp([chainId, nonce, gasPrice, gasLimit, to, value, data, accessList, *signatureYParity*, signatureR, signatureS])
+      // EIP-1559: 0x02 || rlp([chain_id, nonce, max_priority_fee_per_gas, max_fee_per_gas, gas_limit, destination, amount, data, access_list, *signature_y_parity*, signature_r, signature_s])
+      // EIP-4844: 0x03 || rlp([chain_id, nonce, max_priority_fee_per_gas, max_fee_per_gas, gas_limit, to, value, data, access_list, max_fee_per_blob_gas, blob_versioned_hashes, *y_parity*, r, s])
+      // EIP-7702: 0x05 || rlp([chain_id, nonce, max_priority_fee_per_gas, max_fee_per_gas, gas_limit, destination, value, data, access_list, authorization_list, *signature_y_parity*, signature_r, signature_s])
+      padHexString(parity.toString(16));
+};
+
+/**
+ * @ignore for the README
+ *
+ * In order to prevent the device from considering a transaction RLP as complete before it actually is
+ * we need to split the RLP into chunks which could not be mistaken for a complete transaction.
+ * This is true for legacy transaction, where the `v` value is used to store the chainId
+ *
+ * @param {Buffer} transactionRlp
+ * @param {Buffer }derivationPath
+ * @param {Transaction["type"]} transactionType
+ *
+ * @returns {Buffer[]}
+ */
+export const safeChunkTransaction = (
+  transactionRlp: Buffer,
+  derivationPath: Buffer,
+  transactionType: Transaction["type"],
+): Buffer[] => {
+  const maxChunkSize = 255;
+  // The full payload is the derivation path + the complete RLP of the transaction
+  const payload = Buffer.concat([derivationPath, transactionRlp]);
+  if (payload.length <= maxChunkSize) return [payload];
+
+  if (transactionType) {
+    const chunks = Math.ceil(payload.length / maxChunkSize);
+    return new Array(chunks)
+      .fill(null)
+      .map((_, i) => payload.subarray(i * maxChunkSize, (i + 1) * maxChunkSize));
+  }
+
+  // Decode the RLP of the full transaction and keep only the last 3 elements (v, r, s)
+  const decodedVrs: number[] = rlp.decode(transactionRlp).slice(-3);
+  // Encode those values back to RLP in order to get the length of this serialized list
+  // Result should be something like [0xc0 + list payload length, list.map(rlp)]
+  // since only v can be used to store the chainId in legacy transactions
+  const encodedVrs = rlp.encode(decodedVrs);
+  // Since chainIds are uint256, the list payload length can be 1B (v rlp description) + 32B (v) + 1B (r) + 1B (s) = 35B max (< 55B)
+  // Therefore, the RLP of this vrs list should be prefixed by a value between [0xc1, 0xe3] (0xc0 + 35B = 0xe3 max)
+  // @see https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/
+  // `encodedVrs` is then everything but the first byte of this serialization
+  const encodedVrsBuff = hexBuffer(encodedVrs).subarray(1);
+
+  // Since we want to avoid chunking just before the v,r,s values,
+  // we just check the size of that payload and detect
+  // if it would fit perfectly in 255B chunks
+  // if it does, we chunk smaller parts
+  let chunkSize = 0;
+  const lastChunkSize = payload.length % maxChunkSize;
+  if (lastChunkSize === 0 || lastChunkSize > encodedVrsBuff.length) {
+    chunkSize = maxChunkSize;
+  } else {
+    for (let i = 1; i <= maxChunkSize; i++) {
+      const lastChunkSize = payload.length % (maxChunkSize - i);
+      if (lastChunkSize === 0 || lastChunkSize > encodedVrsBuff.length) {
+        chunkSize = maxChunkSize - i;
+        break;
+      }
+    }
+  }
+  const chunks = Math.ceil(payload.length / chunkSize);
+  return new Array(chunks)
+    .fill(null)
+    .map((_, i) => payload.subarray(i * chunkSize, (i + 1) * chunkSize));
+};