@ledgerhq/coin-evm 0.3.0 → 0.4.0-next.0

package/src/datasets/ethereum1.ts

@@ -1,7 +1,9 @@
+/* istanbul ignore file: pure exports, test unecessary */
+
 import { AccountRaw } from "@ledgerhq/types-live";
 
 export const ethereum1: AccountRaw = {
-  id: "js:1:ethereum:0x0E3F0bb9516F01f2C34c25E0957518b8aC9414c5:",
+  id: "js:1:ethereum_as_evm_test_only:0x0E3F0bb9516F01f2C34c25E0957518b8aC9414c5:",
   seedIdentifier: "0x0E3F0bb9516F01f2C34c25E0957518b8aC9414c5",
   name: "Ethereum legacy xpub6Bem...JyAdpYZy",
   derivationMode: "",
@@ -11,7 +13,7 @@ export const ethereum1: AccountRaw = {
   freshAddresses: [],
   pendingOperations: [],
   operations: [],
-  currencyId: "ethereum",
+  currencyId: "ethereum_as_evm_test_only",
   unitMagnitude: 18,
   balance: "",
   blockHeight: 0,

package/src/deviceTransactionConfig.ts

@@ -51,6 +51,71 @@ function getDeviceTransactionConfig({
         },
       );
       break;
+
+    case "erc721":
+      fields.push(
+        {
+          type: "text",
+          label: "Type",
+          value: `NFT Transfer`,
+        },
+        {
+          type: "text",
+          label: "To",
+          value: transaction.recipient,
+        },
+        {
+          type: "text",
+          label: "Collection Name",
+          value: transaction.nft.collectionName,
+        },
+        {
+          type: "address",
+          label: "NFT Address",
+          address: transaction.nft.contract,
+        },
+        {
+          type: "text",
+          label: "NFT ID",
+          value: transaction.nft.tokenId,
+        },
+      );
+      break;
+
+    case "erc1155":
+      fields.push(
+        {
+          type: "text",
+          label: "Type",
+          value: `NFT Transfer`,
+        },
+        {
+          type: "text",
+          label: "To",
+          value: transaction.recipient,
+        },
+        {
+          type: "text",
+          label: "Collection Name",
+          value: transaction.nft.collectionName,
+        },
+        {
+          type: "text",
+          label: "Quantity",
+          value: transaction.nft.quantity.toFixed(),
+        },
+        {
+          type: "address",
+          label: "NFT Address",
+          address: transaction.nft.contract,
+        },
+        {
+          type: "text",
+          label: "NFT ID",
+          value: transaction.nft.tokenId,
+        },
+      );
+      break;
   }
 
   fields.push({

package/src/errors.ts

@@ -1,6 +1,9 @@
 import { createCustomErrorClass } from "@ledgerhq/errors";
 
+// Etherscan API
 export const EtherscanAPIError = createCustomErrorClass("EtherscanAPIError");
+
+// Gas
 export const GasEstimationError = createCustomErrorClass("GasEstimationError");
 export const InsufficientFunds = createCustomErrorClass("InsufficientFunds");
 
@@ -9,3 +12,8 @@ export const NoGasTrackerFound = createCustomErrorClass("NoGasTrackerFound");
 export const GasTrackerDoesNotSupportEIP1559 = createCustomErrorClass(
   "GasTrackerDoesNotSupportEIP1559",
 );
+
+// Nfts
+export const NotOwnedNft = createCustomErrorClass("NotOwnedNft");
+export const NotEnoughNftOwned = createCustomErrorClass("NotEnoughNftOwned");
+export const QuantityNeedsToBePositive = createCustomErrorClass("QuantityNeedsToBePositive");

package/src/getTransactionStatus.ts

@@ -19,6 +19,7 @@ import {
   EvmTransactionLegacy,
   Transaction as EvmTransaction,
 } from "./types";
+import { NotEnoughNftOwned, NotOwnedNft, QuantityNeedsToBePositive } from "./errors";
 
 type ValidatedTransactionFields =
   | "recipient"
@@ -131,6 +132,28 @@ export const validateGas = (
   return [errors, warnings];
 };
 
+export const validateNft = (account: Account, tx: EvmTransaction): Array<ValidationIssues> => {
+  if (!tx.nft) return [{}, {}];
+
+  const errors: ValidationIssues = {};
+  const warnings: ValidationIssues = {};
+
+  const quantityIsPositive = tx.nft.quantity.gt(0);
+  const nftFromAccount = account.nfts?.find(
+    nft => nft.tokenId === tx.nft.tokenId && nft.contract === tx.nft.contract,
+  );
+
+  if (!nftFromAccount) {
+    errors.amount = new NotOwnedNft();
+  } else if (!quantityIsPositive) {
+    errors.amount = new QuantityNeedsToBePositive();
+  } else if (nftFromAccount.amount.lt(tx.nft.quantity)) {
+    errors.amount = new NotEnoughNftOwned();
+  }
+
+  return [errors, warnings];
+};
+
 /**
  * Validate a transaction and get all possibles errors and warnings about it
  */
@@ -151,16 +174,19 @@ export const getTransactionStatus: AccountBridge<EvmTransaction>["getTransaction
   const [amountErr, amountWarn] = validateAmount(subAccount || account, tx, totalSpent);
   // Gas related errors and warnings
   const [gasErr, gasWarn] = validateGas(account, tx, gasLimit, totalFees);
+  const [nftErr, nftWarn] = validateNft(account, tx);
 
   const errors: ValidationIssues = {
     ...recipientErr,
     ...gasErr,
     ...amountErr,
+    ...nftErr,
   };
   const warnings: ValidationIssues = {
     ...recipientWarn,
     ...gasWarn,
     ...amountWarn,
+    ...nftWarn,
   };
 
   return {

package/src/hw-signMessage.ts

@@ -0,0 +1,92 @@
+import { ethers } from "ethers";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { isEIP712Message } from "@ledgerhq/evm-tools/message/EIP712/index";
+import { Account, AnyMessage, DeviceId, TypedEvmMessage } from "@ledgerhq/types-live";
+import { EvmSignature, EvmSigner } from "./signer";
+
+export const prepareMessageToSign = ({ message }: { message: string }): TypedEvmMessage => {
+  const parsedMessage = (() => {
+    try {
+      return JSON.parse(message) as Record<string, unknown>;
+    } catch (error) {
+      return message;
+    }
+  })();
+
+  if (isEIP712Message(parsedMessage)) {
+    // With the ethers lib, EIP712Domain type should be removed otherwise
+    // you'll end up with a "ambiguous primary types" error
+    const { EIP712Domain, ...otherTypes } = parsedMessage.types;
+
+    return {
+      standard: "EIP712",
+      message: parsedMessage,
+      domainHash: ethers.utils._TypedDataEncoder.hashDomain(parsedMessage.domain),
+      hashStruct: ethers.utils._TypedDataEncoder.hashStruct(
+        parsedMessage.primaryType,
+        otherTypes,
+        parsedMessage.message,
+      ),
+    };
+  }
+
+  return {
+    standard: "EIP191",
+    message,
+  };
+};
+
+export const signMessage =
+  (signerContext: SignerContext<EvmSigner, EvmSignature>) =>
+  async (
+    deviceId: DeviceId,
+    account: Account,
+    messageOpts: AnyMessage,
+  ): Promise<{
+    rsv: { r: string; s: string; v: string | number };
+    signature: string;
+  }> => {
+    if (messageOpts.standard === "EIP191") {
+      const { r, s, v } = await signerContext(deviceId, signer => {
+        return signer.signPersonalMessage(
+          account.freshAddressPath,
+          Buffer.from(messageOpts.message).toString("hex"),
+        );
+      });
+
+      const signature = ethers.utils.joinSignature({
+        r: `0x${r}`,
+        s: `0x${s}`,
+        v: typeof v === "string" ? parseInt(v, 16) : v,
+      });
+
+      return { rsv: { r, s, v }, signature };
+    }
+
+    if (messageOpts.standard === "EIP712") {
+      const { r, s, v } = await signerContext(deviceId, async signer => {
+        try {
+          return await signer.signEIP712Message(account.freshAddressPath, messageOpts.message);
+        } catch (e) {
+          if (e instanceof Error && "statusText" in e && e.statusText === "INS_NOT_SUPPORTED") {
+            return await signer.signEIP712HashedMessage(
+              account.freshAddressPath,
+              messageOpts.domainHash,
+              messageOpts.hashStruct,
+            );
+          }
+          throw e;
+        }
+      });
+
+      const signature = ethers.utils.joinSignature({
+        r: `0x${r}`,
+        s: `0x${s}`,
+        v: typeof v === "string" ? parseInt(v, 16) : v,
+      });
+
+      return { rsv: { r, s, v }, signature };
+    }
+
+    throw new Error("Unsupported message standard");
+  };

package/src/logic.ts

@@ -1,11 +1,15 @@
 import { ethers } from "ethers";
 import BigNumber from "bignumber.js";
 import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { isNFTActive } from "@ledgerhq/coin-framework/nft/support";
 import { mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
-import { Account, SubAccount } from "@ledgerhq/types-live";
+import { Account, SubAccount, Operation } from "@ledgerhq/types-live";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
 import { listTokensForCryptoCurrency } from "@ledgerhq/cryptoassets/tokens";
+import { decodeTokenAccountId } from "@ledgerhq/coin-framework/account/index";
 import { getOptimismAdditionalFees } from "./api/rpc/rpc.common";
 import {
+  EvmNftTransaction,
   Transaction as EvmTransaction,
   EvmTransactionEIP1559,
   EvmTransactionLegacy,
@@ -128,12 +132,124 @@ export const mergeSubAccounts = (
 /**
  * Method creating a hash that will help triggering or not a full synchronization on an account.
  * As of now, it's checking if a token has been added, removed of changed regarding important properties
+ * and if the NFTs are activated/supported on this chain
  */
 export const getSyncHash = (currency: CryptoCurrency): string => {
   const tokens = listTokensForCryptoCurrency(currency);
   const basicTokensListString = tokens
     .map(token => token.id + token.contractAddress + token.name + token.ticker + token.delisted)
     .join("");
+  const isNftSupported = isNFTActive(currency);
 
-  return ethers.utils.sha256(Buffer.from(basicTokensListString));
+  return ethers.utils.sha256(Buffer.from(basicTokensListString + isNftSupported));
 };
+
+/**
+ * Helper in charge of linking operations together based on transaction hash.
+ * Token operations & NFT operations are the result of a coin operation
+ * and if this coin operation is originated by our user we want
+ * to link those operations together as main & children ops.
+ *
+ * A sub operation should always be linked to a coin operation,
+ * even if the user isn't at the origin of the sub op.
+ * "NONE" coin ops can be added when necessary.
+ *
+ * ⚠️ If an NFT operation was found without a coin parent op
+ * just like if it was not initiated by the synced account
+ * and we were to find that coin op during another sync,
+ * the NONE operation created would not be removed,
+ * creating a duplicate that will cause issues.
+ * (Incorrect NFT balance & React key dup)
+ */
+export const attachOperations = (
+  _coinOperations: Operation[],
+  _tokenOperations: Operation[],
+  _nftOperations: Operation[],
+): Operation[] => {
+  // Creating deep copies of each Operation[] to prevent mutating the originals
+  const coinOperations = _coinOperations.map(op => ({ ...op }));
+  const tokenOperations = _tokenOperations.map(op => ({ ...op }));
+  const nftOperations = _nftOperations.map(op => ({ ...op }));
+
+  type OperationWithRequiredChildren = Operation &
+    Required<Pick<Operation, "nftOperations" | "subOperations">>;
+
+  // Helper to create a coin operation with type NONE as a parent of an orphan child operation
+  const makeCoinOpForOrphanChildOp = (childOp: Operation): OperationWithRequiredChildren => {
+    const type = "NONE";
+    const { accountId } = decodeTokenAccountId(childOp.accountId);
+    const id = encodeOperationId(accountId, childOp.hash, type);
+
+    return {
+      id,
+      hash: childOp.hash,
+      type,
+      value: new BigNumber(0),
+      fee: new BigNumber(0),
+      senders: [],
+      recipients: [],
+      blockHeight: childOp.blockHeight,
+      blockHash: childOp.blockHash,
+      transactionSequenceNumber: childOp.transactionSequenceNumber,
+      subOperations: [],
+      nftOperations: [],
+      accountId: "",
+      date: childOp.date,
+      extra: {},
+    };
+  };
+
+  // Create a Map of hash => operation
+  const coinOperationsByHash: Record<string, OperationWithRequiredChildren[]> = {};
+  coinOperations.forEach(op => {
+    if (!coinOperationsByHash[op.hash]) {
+      coinOperationsByHash[op.hash] = [];
+    }
+
+    // Adding arrays just in case but this is defined
+    // by the adapters so it should never be needed
+    op.subOperations = [];
+    op.nftOperations = [];
+    coinOperationsByHash[op.hash].push(op as OperationWithRequiredChildren);
+  });
+
+  // Looping through token operations to potentially copy them as a child operation of a coin operation
+  for (const tokenOperation of tokenOperations) {
+    let mainOperations = coinOperationsByHash[tokenOperation.hash];
+    if (!mainOperations?.length) {
+      const noneOperation = makeCoinOpForOrphanChildOp(tokenOperation);
+      mainOperations = [noneOperation];
+      coinOperations.push(noneOperation);
+    }
+
+    // Ugly loop in loop but in theory, this can only be a 2 elements array maximum in the case of a self send
+    for (const mainOperation of mainOperations) {
+      mainOperation.subOperations.push(tokenOperation);
+    }
+  }
+
+  // Looping through nft operations to potentially copy them as a child operation of a coin operation
+  for (const nftOperation of nftOperations) {
+    let mainOperations = coinOperationsByHash[nftOperation.hash];
+    if (!mainOperations?.length) {
+      const noneOperation = makeCoinOpForOrphanChildOp(nftOperation);
+      mainOperations = [noneOperation];
+      coinOperations.push(noneOperation);
+    }
+
+    // Ugly loop in loop but in theory, this can only be a 2 elements array maximum in the case of a self send
+    for (const mainOperation of mainOperations) {
+      mainOperation.nftOperations.push(nftOperation);
+    }
+  }
+
+  return coinOperations;
+};
+
+/**
+ * Type guard for NFT transactions
+ */
+export const isNftTransaction = (
+  transaction: EvmTransaction,
+): transaction is EvmTransaction & EvmNftTransaction =>
+  ["erc1155", "erc721"].includes(transaction.mode);

package/src/nftResolvers.ts

@@ -0,0 +1,71 @@
+import {
+  CurrencyBridge,
+  NFTCollectionMetadataResponse,
+  NFTMetadataResponse,
+} from "@ledgerhq/types-live";
+import { isNFTActive, metadataCallBatcher } from "@ledgerhq/coin-framework/nft/support";
+import { getCryptoCurrencyById } from "@ledgerhq/coin-framework/currencies/index";
+import NftApi from "./api/nft";
+
+type NftResolvers = NonNullable<CurrencyBridge["nftResolvers"]>;
+
+export const nftMetadata: NftResolvers["nftMetadata"] = async ({
+  contract,
+  tokenId,
+  currencyId,
+  metadata,
+}): Promise<NFTMetadataResponse> => {
+  // This is for test/mock purposes
+  if (typeof metadata !== "undefined") {
+    return {
+      status: 200,
+      result: {
+        contract,
+        tokenId,
+        ...metadata,
+      },
+    } as NFTMetadataResponse;
+  }
+
+  const currency = getCryptoCurrencyById(currencyId);
+  if (!isNFTActive(currency)) {
+    throw new Error("Ethereum Bridge NFT Resolver: Unsupported currency");
+  }
+
+  const response = await metadataCallBatcher(currency, NftApi).loadNft({
+    contract,
+    tokenId,
+  });
+
+  return response;
+};
+
+export const collectionMetadata: NftResolvers["collectionMetadata"] = async ({
+  contract,
+  currencyId,
+  metadata,
+}): Promise<NFTCollectionMetadataResponse> => {
+  // This is for test/mock purposes
+  if (typeof metadata !== "undefined") {
+    return {
+      status: 200,
+      result: {
+        contract,
+        ...metadata,
+      },
+    };
+  }
+
+  const currency = getCryptoCurrencyById(currencyId);
+  if (!isNFTActive(currency)) {
+    throw new Error("Ethereum Bridge NFT Resolver: Unsupported currency");
+  }
+
+  const response = await metadataCallBatcher(currency, NftApi).loadCollection({
+    contract,
+  });
+
+  return response;
+};
+
+export default { nftMetadata, collectionMetadata };

package/src/preload.ts

@@ -23,8 +23,9 @@ export const fetchERC20Tokens: (
     });
   if (dynamicTokens) return dynamicTokens;
 
-  // @ts-expect-error FIXME: fix typings
-  const tokens = tokensByChainId[ethereumLikeInfo?.chainId || ""];
+  const tokens = tokensByChainId[
+    ethereumLikeInfo?.chainId as keyof typeof tokensByChainId
+  ] as ERC20Token[];
   if (tokens) return tokens;
 
   log("warning", `EVM Family: No tokens found in CAL for currency: ${currency.id}`, currency);
@@ -33,7 +34,12 @@ export const fetchERC20Tokens: (
 
 export async function preload(currency: CryptoCurrency): Promise<ERC20Token[]> {
   const erc20 = await fetchERC20Tokens(currency);
-  addTokens(erc20.map(convertERC20));
+  // This weird thing is here to help the "clone" currencies like
+  // ethereum_as_evm_test_only & polygon_as_evm_test_only
+  // to get tokens despite the different currency_id
+  // registered in the CAL for those chain ids
+  // We should remove this after the merge
+  addTokens(erc20.map(([, ...tokenRest]) => convertERC20([currency.id, ...tokenRest])));
   return erc20;
 }
 

package/src/prepareTransaction.ts

@@ -1,11 +1,13 @@
-import { findSubAccountById } from "@ledgerhq/coin-framework/account/index";
-import { Account, TokenAccount } from "@ledgerhq/types-live";
+import { isEqual } from "lodash";
 import BigNumber from "bignumber.js";
-import { getFeesEstimation, getGasEstimation, getTransactionCount } from "./api/rpc";
-import { validateRecipient } from "./getTransactionStatus";
-import { getAdditionalLayer2Fees, getEstimatedFees } from "./logic";
+import { Account, TokenAccount } from "@ledgerhq/types-live";
+import { findSubAccountById } from "@ledgerhq/coin-framework/account/index";
+import { EvmNftTransaction, Transaction as EvmTransaction } from "./types";
 import { getTransactionData, getTypedTransaction } from "./transaction";
-import { Transaction as EvmTransaction } from "./types";
+import { validateRecipient } from "./getTransactionStatus";
+import { getNftCollectionMetadata } from "./api/nft";
+import { getFeesEstimation, getGasEstimation, getTransactionCount } from "./api/rpc";
+import { getAdditionalLayer2Fees, getEstimatedFees, isNftTransaction } from "./logic";
 
 /**
  * Prepare basic coin transactions or smart contract interactions (other than live ERC20 transfers)
@@ -76,8 +78,9 @@ export const prepareTokenTransaction = async (
 ): Promise<EvmTransaction> => {
   const [recipientErrors] = validateRecipient(account, typedTransaction);
   const amount = typedTransaction.useAllAmount ? tokenAccount.balance : typedTransaction.amount;
+
   const data = !Object.keys(recipientErrors).length
-    ? getTransactionData({ ...typedTransaction, amount })
+    ? getTransactionData(account, { ...typedTransaction, amount })
     : undefined;
   // As we're interacting with a smart contract,
   // it's going to be the real recipient for the tx
@@ -99,6 +102,7 @@ export const prepareTokenTransaction = async (
 
   // Recipient isn't changed here as it would change on the UI end as well
   // The change will be handled by the `prepareForSignOperation` method
+  // right before the device signature by the signOperation step
   return {
     ...typedTransaction,
     amount,
@@ -108,6 +112,61 @@ export const prepareTokenTransaction = async (
   };
 };
 
+/**
+ * Prepare ERC721/ERC1155 transactions.
+ * Handling addition of NFT safeTransferFrom data and gas limit
+ */
+export const prepareNftTransaction = async (
+  account: Account,
+  typedTransaction: EvmNftTransaction & EvmTransaction,
+): Promise<EvmTransaction> => {
+  const { currency } = account;
+  const [recipientErrors] = validateRecipient(account, typedTransaction);
+
+  const data = !Object.keys(recipientErrors).length
+    ? getTransactionData(account, typedTransaction)
+    : undefined;
+  // As we're interacting with a smart contract,
+  // it's going to be the real recipient for the tx
+  const gasLimit = data
+    ? await getGasEstimation(account, {
+        ...typedTransaction,
+        amount: new BigNumber(0), // amount set to 0 as we're interacting with a smart contract
+        recipient: typedTransaction.nft.contract, // recipient is then the nft smart contract
+        data, // buffer containing the calldata bytecode
+      }).catch(() => new BigNumber(0)) // this catch returning 0 should be handled by the `getTransactionStatus` method
+    : new BigNumber(0);
+  const additionalFees = await getAdditionalLayer2Fees(account.currency, {
+    ...typedTransaction,
+    amount: new BigNumber(0), // amount set to 0 as we're interacting with a smart contract
+    recipient: typedTransaction.nft.contract, // recipient is then the token smart contract
+    data, // buffer containing the calldata bytecode
+    gasLimit,
+  });
+
+  // Providing the collection name to the transaction for the
+  // deviceTransactionConfig step (so purely UI)
+  const [collectionMetadata] = await getNftCollectionMetadata(
+    [{ contract: typedTransaction.nft.contract }],
+    currency?.ethereumLikeInfo?.chainId || 0,
+  );
+  const nft = {
+    ...typedTransaction.nft,
+    collectionName: collectionMetadata.result?.tokenName || "",
+  };
+
+  // Recipient isn't changed here as it would change on the UI end as well
+  // The change will be handled by the `prepareForSignOperation` method
+  // right before the device signature by the signOperation step
+  return {
+    ...typedTransaction,
+    data,
+    gasLimit,
+    additionalFees,
+    nft,
+  };
+};
+
 /**
  * Method called to update a transaction into a state that would make it valid
  * (E.g. Adding fees, add smart contract data, etc...)
@@ -137,12 +196,20 @@ export const prepareTransaction = async (
   })();
 
   const subAccount = findSubAccountById(account, transaction.subAccountId || "");
-  const isTokenTransaction = subAccount?.type === "TokenAccount";
   const typedTransaction = getTypedTransaction(transaction, feeData);
 
-  return isTokenTransaction
-    ? await prepareTokenTransaction(account, subAccount, typedTransaction)
-    : await prepareCoinTransaction(account, typedTransaction);
+  const newTransaction = await (() => {
+    if (isNftTransaction(typedTransaction)) {
+      return prepareNftTransaction(account, typedTransaction);
+    }
+    const isTokenTransaction = subAccount?.type === "TokenAccount";
+    return isTokenTransaction
+      ? prepareTokenTransaction(account, subAccount, typedTransaction)
+      : prepareCoinTransaction(account, typedTransaction);
+  })();
+
+  // maintaining reference if the transaction hasn't change
+  return isEqual(transaction, newTransaction) ? transaction : newTransaction;
 };
 
 /**
@@ -157,19 +224,30 @@ export const prepareForSignOperation = async (
 ): Promise<EvmTransaction> => {
   const nonce = await getTransactionCount(account.currency, account.freshAddress);
 
-  const subAccount = findSubAccountById(account, transaction.subAccountId || "");
+  if (isNftTransaction(transaction)) {
+    return {
+      ...transaction,
+      amount: new BigNumber(0), // amount set to 0 as we're interacting with a smart contract
+      recipient: transaction.nft.contract, // recipient is then the NFT smart contract
+      // data as already been added by the `prepareTokenTransaction` method
+      nonce,
+    };
+  }
+
+  const subAccount = findSubAccountById(account, transaction.subAccountId ?? "");
   const isTokenTransaction = subAccount?.type === "TokenAccount";
+  if (isTokenTransaction) {
+    return {
+      ...transaction,
+      amount: new BigNumber(0), // amount set to 0 as we're interacting with a smart contract
+      recipient: subAccount.token.contractAddress, // recipient is then the token smart contract
+      // data as already been added by the `prepareTokenTransaction` method
+      nonce,
+    };
+  }
 
-  return isTokenTransaction
-    ? {
-        ...transaction,
-        amount: new BigNumber(0), // amount set to 0 as we're interacting with a smart contract
-        recipient: subAccount.token.contractAddress, // recipient is then the token smart contract
-        // data as already been added by the `prepareTokenTransaction` method
-        nonce,
-      }
-    : {
-        ...transaction,
-        nonce,
-      };
+  return {
+    ...transaction,
+    nonce,
+  };
 };