@ledgerhq/coin-evm 0.2.0-next.0

package/src/synchronization.ts

@@ -0,0 +1,317 @@
+import {
+  decodeAccountId,
+  emptyHistoryCache,
+  encodeAccountId,
+  encodeTokenAccountId,
+  shouldRetainPendingOperation,
+} from "@ledgerhq/coin-framework/account/index";
+import {
+  AccountShapeInfo,
+  GetAccountShape,
+  makeSync,
+  mergeOps,
+} 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 etherscanLikeApi from "./api/etherscan";
+import {
+  getBalanceAndBlock,
+  getBlock,
+  getTokenBalance,
+  getTransaction,
+} from "./api/rpc";
+import { getSyncHash, mergeSubAccounts } from "./logic";
+
+/**
+ * Switch to select one of the compatible explorer
+ */
+const getExplorerApi = (currency: CryptoCurrency) => {
+  const apiType = currency.ethereumLikeInfo?.explorer?.type;
+
+  switch (apiType) {
+    case "etherscan":
+    case "blockscout":
+      return etherscanLikeApi;
+
+    default:
+      throw new Error("API type not supported");
+  }
+};
+
+/**
+ * Main synchronization process
+ * Get the main Account and the potential TokenAccounts linked to it
+ */
+export const getAccountShape: GetAccountShape = async (infos) => {
+  const { initialAccount, address, derivationMode, currency } = infos;
+  const { blockHeight, balance } = await getBalanceAndBlock(currency, address);
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: address,
+    derivationMode,
+  });
+  const syncHash = getSyncHash(currency);
+  // Due to some changes (as of now: new/updated tokens) we could need to force a sync from 0
+  const shouldSyncFromScratch = syncHash !== initialAccount?.syncHash;
+
+  // Get the latest stored operation to know where to start the new sync
+  const latestSyncedOperation = shouldSyncFromScratch
+    ? null
+    : initialAccount?.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 lastCoinOperations = await (async () => {
+    try {
+      const { getLastCoinOperations } = getExplorerApi(currency);
+      return await getLastCoinOperations(
+        currency,
+        address,
+        accountId,
+        latestSyncedOperation?.blockHeight || 0
+      );
+    } catch (e) {
+      log("EVM Family", "Failed to get latest transactions", {
+        address,
+        currency,
+        error: e,
+      });
+      throw e;
+    }
+  })();
+
+  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);
+
+  // Trying to confirm pending operations that we are sure of
+  // because they were made in the live
+  // Useful for integrations without explorers
+  const confirmPendingOperations =
+    initialAccount?.pendingOperations?.map((op) =>
+      getOperationStatus(currency, op)
+    ) || [];
+  const confirmedOperations = await Promise.all(confirmPendingOperations).then(
+    (ops) => ops.filter((op): op is Operation => !!op)
+  );
+  const newOperations = [...confirmedOperations, ...lastCoinOperations];
+  const operations = mergeOps(initialAccount?.operations || [], newOperations);
+  const lastSyncDate = new Date();
+
+  return {
+    type: "Account",
+    id: accountId,
+    syncHash,
+    balance,
+    spendableBalance: balance,
+    blockHeight,
+    operations,
+    operationsCount: operations.length,
+    subAccounts,
+    lastSyncDate,
+  } as Partial<Account>;
+};
+
+/**
+ * Getting all token related operations in order to provide TokenAccounts
+ */
+export const getSubAccounts = async (
+  infos: AccountShapeInfo,
+  accountId: string,
+  shouldSyncFromScratch = false
+): 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;
+    }
+  })();
+
+  // 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;
+
+    if (!acc.has(tokenCurrency)) {
+      acc.set(tokenCurrency, []);
+    }
+    acc.get(tokenCurrency)?.push(operation);
+
+    return acc;
+  }, new Map<TokenCurrency, Operation[]>());
+
+  // Fetching all TokenAccounts possible and providing already filtered operations
+  const subAccountsPromises: Promise<Partial<SubAccount>>[] = [];
+  for (const [token, ops] of erc20OperationsByToken.entries()) {
+    subAccountsPromises.push(
+      getSubAccountShape(currency, accountId, token, ops)
+    );
+  }
+
+  return Promise.all(subAccountsPromises);
+};
+
+/**
+ * Fetch the balance for a token and creates a TokenAccount based on this and the provided operations
+ */
+export const getSubAccountShape = async (
+  currency: CryptoCurrency,
+  parentId: string,
+  token: TokenCurrency,
+  operations: Operation[]
+): Promise<Partial<SubAccount>> => {
+  const { xpubOrAddress: address } = decodeAccountId(parentId);
+  const tokenAccountId = encodeTokenAccountId(parentId, token);
+  const balance = await getTokenBalance(
+    currency,
+    address,
+    token.contractAddress
+  );
+
+  return {
+    type: "TokenAccount",
+    id: tokenAccountId,
+    parentId,
+    token,
+    balance,
+    spendableBalance: balance,
+    creationDate: new Date(),
+    operations,
+    operationsCount: operations.length,
+    pendingOperations: [],
+    balanceHistoryCache: emptyHistoryCache,
+    swapHistory: [],
+  };
+};
+
+/**
+ * Get a finalized operation depending on it status (confirmed or not)
+ */
+export const getOperationStatus = async (
+  currency: CryptoCurrency,
+  op: Operation
+): Promise<Operation | null> => {
+  try {
+    const {
+      blockNumber: blockHeight,
+      blockHash,
+      timestamp,
+      nonce,
+    } = await getTransaction(currency, op.hash);
+
+    if (!blockHeight) {
+      throw new Error("getOperationStatus: Transaction has no block");
+    }
+
+    const date = await (async () => {
+      // timestamp can be missing depending on the node
+      if (timestamp) {
+        return new Date(timestamp * 1000);
+      }
+
+      // Without timestamp, we directly look for the block
+      const { timestamp: blockTimestamp } = await getBlock(
+        currency,
+        blockHeight
+      );
+      return new Date(blockTimestamp * 1000);
+    })();
+
+    return {
+      ...op,
+      transactionSequenceNumber: nonce,
+      blockHash,
+      blockHeight,
+      date,
+    } as Operation;
+  } catch (e) {
+    return null;
+  }
+};
+
+/**
+ * After each sync, it might be necessary to remove pending operations
+ * inside of subAccounts.
+ */
+export const postSync = (initial: Account, synced: Account): Account => {
+  // Set of hashes from the pending operations of the main account
+  const coinPendingOperationsHashes = new Set();
+  for (const coinPendingOperation of synced.pendingOperations) {
+    coinPendingOperationsHashes.add(coinPendingOperation.hash);
+  }
+  // Set of ids from the already existing subAccount from previous sync
+  const initialSubAccountsIds = new Set();
+  for (const subAccount of initial.subAccounts || []) {
+    initialSubAccountsIds.add(subAccount.id);
+  }
+
+  return {
+    ...synced,
+    subAccounts: synced.subAccounts?.map((subAccount) => {
+      // If the subAccount is new, just return the freshly synced subAccount
+      if (!initialSubAccountsIds.has(subAccount.id)) return subAccount;
+
+      return {
+        ...subAccount,
+        pendingOperations: subAccount.pendingOperations.filter(
+          (tokenPendingOperation) =>
+            // if the pending operation got removed from the main account, remove it as well
+            coinPendingOperationsHashes.has(tokenPendingOperation.hash) &&
+            // if the transaction has been confirmed, remove it
+            !subAccount.operations.some(
+              (op) => op.hash === tokenPendingOperation.hash
+            ) &&
+            // common rule for pending operations retention in the live
+            shouldRetainPendingOperation(synced, tokenPendingOperation)
+        ),
+      };
+    }),
+  };
+};
+
+export const sync = makeSync({
+  getAccountShape,
+  postSync,
+  shouldMergeOps: false,
+});

