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

package/src/signOperation.ts

@@ -1,18 +1,20 @@
-import { Observable } from "rxjs";
 import {
   Account,
   SignOperationFnSignature,
   SignOperationEvent,
   DeviceId,
 } from "@ledgerhq/types-live";
+import { Observable } from "rxjs";
+import { getEnv } from "@ledgerhq/live-env";
 import { ledgerService } from "@ledgerhq/hw-app-eth";
-import { ResolutionConfig } from "@ledgerhq/hw-app-eth/lib/services/types";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { isNFTActive } from "@ledgerhq/coin-framework/nft/support";
+import { LoadConfig, ResolutionConfig } from "@ledgerhq/hw-app-eth/lib/services/types";
 import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import { EvmAddress, EvmSignature, EvmSigner } from "./signer";
 import { prepareForSignOperation } from "./prepareTransaction";
 import { getSerializedTransaction } from "./transaction";
 import { Transaction } from "./types";
-import { EvmAddress, EvmSignature, EvmSigner } from "./signer";
 
 /**
  * Transforms the ECDSA signature paremeter v hexadecimal string received
@@ -65,12 +67,17 @@ export const buildSignOperation =
         const resolutionConfig: ResolutionConfig = {
           externalPlugins: true,
           erc20: true,
+          nft: isNFTActive(account.currency),
           domains: transaction.recipientDomain ? [transaction.recipientDomain] : [],
         };
+        const loadConfig: LoadConfig = {
+          cryptoassetsBaseURL: getEnv("DYNAMIC_CAL_BASE_URL"),
+          nftExplorerBaseURL: getEnv("NFT_ETH_METADATA_SERVICE") + "/v1/ethereum",
+        };
         // Look for resolutions for external plugins and ERC20
         const resolution = await ledgerService.resolveTransaction(
           serializedTxHexString,
-          {},
+          loadConfig,
           resolutionConfig,
         );
 
@@ -78,10 +85,15 @@ export const buildSignOperation =
           type: "device-signature-requested",
         });
 
-        const sig = (await signerContext(deviceId, signer =>
+        const sig = (await signerContext(deviceId, signer => {
+          signer.setLoadConfig(loadConfig);
           // Request signature on the nano
-          signer.signTransaction(account.freshAddressPath, serializedTxHexString, resolution),
-        )) as EvmSignature;
+          return signer.signTransaction(
+            account.freshAddressPath,
+            serializedTxHexString,
+            resolution,
+          );
+        })) as EvmSignature;
 
         o.next({ type: "device-signature-granted" }); // Signature is done
 
@@ -90,7 +102,7 @@ export const buildSignOperation =
         const signature = await getSerializedTransaction(preparedTransaction, {
           r: "0x" + sig.r,
           s: "0x" + sig.s,
-          v: applyEIP155(sig.v, chainId),
+          v: applyEIP155(typeof sig.v === "number" ? sig.v.toString(16) : sig.v, chainId),
         });
 
         const operation = buildOptimisticOperation(account, {
@@ -110,6 +122,7 @@ export const buildSignOperation =
 
       main().then(
         () => o.complete(),
+        /* istanbul ignore next: don't test throwing an error */
         e => o.error(e),
       );
     });

package/src/signer.ts

@@ -1,13 +1,15 @@
 import { DomainServiceResolution } from "@ledgerhq/domain-service/types";
+import { EIP712Message } from "@ledgerhq/types-live";
 
 export type EvmAddress = {
   publicKey: string;
   address: string;
   chainCode?: string;
 };
+
 export type EvmSignature = {
   s: string;
-  v: string;
+  v: string | number;
   r: string;
 };
 
@@ -25,11 +27,52 @@ type LedgerEthTransactionResolution = {
   domains: DomainServiceResolution[];
 };
 
