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

package/src/load/speculos.ts

@@ -8,7 +8,8 @@ import { spawn, exec } from "child_process";
 import { promises as fsp } from "fs";
 import { log } from "@ledgerhq/logs";
 import type { DeviceModelId } from "@ledgerhq/devices";
-import SpeculosTransport from "@ledgerhq/hw-transport-node-speculos-http";
+import SpeculosTransportHttp from "@ledgerhq/hw-transport-node-speculos-http";
+import SpeculosTransportWebsocket from "@ledgerhq/hw-transport-node-speculos";
 import type { AppCandidate } from "@ledgerhq/coin-framework/bot/types";
 import { registerTransportModule } from "../hw";
 import { getEnv } from "../env";
@@ -18,7 +19,10 @@ import { formatAppCandidate } from "../bot/formatters";
 import { delay } from "../promise";
 import { mustUpgrade, shouldUpgrade } from "../apps";
 
+export type SpeculosTransport = SpeculosTransportHttp | SpeculosTransportWebsocket;
+
 let idCounter = getEnv("SPECULOS_PID_OFFSET");
+const isSpeculosWebsocket = getEnv("SPECULOS_USE_WEBSOCKET");
 
 const data = {};
 
@@ -70,6 +74,22 @@ function inferSDK(firmware: string, model: string): string | undefined {
   if (existingSdks.includes(begin + shortVersion + ".elf")) return shortVersion;
 }
 