package/src/testUtils.ts

@@ -0,0 +1,153 @@
+import {
+  decodeAccountId,
+  decodeTokenAccountId,
+  encodeTokenAccountId,
+  shortAddressPreview,
+} from "@ledgerhq/coin-framework/account/index";
+import {
+  DerivationMode,
+  getDerivationScheme,
+  runDerivationScheme,
+} from "@ledgerhq/coin-framework/derivation";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import {
+  Account,
+  Operation,
+  SubAccount,
+  TokenAccount,
+} from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+
+export const makeAccount = (
+  address: string,
+  currency: CryptoCurrency,
+  subAccounts: SubAccount[] = []
+): Account => {
+  const id = `js:2:${currency.id}:${address}:`;
+  const { derivationMode, xpubOrAddress } = decodeAccountId(id);
+  const scheme = getDerivationScheme({
+    derivationMode: derivationMode as DerivationMode,
+    currency,
+  });
+  const index = 0;
+  const freshAddressPath = runDerivationScheme(scheme, currency, {
+    account: index,
+    node: 0,
+    address: 0,
+  });
+
+  const account: Account = {
+    type: "Account",
+    name:
+      currency.name +
+      " " +
+      (derivationMode || "legacy") +
+      " " +
+      shortAddressPreview(xpubOrAddress),
+    xpub: xpubOrAddress,
+    subAccounts,
+    seedIdentifier: xpubOrAddress,
+    starred: true,
+    used: true,
+    swapHistory: [],
+    id,
+    derivationMode,
+    currency,
+    unit: currency.units[0],
+    index,
+    freshAddress: xpubOrAddress,
+    freshAddressPath,
+    freshAddresses: [],
+    creationDate: new Date(),
+    lastSyncDate: new Date(0),
+    blockHeight: 0,
+    balance: new BigNumber(0),
+    spendableBalance: new BigNumber(0),
+    operationsCount: 0,
+    operations: [],
+    pendingOperations: [],
+    balanceHistoryCache: {
+      HOUR: {
+        latestDate: null,
+        balances: [],
+      },
+      DAY: {
+        latestDate: null,
+        balances: [],
+      },
+      WEEK: {
+        latestDate: null,
+        balances: [],
+      },
+    },
+  };
+
+  return account;
+};
+
+export const makeTokenAccount = (
+  address: string,
+  tokenCurrency: TokenCurrency
+): TokenAccount => {
+  const { parentCurrency: currency } = tokenCurrency;
+  const account = makeAccount(address, currency);
+
+  const tokenAccountId = encodeTokenAccountId(account.id, tokenCurrency);
+
+  return {
+    type: "TokenAccount",
+    id: tokenAccountId,
+    parentId: account.id,
+    token: tokenCurrency,
+    balance: new BigNumber(0),
+    spendableBalance: new BigNumber(0),
+    creationDate: new Date(),
+    operationsCount: 0,
+    operations: [],
+    pendingOperations: [],
+    starred: false,
+    balanceHistoryCache: {
+      HOUR: {
+        latestDate: null,
+        balances: [],
+      },
+      DAY: {
+        latestDate: null,
+        balances: [],
+      },
+      WEEK: {
+        latestDate: null,
+        balances: [],
+      },
+    },
+    swapHistory: [],
+  };
+};
+
+export const makeOperation = (partialOp?: Partial<Operation>): Operation => {
+  const accountId = partialOp?.accountId ?? "js:2:ethereum:0xkvn:";
+  const { xpubOrAddress } = decodeAccountId(
+    accountId.includes("+")
+      ? decodeTokenAccountId(accountId).accountId
+      : accountId
+  );
+  const hash = partialOp?.hash ?? "0xhash";
+  const type = partialOp?.type ?? "OUT";
+  return {
+    id: encodeOperationId(accountId, hash, type),
+    hash,
+    type,
+    value: new BigNumber(0),
+    fee: new BigNumber(0),
+    blockHash: null,
+    blockHeight: null,
+    senders: [xpubOrAddress],
+    recipients: ["0xlmb"],
+    accountId,
+    transactionSequenceNumber: 0,
+    date: new Date(),
+    extra: {},
+    ...partialOp,
+  };
+};