+// Duplicate type definition from hw-app-eth.
+type LoadConfig = {
+  // Backend service responsible for signed NFT APDUS
+  nftExplorerBaseURL?: string | null;
+  // example of payload https://cdn.live.ledger.com/plugins/ethereum/1.json
+  // fetch against an api (base url is an api that hosts /plugins/ethereum/${chainId}.json )
+  // set to null will disable it
+  pluginBaseURL?: string | null;
+  // provide manually some extra plugins to add for the resolution (e.g. for dev purpose)
+  // object will be merged with the returned value of the Ledger cdn payload
+  extraPlugins?: any | null;
+  cryptoassetsBaseURL?: string | null;
+};
+
 export interface EvmSigner {
+  setLoadConfig(loadConfig: LoadConfig): void;
   getAddress(path: string, boolDisplay?: boolean, boolChaincode?: boolean): Promise<EvmAddress>;
   signTransaction(
     path: string,
     rawTxHex: string,
     resolution?: LedgerEthTransactionResolution | null,
   ): Promise<EvmSignature>;
+  signPersonalMessage(
+    path: string,
+    messageHex: string,
+  ): Promise<{
+    v: number;
+    s: string;
+    r: string;
+  }>;
+  signEIP712HashedMessage(
+    path: string,
+    domainSeparatorHex: string,
+    hashStructMessageHex: string,
+  ): Promise<{
+    v: number;
+    s: string;
+    r: string;
+  }>;
+  signEIP712Message(
+    path: string,
+    jsonMessage: EIP712Message,
+    fullImplem?: boolean,
+  ): Promise<{
+    v: number;
+    s: string;
+    r: string;
+  }>;
 }

package/src/specs.ts

@@ -1,16 +1,22 @@
+/* istanbul ignore file: don't test the test. */
+
 import expect from "expect";
 import invariant from "invariant";
 import sample from "lodash/sample";
 import BigNumber from "bignumber.js";
-import { MutationSpec, TransactionDestinationTestInput } from "@ledgerhq/coin-framework/bot/types";
-import { DeviceModelId } from "@ledgerhq/devices";
-import { CryptoCurrencyIds } from "@ledgerhq/types-live";
-import { cryptocurrenciesById } from "@ledgerhq/cryptoassets/currencies";
 import { botTest, genericTestDestination, pickSiblings } from "@ledgerhq/coin-framework/bot/specs";
+import {
+  AppSpec,
+  MutationSpec,
+  TransactionDestinationTestInput,
+} from "@ledgerhq/coin-framework/bot/types";
+import { DeviceModelId } from "@ledgerhq/devices";
 import {
   getCryptoCurrencyById,
   parseCurrencyUnit,
 } from "@ledgerhq/coin-framework/currencies/index";
+import { CryptoCurrencyIds } from "@ledgerhq/types-live";
+import { cryptocurrenciesById } from "@ledgerhq/cryptoassets/currencies";
 import { acceptTransaction } from "./speculos-deviceActions";
 import { Transaction as EvmTransaction } from "./types";
 
