@ledgerhq/live-common 31.2.0 → 31.3.0-next.0

package/src/families/ethereum/__tests__/hw-signMessage.test.ts

@@ -1,12 +1,14 @@
 import "../../../__tests__/test-helpers/setup";
 
-import { fail } from "assert";
-import type { EIP712Message } from "@ledgerhq/hw-app-eth/lib/modules/EIP712";
-import testEIP712Message from "@ledgerhq/hw-app-eth/tests/fixtures/messages/0.json";
-import { createFixtureCryptoCurrency } from "../../../mock/fixtures/cryptoCurrencies";
+import { AssertionError, fail } from "assert";
+import { EIP712Message } from "@ledgerhq/types-live";
 import { StatusCodes, TransportStatusError } from "@ledgerhq/errors";
+import testEIP712Message from "@ledgerhq/hw-app-eth/tests/fixtures/messages/0.json";
+import { createFixtureAccount } from "../../../mock/fixtures/cryptoCurrencies";
 import ethSign from "../hw-signMessage";
 
+const account = createFixtureAccount("17");
+
 const signPersonalMessage = jest.fn(() =>
   Promise.resolve({
     r: "r",
@@ -44,49 +46,35 @@ jest.mock("@ledgerhq/hw-app-eth", () => {
 describe("prepareMessageToSign", () => {
   it("returns a MessageData object when message to sign is a simple string", () => {
     // Given
-    const currency = createFixtureCryptoCurrency("ethereum");
-    const path = "44'/60'/0'/0/0";
-    const derivationMode = "ethM";
-    const message = "4d6573736167652064652074657374";
-    const expectedRawMessage = "0x4d6573736167652064652074657374";
+    const message = Buffer.from("4d6573736167652064652074657374", "hex").toString("utf-8");
 
     // When
-    const result = ethSign.prepareMessageToSign(currency, path, derivationMode, message);
+    const result = ethSign.prepareMessageToSign({ message });
 
     // Then
     expect(result).toEqual({
-      currency,
-      path: "44'/60'/0'/0/0",
-      derivationMode: "ethM",
+      standard: "EIP191",
       message: "Message de test",
-      rawMessage: expectedRawMessage,
     });
   });
 
   it("returns a TypedMessageData object when message to sign is an EIP712Message", () => {
     // Given
-    const currency = createFixtureCryptoCurrency("ethereum");
-    const path = "44'/60'/0'/0/0";
-    const derivationMode = "ethM";
     // testEIP712MessageHex
-    const message =
-      "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";
+    const message = Buffer.from(
+      "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",
+      "hex",
+    ).toString("utf-8");
 
     // When
-    const result = ethSign.prepareMessageToSign(currency, path, derivationMode, message);
+    const result = ethSign.prepareMessageToSign({ message });
 
     // Then
     expect(result).toEqual({
-      currency,
-      path,
-      derivationMode,
+      standard: "EIP712",
       message: testEIP712Message,
-      rawMessage: "0x" + message,
-      hashes: {
-        stringHash: "",
-        domainHash: "0x6137beb405d9ff777172aa879e33edb34a1460e701802746c5ef96e741710e59",
-        messageHash: "0x5476346eb09179b1f7d245c11a27ae6c498a419d7fad4d984d5b1e0ad081662a",
-      },
+      domainHash: "0x6137beb405d9ff777172aa879e33edb34a1460e701802746c5ef96e741710e59",
+      hashStruct: "0x5476346eb09179b1f7d245c11a27ae6c498a419d7fad4d984d5b1e0ad081662a",
     });
   });
 });
@@ -97,31 +85,44 @@ describe("Eth hw-signMessage", () => {
   });
 
   describe("parsing", () => {
+    it("should throw if the standard is not defined", async () => {
+      try {
+        await ethSign.signMessage({} as any, account, {
+          message: "test",
+        });
+        fail("Promise should have been rejected");
+      } catch (e) {
+        if (e instanceof AssertionError) {
+          throw e;
+        }
+        expect((e as Error).message).toEqual("Signature result is not defined");
+      }
+    });
+
     it("should be using the signPersonalMessage method with string message", async () => {
-      await ethSign.signMessage({} as any, {
-        path: "",
+      await ethSign.signMessage({} as any, account, {
+        standard: "EIP191",
         message: "test",
-        rawMessage: "0xtest",
       });
 
       expect(signPersonalMessage).toHaveBeenCalledTimes(1);
     });
 
-    it("should be using the signEIP712Message method with stringified message", async () => {
-      await ethSign.signMessage({} as any, {
-        path: "",
+    it("should be using the signPersonalMessage method with stringified EIP712 message", async () => {
+      await ethSign.signMessage({} as any, account, {
+        standard: "EIP191",
         message: JSON.stringify(testEIP712Message),
-        rawMessage: "0xtest",
       });
 
-      expect(signEIP712Message).toHaveBeenCalledTimes(1);
+      expect(signPersonalMessage).toHaveBeenCalledTimes(1);
     });
 
     it("should be using the signEIP712Message method with EIP712Message message", async () => {
-      await ethSign.signMessage({} as any, {
-        path: "",
+      await ethSign.signMessage({} as any, account, {
+        standard: "EIP712",
         message: testEIP712Message as EIP712Message,
-        rawMessage: "0xtest",
+        domainHash: "0x",
+        hashStruct: "0x",
       });
 
       expect(signEIP712Message).toHaveBeenCalledTimes(1);
@@ -130,30 +131,20 @@ describe("Eth hw-signMessage", () => {
 
   describe("value of v", () => {
     it("should returning parity for signPersonalMessage", async () => {
-      const { rsv } = await ethSign.signMessage({} as any, {
-        path: "",
+      const { rsv } = await ethSign.signMessage({} as any, account, {
+        standard: "EIP191",
         message: "test",
-        rawMessage: "0xtest",
-      });
-
-      expect(rsv.v).toBe(28);
-    });
-
-    it("should not be returning parity for signEIP712HashedMessage", async () => {
-      const { rsv } = await ethSign.signMessage({} as any, {
-        path: "",
-        message: JSON.stringify(testEIP712Message),
-        rawMessage: "0xtest",
       });
 
       expect(rsv.v).toBe(28);
     });
 
     it("should not be returning parity for signEIP712Message", async () => {
-      const { rsv } = await ethSign.signMessage({} as any, {
-        path: "",
+      const { rsv } = await ethSign.signMessage({} as any, account, {
+        standard: "EIP712",
         message: testEIP712Message,
-        rawMessage: "0xtest",
+        domainHash: "0xDontCare",
+        hashStruct: "0xDontCareEither",
       });
 
       expect(rsv.v).toBe(28);
@@ -170,10 +161,11 @@ describe("Eth hw-signMessage", () => {
         throw new TransportStatusError(StatusCodes.INS_NOT_SUPPORTED);
       });
 
-      await ethSign.signMessage({} as any, {
-        path: "",
+      await ethSign.signMessage({} as any, account, {
+        standard: "EIP712",
         message: testEIP712Message,
-        rawMessage: "0xtest",
+        domainHash: "0xDontCare",
+        hashStruct: "0xDontCareEither",
       });
 
       expect(signEIP712HashedMessage).toHaveBeenCalledTimes(1);
@@ -185,10 +177,11 @@ describe("Eth hw-signMessage", () => {
       });
 
       try {
-        await ethSign.signMessage({} as any, {
-          path: "",
+        await ethSign.signMessage({} as any, account, {
+          standard: "EIP712",
           message: testEIP712Message,
-          rawMessage: "0xtest",
+          domainHash: "0xDontCare",
+          hashStruct: "0xDontCareEither",
         });
       } catch (e) {
         return expect(signEIP712HashedMessage).not.toBeCalled();

package/src/families/ethereum/__tests__/modules/send.unit.test.ts

@@ -1,9 +1,12 @@
-import { makeAccount, makeTokenAccount } from "@ledgerhq/coin-evm/testUtils";
+import eip55 from "eip55";
+import BigNumber from "bignumber.js";
+import { getTokenById } from "@ledgerhq/cryptoassets/tokens";
+import {
+  makeAccount,
+  makeTokenAccount,
+} from "@ledgerhq/coin-evm/__tests__/fixtures/common.fixtures";
 import { encodeNftId } from "@ledgerhq/coin-framework/nft/nftId";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
-import { getTokenById } from "@ledgerhq/cryptoassets/tokens";
-import BigNumber from "bignumber.js";
-import eip55 from "eip55";
 import { modes } from "../../modules/send";
 import { Transaction } from "../../types";
 
@@ -16,7 +19,7 @@ enum NFT_CONTRACTS {
   ERC1155 = "0xd07dc4262bcdbf85190c01c996b4c06a461d2430",
 }
 
-const account = makeAccount("0x123", ethereum, [tokenAccount]);
+const account = { ...makeAccount("0x123", ethereum, [tokenAccount]) };
 account.nfts = [
   {
     amount: new BigNumber(1),

package/src/families/ethereum/__tests__/nft.unit.test.ts

@@ -1,18 +1,13 @@
 import { findCryptoCurrencyByTicker } from "@ledgerhq/cryptoassets";
 import "../../../__tests__/test-helpers/setup";
 import BigNumber from "bignumber.js";
+import { nftsFromOperations } from "@ledgerhq/coin-framework/nft/helpers";
 import { encodeAccountId, toNFTRaw } from "../../../account";
 import { ProtoNFT, Operation } from "@ledgerhq/types-live";
 import { mergeNfts } from "../../../bridge/jsHelpers";
-import {
-  encodeNftId,
-  getNftCapabilities,
-  isNFTActive,
-  isNftTransaction,
-  nftsFromOperations,
-} from "../../../nft";
 import { Transaction } from "../types";
 import { encodeERC1155OperationId } from "../../../nft/nftOperationId";
+import { encodeNftId, getNftCapabilities, isNFTActive, isNftTransaction } from "../../../nft";
 
 describe("nft merging", () => {
   const makeNFT = (tokenId: string, contract: string, amount: number): ProtoNFT => ({

package/src/families/ethereum/api/index.ts

@@ -117,15 +117,15 @@ export type API = {
     batchSize?: number,
     token?: string,
   ) => Promise<{ txs: Tx[]; nextPageToken: string | undefined }>;
-  getTransactionByHash: (hash: string) => Promise<Tx>;
   getCurrentBlock: () => Promise<Block>;
   getAccountNonce: (address: string) => Promise<number>;
+  getTransactionByHash: (hash: string) => Promise<Tx | undefined>;
   broadcastTransaction: (signedTransaction: string) => Promise<string>;
   getERC20Balances: (input: ERC20BalancesInput) => Promise<ERC20BalanceOutput>;
-  getNFTMetadata: (input: NFTMetadataInput, chainId: string) => Promise<NFTMetadataResponse[]>;
-  getNFTCollectionMetadata: (
+  getNftMetadata: (input: NFTMetadataInput, chainId: number) => Promise<NFTMetadataResponse[]>;
+  getNftCollectionMetadata: (
     input: NFTCollectionMetadataInput,
-    chainId: string,
+    chainId: number,
   ) => Promise<NFTCollectionMetadataResponse[]>;
   getAccountBalance: (address: string) => Promise<BigNumber>;
   getERC20ApprovalsPerContract: (
@@ -191,14 +191,6 @@ export const apiForCurrency = (currency: CryptoCurrency): API => {
       return { txs: txData.data.data, nextPageToken: txData.data.token };
     },
 
-    async getTransactionByHash(hash): Promise<Tx> {
-      const { data } = await network({
-        method: "GET",
-        url: `${baseURL}/tx/${hash}`,
-      });
-      return data;
-    },
-
     async getCurrentBlock(): Promise<Block> {
       const { data } = await network({
         method: "GET",
@@ -232,6 +224,14 @@ export const apiForCurrency = (currency: CryptoCurrency): API => {
       return data.result;
     },
 
+    async getTransactionByHash(hash): Promise<Tx | undefined> {
+      const { data } = await network({
+        method: "GET",
+        url: `${baseURL}/tx/${hash}`,
+      });
+      return data;
+    },
+
     async getAccountBalance(address): Promise<BigNumber> {
       const { data } = await network({
         method: "GET",
@@ -253,7 +253,7 @@ export const apiForCurrency = (currency: CryptoCurrency): API => {
       }));
     },
 
-    async getNFTMetadata(input, chainId): Promise<NFTMetadataResponse[]> {
+    async getNftMetadata(input, chainId): Promise<NFTMetadataResponse[]> {
       const { data }: { data: NFTMetadataResponse[] } = await network({
         method: "POST",
         url: `${getEnv("NFT_ETH_METADATA_SERVICE")}/v1/ethereum/${chainId}/contracts/tokens/infos`,
@@ -263,7 +263,7 @@ export const apiForCurrency = (currency: CryptoCurrency): API => {
       return data;
     },
 
-    async getNFTCollectionMetadata(input, chainId): Promise<NFTCollectionMetadataResponse[]> {
+    async getNftCollectionMetadata(input, chainId): Promise<NFTCollectionMetadataResponse[]> {
       const { data }: { data: NFTCollectionMetadataResponse[] } = await network({
         method: "POST",
         url: `${getEnv("NFT_ETH_METADATA_SERVICE")}/v1/ethereum/${chainId}/contracts/infos`,

package/src/families/ethereum/bridge/mock.ts

@@ -16,10 +16,12 @@ import {
   broadcast,
   sync,
   isInvalidRecipient,
+  makeAccountBridgeReceive,
 } from "../../../bridge/mockHelpers";
+import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { getGasLimit } from "../transaction";
-import { makeAccountBridgeReceive } from "../../../bridge/mockHelpers";
 import { inferDynamicRange } from "../../../range";
+
 const receive = makeAccountBridgeReceive();
 
 const defaultGetFees = (a, t: any) => (t.gasPrice || new BigNumber(0)).times(getGasLimit(t));
@@ -38,8 +40,6 @@ const createTransaction = (): Transaction => ({
   subAccountId: null,
 });
 
-const updateTransaction = (t, patch) => ({ ...t, ...patch });
-
 const estimateMaxSpendable = ({ account, parentAccount, transaction }) => {
   const mainAccount = getMainAccount(account, parentAccount);
   const estimatedFees = parentAccount
@@ -130,7 +130,7 @@ const prepareTransaction = async (a, t) => {
 
 const accountBridge: AccountBridge<Transaction> = {
   createTransaction,
-  updateTransaction,
+  updateTransaction: defaultUpdateTransaction,
   getTransactionStatus,
   estimateMaxSpendable,
   prepareTransaction,

package/src/families/ethereum/hw-signMessage.ts

@@ -1,19 +1,9 @@
-import Eth, { isEIP712Message } from "@ledgerhq/hw-app-eth";
-import type { EIP712Message } from "@ledgerhq/hw-app-eth/lib/modules/EIP712/EIP712.types";
-import { getFiltersForMessage } from "@ledgerhq/hw-app-eth";
-import Transport from "@ledgerhq/hw-transport";
+import Eth from "@ledgerhq/hw-app-eth";
 import { TypedDataUtils } from "eth-sig-util";
 import { bufferToHex } from "ethereumjs-util";
-import type { MessageData, Result } from "../../hw/signMessage/types";
-import type { TypedMessageData } from "./types";
-import { DerivationMode } from "@ledgerhq/coin-framework/derivation";
-import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import { getEnv } from "../../env";
-
-type EthSignMessage = (
-  transport: Transport,
-  message: Pick<MessageData | TypedMessageData, "path" | "message" | "rawMessage">,
-) => Promise<Result>;
+import { isEIP712Message } from "@ledgerhq/evm-tools/message/EIP712/index";
+import type { EIP712Message, TypedEvmMessage } from "@ledgerhq/types-live";
+import type { SignMessage } from "../../hw/signMessage/types";
 
 export const domainHash = (message: EIP712Message): Buffer => {
   return TypedDataUtils.hashStruct("EIP712Domain", message.domain, message.types, true);
@@ -26,7 +16,7 @@ function tryConvertToJSON(message: string): string | EIP712Message {
   try {
     const parsedMessage = JSON.parse(message);
     if (isEIP712Message(parsedMessage)) {
-      return parsedMessage as EIP712Message;
+      return parsedMessage;
     }
   } catch {
     // Not a JSON message
@@ -34,73 +24,48 @@ function tryConvertToJSON(message: string): string | EIP712Message {
   return message;
 }
 
-const prepareMessageToSign = (
-  currency: CryptoCurrency,
-  path: string,
-  derivationMode: DerivationMode,
-  message: string,
-): MessageData | TypedMessageData => {
-  const hexToStringMessage = Buffer.from(message, "hex").toString();
-  const parsedMessage = tryConvertToJSON(hexToStringMessage);
+const prepareMessageToSign = ({ message }: { message: string }): TypedEvmMessage => {
+  const parsedMessage = tryConvertToJSON(message);
 
-  const messageData = {
-    currency,
-    path,
-    derivationMode,
-    rawMessage: "0x" + message,
-  };
   if (typeof parsedMessage === "string") {
     return {
-      ...messageData,
+      standard: "EIP191",
       message: parsedMessage,
     };
   } else {
     return {
-      ...messageData,
+      standard: "EIP712",
       message: parsedMessage,
-      hashes: {
-        stringHash: "",
-        domainHash: bufferToHex(domainHash(parsedMessage)),
-        messageHash: bufferToHex(messageHash(parsedMessage)),
-      },
+      domainHash: bufferToHex(domainHash(parsedMessage)),
+      hashStruct: bufferToHex(messageHash(parsedMessage)),
     };
   }
 };
 
-type PartialMessageData = {
-  path: string;
-  message: string | EIP712Message;
-  rawMessage: string;
-};
-const signMessage: EthSignMessage = async (
-  transport: Transport,
-  { path, message, rawMessage }: PartialMessageData,
-) => {
+const signMessage: SignMessage = async (transport, account, messageData) => {
   const eth = new Eth(transport);
-  let parsedMessage = message;
-  if (typeof message === "string") {
-    parsedMessage = tryConvertToJSON(message);
-  }
 
-  let result: Awaited<ReturnType<typeof eth.signPersonalMessage>>;
-  if (typeof parsedMessage === "string") {
+  let result:
+    | {
+        v: number;
+        s: string;
+        r: string;
+      }
+    | undefined;
+  if (messageData.standard === "EIP191") {
     result = await eth.signPersonalMessage(
-      path,
-      rawMessage ? rawMessage?.slice(2) : Buffer.from(parsedMessage).toString("hex") || "",
+      account.freshAddressPath,
+      Buffer.from(messageData.message).toString("hex"),
     );
-  } else {
+  } else if (messageData.standard === "EIP712") {
     try {
-      result = await eth.signEIP712Message(path, parsedMessage);
+      result = await eth.signEIP712Message(account.freshAddressPath, messageData.message);
     } catch (e) {
-      if (
-        e instanceof Error &&
-        // @ts-expect-error TransportStatusError to be typed on ledgerjs
-        e.statusText === "INS_NOT_SUPPORTED"
-      ) {
+      if (e instanceof Error && "statusText" in e && e.statusText === "INS_NOT_SUPPORTED") {
         result = await eth.signEIP712HashedMessage(
-          path,
-          bufferToHex(domainHash(parsedMessage)),
-          bufferToHex(messageHash(parsedMessage)),
+          account.freshAddressPath,
+          messageData.domainHash,
+          messageData.hashStruct,
         );
       } else {
         throw e;
@@ -108,6 +73,8 @@ const signMessage: EthSignMessage = async (
     }
   }
 
+  if (!result) throw new Error("Signature result is not defined");
+
   let v = result.v.toString(16);
   if (v.length < 2) {
     v = "0" + v;
@@ -120,143 +87,6 @@ const signMessage: EthSignMessage = async (
   };
 };
 
-/**
- * Get the value at a specific path of an object and return it as a string or as an array of string
- * Used recursively by getValueFromPath
- *
- * @see getValueFromPath
- */
-const getValue = (
-  path: string,
-  value: Record<string, any> | Array<any> | string,
-): Record<string, any> | Array<any> | string => {
-  if (typeof value === "object") {
-    if (Array.isArray(value)) {
-      return value.map(v => getValue(path, v)).flat();
-    }
-
-    if (!Object.prototype.hasOwnProperty.call(value, path)) {
-      throw new Error();
-    }
-    const result = value[path];
-    return typeof result === "object" ? result : result.toString();
-  }
-
-  return value.toString();
-};
-
-/**
- * Using a path as a string, returns the value(s) of a json key without worrying about depth or arrays
- * (e.g: 'to.wallets.[]' => ["0x123", "0x456"])
- */
-const getValueFromPath = (path: string, eip721Message: EIP712Message): string | string[] => {
-  const splittedPath = path.split(".");
-  const { message } = eip721Message;
-
-  let value: any = message;
-  for (let i = 0; i <= splittedPath.length - 1; i++) {
-    const subPath = splittedPath[i];
-    const isLastElement = i >= splittedPath.length - 1;
-    if (subPath === "[]" && !isLastElement) continue;
-
-    value = getValue(subPath, value);
-  }
-
-  if (value === message) {
-    throw new Error();
-  }
-
-  return value as string | string[];
-};
-
-/**
- * Gets the fields visible on the nano for a specific EIP712 message
- */
-export const getNanoDisplayedInfosFor712 = async (
-  message: Record<string, any>,
-  remoteCryptoAssetsListURI: string = getEnv("DYNAMIC_CAL_BASE_URL"),
-): Promise<{ label: string; value: string | string[] }[] | null> => {
-  if (!isEIP712Message(message)) {
-    return null;
-  }
-
-  const displayedInfos: { label: string; value: string | string[] }[] = [];
-  const filters = await getFiltersForMessage(message, remoteCryptoAssetsListURI);
-
-  if (!filters) {
-    const { types } = message;
-    const domainFields = types["EIP712Domain"].map(({ name }) => name);
-
-    if (domainFields.includes("name") && message.domain.name) {
-      displayedInfos.push({
-        label: "name",
-        value: message.domain.name,
-      });
-    }
-
-    if (domainFields.includes("version") && message.domain.version) {
-      displayedInfos.push({
-        label: "version",
-        value: message.domain.version,
-      });
-    }
-
-    if (domainFields.includes("chainId") && message.domain.chainId) {
-      displayedInfos.push({
-        label: "chainId",
-        value: message.domain.chainId.toString(),
-      });
-    }
-
-    if (domainFields.includes("verifyingContract") && message.domain.verifyingContract) {
-      displayedInfos.push({
-        label: "verifyingContract",
-        value: message.domain.verifyingContract.toString(),
-      });
-    }
-
-    if (domainFields.includes("salt") && message.domain.salt) {
-      displayedInfos.push({
-        label: "salt",
-        value: message.domain.salt.toString(),
-      });
-    }
-
-    displayedInfos.push({
-      label: "Message hash",
-      value: "0x" + messageHash(message).toString("hex"),
-    });
-
-    return displayedInfos;
-  }
-
-  const { contractName, fields } = filters;
-  if (contractName && contractName.label) {
-    displayedInfos.push({
-      label: "Contract",
-      value: contractName.label,
-    });
-  }
-
-  if (message.domain.version) {
-    displayedInfos.push({
-      label: "version",
-      value: message.domain.version.toString(),
-    });
-  }
-
-  for (const field of fields) {
-    displayedInfos.push({
-      label: field.label,
-      value: getValueFromPath(field.path, message),
-    });
-  }
-
-  return displayedInfos;
-};
-
-export { isEIP712Message, getFiltersForMessage };
-
 export default {
   prepareMessageToSign,
   signMessage,

package/src/families/ethereum/modules/erc1155.ts

@@ -141,7 +141,7 @@ function serializeTransactionData(
   const from = eip55.encode(account.freshAddress);
   const to = eip55.encode(transaction.recipient);
   const tokenIds = transaction.tokenIds || [];
-  const quantities = transaction.quantities?.map(q => q?.toFixed() || "0") || [];
+  const quantities = transaction.quantities?.map(q => (q?.isFinite() ? q?.toFixed() : "0")) || [];
 
   return tokenIds?.length > 1
     ? abi.simpleEncode(

package/src/families/ethereum/modules/erc721.ts

@@ -19,13 +19,13 @@ export async function prepareTransaction(
   const { collection, collectionName, tokenIds } = transaction;
   if (collection && tokenIds && typeof collectionName === "undefined") {
     const api = apiForCurrency(account.currency);
-    const [{ status, result }] = await api.getNFTCollectionMetadata(
+    const [{ status, result }] = await api.getNftCollectionMetadata(
       [
         {
           contract: collection,
         },
       ],
-      account.currency?.ethereumLikeInfo?.chainId?.toString() || "1",
+      account.currency?.ethereumLikeInfo?.chainId ?? 1,
     );
     let collectionName = ""; // default value fallback if issue
     if (status === 200) {