package/src/transaction.ts

@@ -0,0 +1,193 @@
+import { getAccountUnit } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import {
+  formatTransactionStatusCommon as formatTransactionStatus,
+  fromTransactionCommonRaw,
+  fromTransactionStatusRawCommon as fromTransactionStatusRaw,
+  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 { transactionToEthersTransaction } from "./adapters";
+import type {
+  Transaction as EvmTransaction,
+  EvmTransactionEIP1559,
+  EvmTransactionLegacy,
+  TransactionRaw as EvmTransactionRaw,
+  FeeData,
+} from "./types";
+
+export const DEFAULT_GAS_LIMIT = new BigNumber(21000);
+
+/**
+ * Format the transaction for the CLI
+ */
+export const formatTransaction = (
+  { mode, amount, recipient, useAllAmount }: EvmTransaction,
+  account: Account
+): string =>
+  `
+${mode.toUpperCase()} ${
+    useAllAmount
+      ? "MAX"
+      : amount.isZero()
+      ? ""
+      : " " +
+        formatCurrencyUnit(getAccountUnit(account), amount, {
+          showCode: true,
+          disableRounding: true,
+        })
+  }${recipient ? `\nTO ${recipient}` : ""}`;
+
+/**
+ * Serializer raw to transaction
+ */
+export const fromTransactionRaw = (
+  rawTx: EvmTransactionRaw
+): EvmTransaction => {
+  const common = fromTransactionCommonRaw(rawTx);
+  const tx: Partial<EvmTransaction> = {
+    ...common,
+    family: rawTx.family,
+    mode: rawTx.mode,
+    chainId: rawTx.chainId,
+    nonce: rawTx.nonce,
+    gasLimit: new BigNumber(rawTx.gasLimit),
+    feesStrategy: rawTx.feesStrategy,
+    type: rawTx.type ?? 0, // if rawTx.type is undefined, transaction will be considered legacy and therefore type 0
+  };
+
+  if (rawTx.data) {
+    tx.data = Buffer.from(rawTx.data, "hex");
+  }
+
+  if (rawTx.gasPrice) {
+    tx.gasPrice = new BigNumber(rawTx.gasPrice);
+  }
+
+  if (rawTx.maxFeePerGas) {
+    tx.maxFeePerGas = new BigNumber(rawTx.maxFeePerGas);
+  }
+
+  if (rawTx.maxPriorityFeePerGas) {
+    tx.maxPriorityFeePerGas = new BigNumber(rawTx.maxPriorityFeePerGas);
+  }
+
+  if (rawTx.additionalFees) {
+    tx.additionalFees = new BigNumber(rawTx.additionalFees);
+  }
+
+  return tx as EvmTransaction;
+};
+
+/**
+ * Serializer transaction to raw
+ */
+export const toTransactionRaw = (tx: EvmTransaction): EvmTransactionRaw => {
+  const common = toTransactionCommonRaw(tx);
+  const txRaw: Partial<EvmTransactionRaw> = {
+    ...common,
+    family: tx.family,
+    mode: tx.mode,
+    chainId: tx.chainId,
+    nonce: tx.nonce,
+    gasLimit: tx.gasLimit.toFixed(),
+    feesStrategy: tx.feesStrategy,
+    type: tx.type,
+  };
+
+  if (tx.data) {
+    txRaw.data = Buffer.from(tx.data).toString("hex");
+  }
+
+  if (tx.gasPrice) {
+    txRaw.gasPrice = tx.gasPrice.toFixed();
+  }
+
+  if (tx.maxFeePerGas) {
+    txRaw.maxFeePerGas = tx.maxFeePerGas.toFixed();
+  }
+
+  if (tx.maxPriorityFeePerGas) {
+    txRaw.maxPriorityFeePerGas = tx.maxPriorityFeePerGas.toFixed();
+  }
+
+  if (tx.additionalFees) {
+    txRaw.additionalFees = tx.additionalFees.toFixed();
+  }
+
+  return txRaw as 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;
+};
+
+/**
+ * Returns a transaction with the correct type and entries depending
+ * on the network compatiblity.
+ */
+export const getTypedTransaction = (
+  transaction: EvmTransaction,
+  feeData: FeeData
+): EvmTransaction => {
+  // If the blockchain is supporting EIP-1559, use maxFeePerGas & maxPriorityFeePerGas
+  if (feeData.maxFeePerGas && feeData.maxPriorityFeePerGas) {
+    delete transaction.gasPrice;
+    return {
+      ...transaction,
+      maxFeePerGas: feeData.maxFeePerGas,
+      maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
+      type: 2,
+    } as EvmTransactionEIP1559;
+  }
+
+  // Else just use a legacy transaction
+  delete transaction.maxFeePerGas;
+  delete transaction.maxPriorityFeePerGas;
+  return {
+    ...transaction,
+    gasPrice: feeData.gasPrice || new BigNumber(0),
+    type: 0,
+  } as EvmTransactionLegacy;
+};
+
+/**
+ * Serialize a Ledger Live transaction into an hex string
+ */
+export const getSerializedTransaction = (
+  tx: EvmTransaction,
+  signature?: Partial<ethers.Signature>
+): string => {
+  const unsignedEthersTransaction = transactionToEthersTransaction(tx);
+
+  return ethers.utils.serializeTransaction(
+    unsignedEthersTransaction,
+    signature as ethers.Signature
+  );
+};
+
+export default {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+  toTransactionStatusRaw,
+  formatTransactionStatus,
+  fromTransactionStatusRaw,
+  getSerializedTransaction,
+};