@@ -298,8 +304,7 @@ const evmBasicMutations: ({
 
 export default Object.values(cryptocurrenciesById)
   .filter(currency => currency.family === "evm")
-  .reduce((acc, currency) => {
-    // @ts-expect-error FIXME: fix typings
+  .reduce<Record<CryptoCurrencyIds, AppSpec<EvmTransaction>>>((acc, currency) => {
     acc[currency.id] = {
       name: currency.name,
       currency,

package/src/speculos-deviceActions.ts

@@ -1,10 +1,12 @@
-import { findSubAccountById } from "@ledgerhq/coin-framework/account/index";
+/* istanbul ignore file: not reaching userland - bot only. */
+
 import {
   deviceActionFlow,
   formatDeviceAmount,
   SpeculosButton,
 } from "@ledgerhq/coin-framework/bot/specs";
 import type { DeviceAction } from "@ledgerhq/coin-framework/bot/types";
+import { findSubAccountById } from "@ledgerhq/coin-framework/account/index";
 import type { Transaction } from "./types";
 
 // FIXME: fix types

package/src/synchronization.ts

@@ -1,5 +1,7 @@
+import { log } from "@ledgerhq/logs";
 import {
   decodeAccountId,
+  decodeTokenAccountId,
   emptyHistoryCache,
   encodeAccountId,
   encodeTokenAccountId,
@@ -10,15 +12,22 @@ import {
   GetAccountShape,
   makeSync,
   mergeOps,
+  mergeNfts,
 } from "@ledgerhq/coin-framework/bridge/jsHelpers";
-import { log } from "@ledgerhq/logs";
-import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { Account, Operation, SubAccount } from "@ledgerhq/types-live";
-
+import { decodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { nftsFromOperations } from "@ledgerhq/coin-framework/nft/helpers";
+import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { getBalanceAndBlock, getBlock, getTokenBalance, getTransaction } from "./api/rpc";
-import { getSyncHash, mergeSubAccounts } from "./logic";
+import { attachOperations, getSyncHash, mergeSubAccounts } from "./logic";
 import { getExplorerApi } from "./api/explorer";
 
+/**
+ * Number of blocks that are considered "unsafe" due to a potential reorg.
+ * Everything older than this number, should be considered immutable.
+ */
+export const SAFE_REORG_THRESHOLD = 80;
+
 /**
  * Main synchronization process
  * Get the main Account and the potential TokenAccounts linked to it
@@ -47,15 +56,17 @@ export const getAccountShape: GetAccountShape = async infos => {
         return (acc?.blockHeight || 0) > (curr?.blockHeight || 0) ? acc : curr;
       }, null);
 
-  // This method could not be working if the integration doesn't have an API to retreive the operations
-  const lastCoinOperations = await (async () => {
+  const { lastCoinOperations, lastTokenOperations, lastNftOperations } = await (async () => {
     try {
-      const { getLastCoinOperations } = getExplorerApi(currency);
-      return await getLastCoinOperations(
+      const { getLastOperations } = getExplorerApi(currency);
+      return await getLastOperations(
         currency,
         address,
         accountId,
-        latestSyncedOperation?.blockHeight || 0,
+        latestSyncedOperation?.blockHeight
+          ? Math.max(latestSyncedOperation.blockHeight - SAFE_REORG_THRESHOLD, 0)
+          : 0,
+        blockHeight,
       );
     } catch (e) {
       log("EVM Family", "Failed to get latest transactions", {
@@ -67,9 +78,8 @@ export const getAccountShape: GetAccountShape = async infos => {
     }
   })();
 
-  const newSubAccounts = await getSubAccounts(infos, accountId, shouldSyncFromScratch);
-  // Merging potential new subAccouns while preserving the reference (returned value will be initialAccount.subAccounts)
-  const subAccounts = mergeSubAccounts(initialAccount, newSubAccounts);
+  const newSubAccounts = await getSubAccounts(infos, accountId, lastTokenOperations);
+  const subAccounts = mergeSubAccounts(initialAccount, newSubAccounts); // Merging potential new subAccouns while preserving the references
 
   // Trying to confirm pending operations that we are sure of
   // because they were made in the live
@@ -79,9 +89,27 @@ export const getAccountShape: GetAccountShape = async infos => {
   const confirmedOperations = await Promise.all(confirmPendingOperations).then(ops =>
     ops.filter((op): op is Operation => !!op),
   );
-  const newOperations = [...confirmedOperations, ...lastCoinOperations];
+
+  // Coin operations with children ops like token & nft ops attached to it
+  const lastCoinOperationsWithAttachements = attachOperations(
+    lastCoinOperations,
+    lastTokenOperations,
+    lastNftOperations,
+  );
+  const newOperations = [...confirmedOperations, ...lastCoinOperationsWithAttachements];
   const operations = mergeOps(initialAccount?.operations || [], newOperations);
-  const lastSyncDate = new Date();
+  const operationsWithPendings = mergeOps(operations, initialAccount?.pendingOperations || []);
+
+  // Merging potential new nfts while preserving the references.
+  //
+  // ⚠️ NFTs are aggregated manually to get the account "balance" for each of them.
+  // Because of that, we're not creating NFTs in an incremental way,
+  // but always creating them based on *all* operations.
+  const nfts = mergeNfts(
+    initialAccount?.nfts || [],
+    // Adding pendings ops to this to temporarly remove an NFT from an account if actively being transfered
+    nftsFromOperations(operationsWithPendings),
+  ).filter(nft => nft.amount.gt(0));
 
   return {
     type: "Account",
@@ -93,7 +121,8 @@ export const getAccountShape: GetAccountShape = async infos => {
     operations,
     operationsCount: operations.length,
     subAccounts,
-    lastSyncDate,
+    nfts,
+    lastSyncDate: new Date(),
   } as Partial<Account>;
 };
 
@@ -103,55 +132,26 @@ export const getAccountShape: GetAccountShape = async infos => {
 export const getSubAccounts = async (
   infos: AccountShapeInfo,
   accountId: string,
-  shouldSyncFromScratch = false,
+  lastTokenOperations: Operation[],
 ): Promise<Partial<SubAccount>[]> => {
-  const { initialAccount, address, currency } = infos;
-
-  // Get the latest operation from all subaccounts
-  const latestSyncedOperation = shouldSyncFromScratch
-    ? null
-    : initialAccount?.subAccounts
-        ?.flatMap(({ operations }) => operations)
-        .reduce<Operation | null>((acc, curr) => {
-          if (!acc) {
-            return curr;
-          }
-          return (acc?.blockHeight || 0) > (curr?.blockHeight || 0) ? acc : curr;
-        }, null);
-
-  // This method could not be working if the integration doesn't have an API to retreive the operations
-  const lastERC20OperationsAndCurrencies = await (async () => {
-    try {
-      const { getLastTokenOperations } = getExplorerApi(currency);
-      return await getLastTokenOperations(
-        currency,
-        address,
-        accountId,
-        latestSyncedOperation?.blockHeight || 0,
-      );
-    } catch (e) {
-      log("EVM Family", "Failed to get latest ERC20 transactions", {
-        address,
-        currency,
-        error: e,
-      });
-      throw e;
-    }
-  })();
+  const { currency } = infos;
 
   // Creating a Map of Operations by TokenCurrencies in order to know which TokenAccounts should be synced as well
-  const erc20OperationsByToken = lastERC20OperationsAndCurrencies.reduce<
-    Map<TokenCurrency, Operation[]>
-  >((acc, { tokenCurrency, operation }) => {
-    if (!tokenCurrency) return acc;
+  const erc20OperationsByToken = lastTokenOperations.reduce<Map<TokenCurrency, Operation[]>>(
+    (acc, operation) => {
+      const { accountId } = decodeOperationId(operation.id);
+      const { token } = decodeTokenAccountId(accountId);
+      if (!token) return acc;
 
-    if (!acc.has(tokenCurrency)) {
-      acc.set(tokenCurrency, []);
-    }
-    acc.get(tokenCurrency)?.push(operation);
+      if (!acc.has(token)) {
+        acc.set(token, []);
+      }
+      acc.get(token)?.push(operation);
 
-    return acc;
-  }, new Map<TokenCurrency, Operation[]>());
+      return acc;
+    },
+    new Map<TokenCurrency, Operation[]>(),
+  );
 
   // Fetching all TokenAccounts possible and providing already filtered operations
   const subAccountsPromises: Promise<Partial<SubAccount>>[] = [];
@@ -227,6 +227,20 @@ export const getOperationStatus = async (
       blockHash,
       blockHeight,
       date,
+      subOperations: op.subOperations?.map(subOp => ({
+        ...subOp,
+        transactionSequenceNumber: nonce,
+        blockHash,
+        blockHeight,
+        date,
+      })),
+      nftOperations: op.nftOperations?.map(nftOp => ({
+        ...nftOp,
+        transactionSequenceNumber: nonce,
+        blockHash,
+        blockHeight,
+        date,
+      })),
     } as Operation;
   } catch (e) {
     return null;

package/src/transaction.ts

@@ -1,5 +1,6 @@
-import { getAccountUnit } from "@ledgerhq/coin-framework/account/index";
-import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import { ethers } from "ethers";
+import { BigNumber } from "bignumber.js";
+import type { Account } from "@ledgerhq/types-live";
 import {
   formatTransactionStatusCommon as formatTransactionStatus,
   fromTransactionCommonRaw,
@@ -7,11 +8,12 @@ import {
   toTransactionCommonRaw,
   toTransactionStatusRawCommon as toTransactionStatusRaw,
 } from "@ledgerhq/coin-framework/transaction/common";
-import type { Account } from "@ledgerhq/types-live";
-import { BigNumber } from "bignumber.js";
-import { ethers } from "ethers";
-import ERC20ABI from "./abis/erc20.abi.json";
+import { getAccountUnit } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
 import { transactionToEthersTransaction } from "./adapters";
+import ERC1155ABI from "./abis/erc1155.abi.json";
+import ERC721ABI from "./abis/erc721.abi.json";
+import ERC20ABI from "./abis/erc20.abi.json";
 import type {
   Transaction as EvmTransaction,
   EvmTransactionEIP1559,
@@ -22,6 +24,7 @@ import type {
 
 export const DEFAULT_GAS_LIMIT = new BigNumber(21000);
 
+/* istanbul ignore next: don't test CLI text helpers */
 /**
  * Format the transaction for the CLI
  */
@@ -78,6 +81,15 @@ export const fromTransactionRaw = (rawTx: EvmTransactionRaw): EvmTransaction =>
     tx.additionalFees = new BigNumber(rawTx.additionalFees);
   }
 
+  if (rawTx.nft) {
+    tx.nft = {
+      tokenId: rawTx.nft.tokenId,
+      contract: rawTx.nft.contract,
+      quantity: new BigNumber(rawTx.nft.quantity),
+      collectionName: rawTx.nft.collectionName,
+    };
+  }
+
   return tx as EvmTransaction;
 };
 
@@ -117,6 +129,15 @@ export const toTransactionRaw = (tx: EvmTransaction): EvmTransactionRaw => {
     txRaw.additionalFees = tx.additionalFees.toFixed();
   }
 
+  if (tx.nft) {
+    txRaw.nft = {
+      tokenId: tx.nft.tokenId,
+      contract: tx.nft.contract,
+      quantity: tx.nft.quantity.toFixed(),
+      collectionName: tx.nft.collectionName,
+    };
+  }
+
   return txRaw as EvmTransactionRaw;
 };
 
@@ -124,14 +145,47 @@ export const toTransactionRaw = (tx: EvmTransaction): EvmTransactionRaw => {
  * Returns the data necessary to execute smart contracts.
  * As of now, only used to create ERC20 transfers' data
  */
-export const getTransactionData = (transaction: EvmTransaction): Buffer | undefined => {
-  const contract = new ethers.utils.Interface(ERC20ABI);
-  const data = contract.encodeFunctionData("transfer", [
-    transaction.recipient,
-    transaction.amount.toFixed(),
-  ]);
-
-  return data ? Buffer.from(data.slice(2), "hex") : undefined;
+export const getTransactionData = (
+  account: Account,
+  transaction: EvmTransaction,
+): Buffer | undefined => {
+  switch (transaction.mode) {
+    case "send": {
+      const contract = new ethers.utils.Interface(ERC20ABI);
+      const data = contract.encodeFunctionData("transfer", [
+        transaction.recipient,
+        transaction.amount.toFixed(),
+      ]);
+
+      // removing 0x prefix
+      return Buffer.from(data.slice(2), "hex");
+    }
+    case "erc721": {
+      const contract = new ethers.utils.Interface(ERC721ABI);
+      const data = contract.encodeFunctionData("safeTransferFrom(address,address,uint256,bytes)", [
+        account.freshAddress,
+        transaction.recipient,
+        transaction.nft.tokenId,
+        "0x",
+      ]);
+
+      // removing 0x prefix
+      return Buffer.from(data.slice(2), "hex");
+    }
+    case "erc1155": {
+      const contract = new ethers.utils.Interface(ERC1155ABI);
+      const data = contract.encodeFunctionData("safeTransferFrom", [
+        account.freshAddress,
+        transaction.recipient,
+        transaction.nft.tokenId,
+        transaction.nft.quantity.isFinite() ? transaction.nft.quantity.toFixed() : 0,
+        "0x",
+      ]);
+
+      // removing 0x prefix
+      return Buffer.from(data.slice(2), "hex");
+    }
+  }
 };
 
 /**
@@ -185,5 +239,4 @@ export default {
   toTransactionStatusRaw,
   formatTransactionStatus,
   fromTransactionStatusRaw,
-  getSerializedTransaction,
 };