+const getPorts = (idCounter: number, isSpeculosWebsocket?: boolean) => {
+  if (isSpeculosWebsocket) {
+    const apduPort = 30000 + idCounter;
+    const vncPort = 35000 + idCounter;
+    const buttonPort = 40000 + idCounter;
+    const automationPort = 45000 + idCounter;
+
+    return { apduPort, vncPort, buttonPort, automationPort };
+  } else {
+    const apiPort = 30000 + idCounter;
+    const vncPort = 35000 + idCounter;
+
+    return { apiPort, vncPort };
+  }
+};
+
 export async function createSpeculosDevice(
   arg: {
     model: DeviceModelId;
@@ -89,8 +109,7 @@ export async function createSpeculosDevice(
 }> {
   const { model, firmware, appName, appVersion, seed, coinapps, dependency } = arg;
   const speculosID = `speculosID-${++idCounter}`;
-  const apiPort = 30000 + idCounter;
-  const vncPort = 35000 + idCounter;
+  const ports = getPorts(idCounter, isSpeculosWebsocket);
 
   const sdk = inferSDK(firmware, model);
 
@@ -103,10 +122,18 @@ export async function createSpeculosDevice(
     "run",
     "-v",
     `${coinapps}:/speculos/apps`,
-    "-p",
-    `${apiPort}:40000`,
-    "-p",
-    `${vncPort}:41000`,
+    ...(isSpeculosWebsocket
+      ? [
+          "-p",
+          `${ports.apduPort}:40000`,
+          "-p",
+          `${ports.vncPort}:41000`,
+          "-p",
+          `${ports.buttonPort}:42000`,
+          "-p",
+          `${ports.automationPort}:43000`,
+        ]
+      : ["-p", `${ports.apiPort}:40000`, "-p", `${ports.vncPort}:41000`]),
     "-e",
     `SPECULOS_APPNAME=${appName}:${appVersion}`,
     "--name",
@@ -129,10 +156,18 @@ export async function createSpeculosDevice(
     "headless",
     "--vnc-password",
     "live",
-    "--api-port",
-    "40000",
-    "--vnc-port",
-    "41000",
+    ...(isSpeculosWebsocket
+      ? [
+          "--apdu-port",
+          "40000",
+          "--vnc-port",
+          "41000",
+          "--button-port",
+          "42000",
+          "--automation-port",
+          "43000",
+        ]
+      : ["--api-port", "40000", "--vnc-port", "41000"]),
   ];
 
   log("speculos", `${speculosID}: spawning = ${params.join(" ")}`);
@@ -208,15 +243,34 @@ export async function createSpeculosDevice(
     return createSpeculosDevice(arg, maxRetry - 1);
   }
 
-  const transport = await SpeculosTransport.open({
-    apiPort,
-  });
-  data[speculosID] = {
-    process: p,
-    apiPort,
-    transport,
-    destroy,
-  };
+  let transport: SpeculosTransport;
+  if (isSpeculosWebsocket) {
+    transport = await SpeculosTransportWebsocket.open({
+      apduPort: ports?.apduPort as number,
+      buttonPort: ports?.buttonPort as number,
+      automationPort: ports?.automationPort as number,
+    });
+
+    data[speculosID] = {
+      process: p,
+      apduPort: ports.apduPort as number,
+      buttonPort: ports.buttonPort as number,
+      automationPort: ports.automationPort as number,
+      transport,
+      destroy,
+    };
+  } else {
+    transport = await SpeculosTransportHttp.open({
+      apiPort: ports.apiPort?.toString(),
+    });
+
+    data[speculosID] = {
+      process: p,
+      apiPort: ports.apiPort?.toString(),
+      transport,
+      destroy,
+    };
+  }
   return {
     id: speculosID,
     transport,

package/src/manager/index.test.ts

@@ -1,5 +1,6 @@
 import manager from ".";
 import { lenseDevices } from "../__tests__/test-helpers/deviceInfos";
+
 test("firmwareUpdateNeedsLegacyBlueResetInstructions", () => {
   lenseDevices(["Blue211", "NanoS120", "NanoS142", "NanoS155", "NanoX1242rc5"]).forEach(
     ({ deviceInfo, modelId }) => {
@@ -34,3 +35,6 @@ test("firmwareUnsupported", () => {
     expect(manager.firmwareUnsupported(modelId, deviceInfo)).toBe(true);
   });
 });
+test("A terminated currency is still installable", () => {
+  expect(manager.canHandleInstall({ name: "Stratis" })).toBe(true);
+});

package/src/manager/index.ts

@@ -4,7 +4,6 @@ import semver from "semver";
 import chunk from "lodash/chunk";
 import type { DeviceModelId } from "@ledgerhq/devices";
 import { UnknownMCU } from "@ledgerhq/errors";
-import { listCryptoCurrencies } from "../currencies";
 import ManagerAPI from "./api";
 import { getProviderId } from "./provider";
 import type {
@@ -28,13 +27,7 @@ const oldAppsInstallDisabled = [
 ];
 
 const canHandleInstall = (app: { name: string }): boolean =>
-  !oldAppsInstallDisabled.includes(app.name) &&
-  !listCryptoCurrencies(true, true).some(
-    coin =>
-      coin.managerAppName &&
-      coin.terminated &&
-      coin.managerAppName.toLowerCase() === app.name.toLowerCase(),
-  );
+  !oldAppsInstallDisabled.includes(app.name);
 
 const CacheAPI = {
   // TODO: Move to new ManagerAPI

package/src/mock/account.ts

@@ -14,6 +14,7 @@ import { CosmosAccount } from "../families/cosmos/types";
 import { BitcoinAccount } from "../families/bitcoin/types";
 import { PolkadotAccount } from "@ledgerhq/coin-polkadot/types";
 import { TezosAccount } from "../families/tezos/types";
+import { TronAccount } from "../families/tron/types";
 
 /**
  * @memberof mock/account
@@ -81,6 +82,32 @@ export function genAccount(id: number | string, opts: GenAccountOptions = {}): A
             counter: 0,
           };
           break;
+        case "tron":
+          // TODO variation in these. you could use the account.name as a way to split cases
+          (account as TronAccount).tronResources = {
+            frozen: {
+              bandwidth: null,
+              energy: null,
+            },
+            delegatedFrozen: {
+              bandwidth: null,
+              energy: null,
+            },
+            votes: [],
+            tronPower: 0,
+            energy: BigNumber(0),
+            bandwidth: {
+              freeUsed: BigNumber(0),
+              freeLimit: BigNumber(1),
+              gainedUsed: BigNumber(0),
+              gainedLimit: BigNumber(0),
+            },
+            unwithdrawnReward: BigNumber(0),
+            lastWithdrawnRewardDate: null,
+            lastVotedDate: null,
+            cacheTransactionInfoById: {},
+          };
+          break;
         default: {
           try {
             const bridge = getAccountBridge(account);

package/src/nft/NftMetadataProvider/index.tsx

@@ -1,15 +1,20 @@
+import type {
+  NFT,
+  NFTCollectionMetadataResponse,
+  NFTMetadataResponse,
+  ProtoNFT,
+} from "@ledgerhq/types-live";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
 import React, { createContext, useContext, useMemo, useState, useEffect } from "react";
 import { getNftCollectionKey, getNftKey } from "../helpers";
+import { getCurrencyBridge } from "../../bridge";
+import { isOutdated } from "./logic";
 import {
   NFTMetadataContextAPI,
   NFTMetadataContextState,
   NFTMetadataContextType,
   NFTResource,
 } from "./types";
-import { isOutdated } from "./logic";
-import { getCurrencyBridge } from "../../bridge";
-import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
-import type { NFT, ProtoNFT } from "@ledgerhq/types-live";
 
 const NftMetadataContext = createContext<NFTMetadataContextType>({
   cache: {},
@@ -22,10 +27,10 @@ export function useNftMetadata(
   contract: string | undefined,
   tokenId: string | undefined,
   currencyId: string | undefined,
-): NFTResource {
+): NFTResource<NonNullable<NFTMetadataResponse["result"]>> {
   const { cache, loadNFTMetadata } = useContext(NftMetadataContext);
   const key = contract && tokenId && currencyId ? getNftKey(contract, tokenId, currencyId) : "";
-  const cachedData = cache[key];
+  const cachedData = cache[key] as NFTResource<NonNullable<NFTMetadataResponse["result"]>>;
 
   useEffect(() => {
     if (!contract || !tokenId || !currencyId) return;
@@ -46,11 +51,13 @@ export function useNftMetadata(
 export function useNftCollectionMetadata(
   contract: string | undefined,
   currencyId: string | undefined,
-): NFTResource {
+): NFTResource<NonNullable<NFTCollectionMetadataResponse["result"]>> {
   const { cache, loadCollectionMetadata } = useContext(NftMetadataContext);
   const key = contract && currencyId ? getNftCollectionKey(contract, currencyId) : "";
 
-  const cachedData = cache[key];
+  const cachedData = cache[key] as NFTResource<
+    NonNullable<NFTCollectionMetadataResponse["result"]>
+  >;
 
   useEffect(() => {
     if (!contract || !currencyId) return;
@@ -163,14 +170,17 @@ export function NftMetadataProvider({ children }: NFTMetadataProviderProps): Rea
                     status: "loaded",
                     metadata: result,
                     updatedAt: Date.now(),
-                  },
+                  } as NFTResource<NonNullable<NFTMetadataResponse["result"]>>,
                 },
               }));
               break;
             default:
               break;
           }
-        } catch (error) {
+        } catch (_error) {
+          // This shenanigan is here to avoid an Hermes bug https://github.com/pmndrs/zustand/discussions/1269
+          const error = new Error(_error ? (_error as Error).message : "Unknown Error");
+
           setState(oldState => ({
             ...oldState,
             cache: {
@@ -235,14 +245,17 @@ export function NftMetadataProvider({ children }: NFTMetadataProviderProps): Rea
                     status: "loaded",
                     metadata: result,
                     updatedAt: Date.now(),
-                  },
+                  } as NFTResource<NonNullable<NFTCollectionMetadataResponse["result"]>>,
                 },
               }));
               break;
             default:
               break;
           }
-        } catch (error) {
+        } catch (_error) {
+          // This shenanigan is here to avoid an Hermes bug https://github.com/pmndrs/zustand/discussions/1269
+          const error = new Error(_error ? (_error as Error).message : "Unknown Error");
+
           setState(oldState => ({
             ...oldState,
             cache: {

package/src/nft/NftMetadataProvider/types.ts

@@ -1,5 +1,9 @@
 import { NFTCollectionMetadataResponse, NFTMetadataResponse } from "@ledgerhq/types-live";
 
+type DefaultResource =
+  | NonNullable<NFTMetadataResponse["result"]>
+  | NonNullable<NFTCollectionMetadataResponse["result"]>;
+
 export type NFTResourceQueued = {
   status: "queued";
   metadata?: null;
@@ -12,9 +16,9 @@ export type NFTResourceLoading = {
   updatedAt?: undefined;
 };
 
-export type NFTResourceLoaded = {
+export type NFTResourceLoaded<T extends Record<string, unknown> = DefaultResource> = {
   status: "loaded";
-  metadata: NFTMetadataResponse["result"] | NFTCollectionMetadataResponse["result"];
+  metadata: T;
   updatedAt: number;
 };
 
@@ -31,15 +35,15 @@ export type NFTResourceNoData = {
   metadata?: null;
 };
 
-export type NFTResource =
+export type NFTResource<T extends Record<string, unknown> = DefaultResource> =
   | NFTResourceQueued
   | NFTResourceLoading
-  | NFTResourceLoaded
+  | NFTResourceLoaded<T>
   | NFTResourceError
   | NFTResourceNoData;
 
-export type NFTMetadataContextState = {
-  cache: Record<string, NFTResource>;
+export type NFTMetadataContextState<T extends Record<string, unknown> = DefaultResource> = {
+  cache: Record<string, NFTResource<T>>;
 };
 
 export type NFTMetadataContextAPI = {
@@ -48,7 +52,8 @@ export type NFTMetadataContextAPI = {
   clearCache: () => void;
 };
 
-export type NFTMetadataContextType = NFTMetadataContextState & NFTMetadataContextAPI;
+export type NFTMetadataContextType<T extends Record<string, unknown> = DefaultResource> =
+  NFTMetadataContextState<T> & NFTMetadataContextAPI;
 
 export type Batcher = {
   load: (

package/src/nft/helpers.ts

@@ -1,77 +1,6 @@
-import eip55 from "eip55";
-import BigNumber from "bignumber.js";
-import { encodeNftId } from "@ledgerhq/coin-framework/nft/nftId";
-import { decodeAccountId, groupAccountsOperationsByDay } from "../account";
-
-import type { Batch, BatchElement, Batcher } from "./NftMetadataProvider/types";
-import type {
-  NFTMetadataResponse,
-  Operation,
-  ProtoNFT,
-  NFT,
-  NFTCollectionMetadataResponse,
-  Account,
-} from "@ledgerhq/types-live";
-import { API, apiForCurrency } from "../families/ethereum/api";
-import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-
-export const nftsFromOperations = (ops: Operation[]): ProtoNFT[] => {
-  const nftsMap = ops
-    .slice(0)
-    // make sure we have the operation in chronological order (older first)
-    .sort((a, b) => a.date.getTime() - b.date.getTime())
-    // if ops are Operations get the prop nftOperations, else ops are considered nftOperations already
-    .flatMap(op => (op?.nftOperations?.length ? op.nftOperations : op))
-    .reduce((acc: Record<string, ProtoNFT>, nftOp: Operation) => {
-      let { contract } = nftOp;
-      if (!contract) {
-        return acc;
-      }
-
-      // Creating a "token for a contract" unique key
-      contract = eip55.encode(contract);
-      const { tokenId, standard, accountId } = nftOp;
-      const { currencyId } = decodeAccountId(nftOp.accountId);
-      if (!tokenId || !standard) return acc;
-      const id = encodeNftId(accountId, contract, tokenId, currencyId);
-
-      const nft = (acc[id] || {
-        id,
-        tokenId,
-        amount: new BigNumber(0),
-        contract,
-        standard,
-        currencyId,
-      }) as ProtoNFT;
-
-      if (nftOp.type === "NFT_IN") {
-        nft.amount = nft.amount.plus(nftOp.value);
-      } else if (nftOp.type === "NFT_OUT") {
-        const newAmount = nft.amount.minus(nftOp.value);
-
-        // In case of OpenSea lazy minting feature (minting an NFT off-chain)
-        // OpenSea will fire a false ERC1155 event saying that you sent an NFT
-        // from your account that you never received first.
-        //
-        // E.g.: I'm creating 10 ERC1155 on OpenSea. It's not going to create anything on-chain.
-        // Then I (bob) decide to transfer 5 to someone (kvn). OpenSea is going to mint the NFT in its
-        // collection (`OpenSea Shared Storefront` / `OpenSea Collections`) and transfer it to kvn.
-        // But the event fired by the Smart Contract is going to be `bob transfered 5 NFT to kvn` which is false.
-        // It would then result in bob have -5 NFTs since he never received them first.
-        // If kvn send 2 back to bob, based on the events we would think that bob has -3 NFTs.
-        //
-        // To mitigate that we put a minimum value of 0 when an account is transferring some NFTs.
-        nft.amount = newAmount.isNegative() ? new BigNumber(0) : newAmount;
-      }
-
-      acc[id] = nft;
-
-      return acc;
-    }, {});
-
-  // We reverse the array to make it from latest to oldest again
-  return Object.values(nftsMap).reverse();
-};
+import { getEnv } from "@ledgerhq/live-env";
+import { groupAccountsOperationsByDay } from "../account";
+import type { Operation, ProtoNFT, NFT, Account } from "@ledgerhq/types-live";
 
 /**
  * Helper to group NFTs by their collection/contract.
@@ -108,115 +37,15 @@ export const getNftCollectionKey = (contract: string, currencyId: string): strin
   return `${currencyId}-${contract}`;
 };
 
-/**
- * Factory to make a metadata API call batcher.
- *
- * It will wait for a complete `tick` to accumulate all the metadata requests
- * before sending it as one call to a given API.
- * Once the response is received, it will then spread the metadata to each request Promise,
- * just like if each request had been made separately.
- */
-const makeBatcher = (
-  call: API["getNFTMetadata"] | API["getNFTCollectionMetadata"],
-  chainId: number,
-): Batcher =>
-  (() => {
-    const queue: BatchElement[] = [];
-
-    let debounce;
-    const timeoutBatchCall = () => {
-      // Clear the previous scheduled call if it was existing
-      clearTimeout(debounce);
-
-      // Schedule a new call with the whole batch
-      debounce = setTimeout(() => {
-        // Seperate each batch element properties into arrays by type and index
-        const { elements, resolvers, rejecters } = queue.reduce(
-          (acc, { element, resolve, reject }) => {
-            acc.elements.push(element);
-            acc.resolvers.push(resolve);
-            acc.rejecters.push(reject);
-
-            return acc;
-          },
-          { elements: [], resolvers: [], rejecters: [] } as Batch,
-        );
-        // Empty the queue
-        queue.length = 0;
-
-        // Make the call with all the couples of contract and tokenId at once
-        call(elements, chainId.toString())
-          .then((res: any) => {
-            // Resolve each batch element with its own resolver and only its response
-            res.forEach((metadata, index) => resolvers[index](metadata));
-          })
-          .catch(err => {
-            // Reject all batch element with the error
-            rejecters.forEach(reject => reject(err));
-          });
-      });
-    };
-
-    return {
-      // Load the metadata for a given couple contract + tokenId
-      load(
-        element:
-          | {
-              contract: string;
-              tokenId: string;
-            }
-          | { contract: string },
-      ): Promise<NFTMetadataResponse | NFTCollectionMetadataResponse> {
-        return new Promise((resolve, reject) => {
-          queue.push({ element, resolve, reject });
-          timeoutBatchCall();
-        });
-      },
-    };
-  })();
-
-const batchersMap = new Map();
-
-/**
- * In order to `instanciate`/make only 1 batcher by currency,
- * they're `cached` in a Map and retrieved by this method
- * This method is still EVM based for now but can be improved
- * to implement an even more generic solution
- */
-export const metadataCallBatcher = (
-  currency: CryptoCurrency,
-): { loadNft: Batcher["load"]; loadCollection: Batcher["load"] } => {
-  const api: API = apiForCurrency(currency);
-  const chainId = currency?.ethereumLikeInfo?.chainId;
-
-  if (!chainId || !api) {
-    throw new Error("Ethereum: No API or chainId for this Currency");
-  }
-
-  if (!batchersMap.has(currency.id)) {
-    batchersMap.set(currency.id, {
-      nft: makeBatcher(api.getNFTMetadata, chainId),
-      collection: makeBatcher(api.getNFTCollectionMetadata, chainId),
-    });
-  }
-
-  const batchers = batchersMap.get(currency.id);
-  return {
-    loadNft: batchers.nft.load,
-    loadCollection: batchers.collection.load,
-  };
-};
-
 export const getNFT = (
-  contract?: string,
-  tokenId?: string,
-  nfts?: ProtoNFT[],
+  contract?: string | null | undefined,
+  tokenId?: string | null | undefined,
+  nfts?: ProtoNFT[] | null | undefined,
 ): ProtoNFT | undefined => nfts?.find(nft => nft.contract === contract && nft.tokenId === tokenId);
 
-const SUPPORTED_CURRENCIES = ["ethereum", "polygon"];
-
 export const groupByCurrency = (nfts: ProtoNFT[]): ProtoNFT[] => {
   const groupMap = new Map<string, ProtoNFT[]>();
+  const SUPPORTED_CURRENCIES = getEnv("NFT_CURRENCIES").split(",");
   SUPPORTED_CURRENCIES.forEach(elem => groupMap.set(elem, []));
 
   // GROUPING

package/src/nft/nftOperationId.ts

@@ -1,43 +1 @@
-export function encodeERC721OperationId(nftId: string, hash: string, type: string): string {
-  return `${nftId}-${hash}-${type}`;
-}
-
-export function decodeERC721OperationId(id: string): {
-  nftId: string;
-  hash: string;
-  type: string;
-} {
-  const [nftId, hash, type] = id.split("-");
-  return {
-    nftId,
-    hash,
-    type,
-  };
-}
-
-export function encodeERC1155OperationId(
-  nftId: string,
-  hash: string,
-  type: string,
-  i = 0,
-  j = 0,
-): string {
-  return `${nftId}-${hash}-${type}-i${i}_${j}`;
-}
-
-export function decodeERC1155OperationId(id: string): {
-  nftId: string;
-  hash: string;
-  type: string;
-  i: number;
-  j: number;
-} {
-  const [nftId, hash, type, i, j] = id.split("-");
-  return {
-    nftId,
-    hash,
-    type,
-    i: Number(i),
-    j: Number(j),
-  };
-}
+export * from "@ledgerhq/coin-framework/nft/nftOperationId";

package/src/nft/support.ts

@@ -1,33 +1,13 @@
 import { Transaction } from "../generated/types";
-import { getEnv } from "../env";
-import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import type { NFTStandard, ProtoNFT } from "@ledgerhq/types-live";
+
+export * from "@ledgerhq/coin-framework/nft/support";
 
 export const isNftTransaction = (transaction: Transaction | undefined | null): boolean => {
   if (transaction?.family === "ethereum") {
     return ["erc721.transfer", "erc1155.transfer"].includes(transaction?.mode);
+  } else if (transaction?.family === "evm") {
+    return ["erc721", "erc1155"].includes(transaction?.mode);
   }
 
   return false;
 };
-
-export function isNFTActive(currency: CryptoCurrency | undefined | null): boolean {
-  return getEnv("NFT_CURRENCIES").split(",").includes(currency?.id);
-}
-
-const nftCapabilities: Record<string, NFTStandard[]> = {
-  hasQuantity: ["ERC1155"],
-};
-
-type NFTCapabilty = keyof typeof nftCapabilities;
-
-export const getNftCapabilities = (
-  nft: ProtoNFT | undefined | null,
-): Record<NFTCapabilty, boolean> =>
-  (Object.entries(nftCapabilities) as [NFTCapabilty, NFTStandard[]][]).reduce(
-    (acc, [capability, standards]) => ({
-      ...acc,
-      [capability]: nft?.standard ? standards.includes(nft.standard) : false,
-    }),
-    {} as Record<NFTCapabilty, boolean>,
-  );

package/src/operation.ts

@@ -1,12 +1,8 @@
 import type { NFTStandard, Operation } from "@ledgerhq/types-live";
 import { decodeAccountId } from "./account";
 import { encodeNftId } from "@ledgerhq/coin-framework/nft/nftId";
-import { encodeERC1155OperationId, encodeERC721OperationId } from "./nft/nftOperationId";
 
-const nftOperationIdEncoderPerStandard: Record<NFTStandard, (...args: any[]) => string> = {
-  ERC721: encodeERC721OperationId,
-  ERC1155: encodeERC1155OperationId,
-};
+import { encodeERC1155OperationId, encodeERC721OperationId } from "./nft/nftOperationId";
 
 import {
   findOperationInAccount,
@@ -43,6 +39,11 @@ export {
   getStuckAccountAndOperation,
 };
 
+const nftOperationIdEncoderPerStandard: Record<NFTStandard, (...args: any[]) => string> = {
+  ERC721: encodeERC721OperationId,
+  ERC1155: encodeERC1155OperationId,
+};
+
 export function patchOperationWithHash(operation: Operation, hash: string): Operation {
   const commonOperation = commonPatchOperationWithHash(operation, hash);