@ledgerhq/coin-evm 0.2.0-next.0

package/src/adapters.ts

@@ -0,0 +1,148 @@
+import eip55 from "eip55";
+import { ethers } from "ethers";
+import BigNumber from "bignumber.js";
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { Operation, OperationType } from "@ledgerhq/types-live";
+import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets";
+import {
+  decodeAccountId,
+  encodeTokenAccountId,
+} from "@ledgerhq/coin-framework/account/index";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import {
+  Transaction as EvmTransaction,
+  EvmTransactionEIP1559,
+  EvmTransactionLegacy,
+  EtherscanOperation,
+  EtherscanERC20Event,
+} from "./types";
+
+/**
+ * Adapter to convert a Ledger Live transaction to an Ethers transaction
+ */
+export const transactionToEthersTransaction = (
+  tx: EvmTransaction
+): ethers.Transaction => {
+  const ethersTx = {
+    to: tx.recipient,
+    value: ethers.BigNumber.from(tx.amount.toFixed()),
+    data: tx.data ? `0x${tx.data.toString("hex")}` : undefined,
+    gasLimit: ethers.BigNumber.from(tx.gasLimit.toFixed()),
+    nonce: tx.nonce,
+    chainId: tx.chainId,
+    type: tx.type,
+  } as Partial<ethers.Transaction>;
+
+  // is EIP-1559 transaction (type 2)
+  if (tx.type === 2) {
+    ethersTx.maxFeePerGas = ethers.BigNumber.from(
+      (tx as EvmTransactionEIP1559).maxFeePerGas.toFixed()
+    );
+    ethersTx.maxPriorityFeePerGas = ethers.BigNumber.from(
+      (tx as EvmTransactionEIP1559).maxPriorityFeePerGas.toFixed()
+    );
+  } else {
+    // is Legacy transaction (type 0)
+    ethersTx.gasPrice = ethers.BigNumber.from(
+      (tx as EvmTransactionLegacy).gasPrice.toFixed()
+    );
+  }
+
+  return ethersTx as ethers.Transaction;
+};
+
+/**
+ * Adapter to convert an Etherscan-like operation into a Ledger Live Operation
+ */
+export const etherscanOperationToOperation = (
+  accountId: string,
+  tx: EtherscanOperation
+): Operation => {
+  const { xpubOrAddress: address } = decodeAccountId(accountId);
+  const checksummedAddress = eip55.encode(address);
+  const from = eip55.encode(tx.from);
+  const to = tx.to ? eip55.encode(tx.to) : "";
+  const value = new BigNumber(tx.value);
+  const fee = new BigNumber(tx.gasUsed).times(new BigNumber(tx.gasPrice));
+
+  const type = ((): OperationType => {
+    if (to === checksummedAddress) {
+      return "IN";
+    }
+    if (from === checksummedAddress) {
+      return value.eq(0) ? "FEES" : "OUT";
+    }
+
+    return "NONE";
+  })();
+
+  return {
+    id: encodeOperationId(accountId, tx.hash, type),
+    hash: tx.hash,
+    type: type,
+    value: type === "OUT" || type === "FEES" ? value.plus(fee) : value,
+    fee,
+    senders: [from],
+    recipients: [to],
+    blockHeight: parseInt(tx.blockNumber, 10),
+    blockHash: tx.blockHash,
+    transactionSequenceNumber: parseInt(tx.nonce, 10),
+    accountId: accountId,
+    date: new Date(parseInt(tx.timeStamp, 10) * 1000),
+    extra: {},
+  };
+};
+
+/**
+ * Adapter to convert an ERC20 transaction received
+ * on etherscan-like APIs into an Operation
+ */
+export const etherscanERC20EventToOperation = (
+  accountId: string,
+  event: EtherscanERC20Event
+): { tokenCurrency: TokenCurrency; operation: Operation } | null => {
+  const { currencyId, xpubOrAddress: address } = decodeAccountId(accountId);
+  const tokenCurrency = findTokenByAddressInCurrency(
+    event.contractAddress,
+    currencyId
+  );
+  if (!tokenCurrency) return null;
+
+  const tokenAccountId = encodeTokenAccountId(accountId, tokenCurrency);
+  const from = eip55.encode(event.from);
+  const to = event.to ? eip55.encode(event.to) : "";
+  const value = new BigNumber(event.value);
+  const fee = new BigNumber(event.gasUsed).times(new BigNumber(event.gasPrice));
+
+  const type = ((): OperationType => {
+    if (event.contractAddress && to === eip55.encode(address)) {
+      return "IN";
+    }
+
+    if (event.contractAddress && from === eip55.encode(address)) {
+      return "OUT";
+    }
+
+    return "NONE";
+  })();
+
+  return {
+    tokenCurrency,
+    operation: {
+      id: encodeOperationId(tokenAccountId, event.hash, type),
+      hash: event.hash,
+      type: type,
+      value,
+      fee,
+      senders: [from],
+      recipients: [to],
+      contract: tokenCurrency.contractAddress,
+      blockHeight: parseInt(event.blockNumber, 10),
+      blockHash: event.blockHash,
+      transactionSequenceNumber: parseInt(event.nonce, 10),
+      accountId: tokenAccountId,
+      date: new Date(parseInt(event.timeStamp, 10) * 1000),
+      extra: {},
+    },
+  };
+};

package/src/api/etherscan.ts

@@ -0,0 +1,124 @@
+import { delay } from "@ledgerhq/live-promise";
+import { Operation } from "@ledgerhq/types-live";
+import axios, { AxiosRequestConfig } from "axios";
+import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { makeLRUCache } from "@ledgerhq/live-network/cache";
+import { EtherscanERC20Event, EtherscanOperation } from "../types";
+import { EtherscanAPIError } from "../errors";
+import {
+  etherscanERC20EventToOperation,
+  etherscanOperationToOperation,
+} from "../adapters";
+
+export const ETHERSCAN_TIMEOUT = 5000; // 5 seconds between 2 calls
+export const DEFAULT_RETRIES_API = 8;
+
+async function fetchWithRetries<T>(
+  params: AxiosRequestConfig,
+  retries = DEFAULT_RETRIES_API
+): Promise<T> {
+  try {
+    const { data } = await axios.request<{
+      status: string;
+      message: string;
+      result: T;
+    }>(params);
+
+    if (!Number(data.status) && data.message === "NOTOK") {
+      throw new EtherscanAPIError(
+        "Error while fetching data from Etherscan like API",
+        { params, data }
+      );
+    }
+
+    return data.result;
+  } catch (e) {
+    if (retries) {
+      // wait the API timeout before trying again
+      await delay(ETHERSCAN_TIMEOUT);
+      // decrement with prefix here or it won't work
+      return fetchWithRetries<T>(params, --retries);
+    }
+    throw e;
+  }
+}
+
+/**
+ * Get all the last "normal" transactions (no tokens / NFTs)
+ */
+export const getLastCoinOperations = makeLRUCache<
+  [
+    currency: CryptoCurrency,
+    address: string,
+    accountId: string,
+    fromBlock: number
+  ],
+  Operation[]
+>(
+  async (currency, address, accountId, fromBlock) => {
+    const apiDomain = currency.ethereumLikeInfo?.explorer?.uri;
+    if (!apiDomain) {
+      return [];
+    }
+
+    let url = `${apiDomain}/api?module=account&action=txlist&address=${address}&tag=latest&page=1&sort=desc`;
+    if (fromBlock) {
+      url += `&startBlock=${fromBlock}`;
+    }
+
+    const ops = await fetchWithRetries<EtherscanOperation[]>({
+      method: "GET",
+      url,
+    });
+
+    return ops
+      .map((tx) => etherscanOperationToOperation(accountId, tx))
+      .filter(Boolean) as Operation[];
+  },
+  (currency, address, accountId, fromBlock) => accountId + fromBlock,
+  { ttl: 5 * 1000 }
+);
+
+/**
+ * Get all the last ERC20 transactions
+ */
+export const getLastTokenOperations = makeLRUCache<
+  [
+    currency: CryptoCurrency,
+    address: string,
+    accountId: string,
+    fromBlock: number
+  ],
+  { tokenCurrency: TokenCurrency; operation: Operation }[]
+>(
+  async (currency, address, accountId, fromBlock) => {
+    const apiDomain = currency.ethereumLikeInfo?.explorer?.uri;
+    if (!apiDomain) {
+      return [];
+    }
+
+    let url = `${apiDomain}/api?module=account&action=tokentx&address=${address}&tag=latest&page=1&sort=desc`;
+    if (fromBlock) {
+      url += `&startBlock=${fromBlock}`;
+    }
+
+    const ops = await fetchWithRetries<EtherscanERC20Event[]>({
+      method: "GET",
+      url,
+    });
+
+    return ops
+      .map((event) => etherscanERC20EventToOperation(accountId, event))
+      .filter(Boolean) as {
+      tokenCurrency: TokenCurrency;
+      operation: Operation;
+    }[];
+  },
+  (currency, address, accountId, fromBlock) => accountId + fromBlock,
+  { ttl: 5 * 1000 }
+);
+
+export default {
+  getLastCoinOperations,
+  getLastTokenOperations,
+};

package/src/api/rpc.common.ts

@@ -0,0 +1,354 @@
+/** ⚠️ keep this order of import. @see https://docs.ethers.io/v5/cookbook/react-native/#cookbook-reactnative ⚠️ */
+import { ethers } from "ethers";
+import BigNumber from "bignumber.js";
+import { log } from "@ledgerhq/logs";
+import { delay } from "@ledgerhq/live-promise";
+import { Account } from "@ledgerhq/types-live";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { makeLRUCache } from "@ledgerhq/live-network/cache";
+import OptimismGasPriceOracleAbi from "../abis/optimismGasPriceOracle.abi.json";
+import { FeeData, FeeHistory, Transaction as EvmTransaction } from "../types";
+import { GasEstimationError, InsufficientFunds } from "../errors";
+import { transactionToEthersTransaction } from "../adapters";
+import { getSerializedTransaction } from "../transaction";
+import ERC20Abi from "../abis/erc20.abi.json";
+
+export const RPC_TIMEOUT = 5000; // wait 5 sec after a fail
+export const DEFAULT_RETRIES_RPC_METHODS = 3;
+
+/**
+ * Cache for RPC providers to avoid recreating the connection on every usage of `withApi`
+ * Without this, ethers will create a new provider and use the `eth_chainId` RPC call
+ * at instanciation which could result in rate limits being reached
+ * on some specific nodes (E.g. the main Optimism RPC)
+ */
+const PROVIDERS_BY_RPC: Record<string, ethers.providers.StaticJsonRpcProvider> =
+  {};
+
+/**
+ * Connects to RPC Node
+ *
+ * ⚠️ Make sure to always use a `StaticJsonRpcProvider` and not a `JsonRpcProvider`
+ * because the latter will use a `eth_chainId` before every request in order
+ * to check if the node used changed (as per EIP-1193 standard)
+ * @see https://github.com/ethers-io/ethers.js/issues/901
+ */
+export async function withApi<T>(
+  currency: CryptoCurrency,
+  execute: (api: ethers.providers.StaticJsonRpcProvider) => Promise<T>,
+  retries = DEFAULT_RETRIES_RPC_METHODS
+): Promise<T> {
+  if (!currency?.ethereumLikeInfo?.rpc) {
+    throw new Error("Currency doesn't have an RPC node provided");
+  }
+
+  try {
+    if (!PROVIDERS_BY_RPC[currency.ethereumLikeInfo.rpc]) {
+      PROVIDERS_BY_RPC[currency.ethereumLikeInfo.rpc] =
+        new ethers.providers.StaticJsonRpcProvider(
+          currency.ethereumLikeInfo.rpc
+        );
+    }
+
+    const provider = PROVIDERS_BY_RPC[currency.ethereumLikeInfo.rpc];
+    return await execute(provider);
+  } catch (e) {
+    if (retries) {
+      // wait the RPC timeout before trying again
+      await delay(RPC_TIMEOUT);
+      // decrement with prefix here or it won't work
+      return withApi<T>(currency, execute, --retries);
+    }
+    throw e;
+  }
+}
+
+/**
+ * Get account balance and last chain block
+ */
+export const getBalanceAndBlock: (
+  currency: CryptoCurrency,
+  addr: string
+) => Promise<{ blockHeight: number; balance: BigNumber }> = async (
+  currency,
+  addr
+) =>
+  withApi(currency, async (api) => {
+    const [balance, blockHeight] = await Promise.all([
+      getCoinBalance(currency, addr),
+      api.getBlockNumber(),
+    ]);
+
+    return {
+      blockHeight,
+      balance: new BigNumber(balance.toString()),
+    };
+  });
+
+/**
+ * Get a transaction by hash
+ */
+export const getTransaction = (
+  currency: CryptoCurrency,
+  hash: string
+): Promise<ethers.providers.TransactionResponse> =>
+  withApi(currency, (api) => {
+    return api.getTransaction(hash);
+  });
+
+/**
+ * Get the balance of an address
+ */
+export const getCoinBalance = (
+  currency: CryptoCurrency,
+  address: string
+): Promise<BigNumber> =>
+  withApi(currency, async (api) => {
+    const balance = await api.getBalance(address);
+    return new BigNumber(balance.toString());
+  });
+
+/**
+ * Get the balance of an address
+ */
+export const getTokenBalance = (
+  currency: CryptoCurrency,
+  address: string,
+  contractAddress: string
+): Promise<BigNumber> =>
+  withApi(currency, async (api) => {
+    const erc20 = new ethers.Contract(contractAddress, ERC20Abi, api);
+    const balance = await erc20.balanceOf(address);
+    return new BigNumber(balance.toString());
+  });
+
+/**
+ * Get account nonce
+ */
+export const getTransactionCount = (
+  currency: CryptoCurrency,
+  addr: string
+): Promise<number> =>
+  withApi(currency, async (api) => {
+    return api.getTransactionCount(addr);
+  });
+
+/**
+ * Get an estimated gas limit for a transaction
+ */
+export const getGasEstimation = (
+  account: Account,
+  transaction: EvmTransaction
+): Promise<BigNumber> =>
+  withApi(account.currency, async (api) => {
+    const { to, value, data } = transactionToEthersTransaction(transaction);
+
+    try {
+      const gasEtimation = await api.estimateGas({
+        from: account.freshAddress, // should be necessary for some estimations
+        to,
+        value,
+        data,
+      });
+
+      return new BigNumber(gasEtimation.toString());
+    } catch (e) {
+      log("error", "EVM Family: Gas Estimation Error", e);
+      throw new GasEstimationError();
+    }
+  });
+
+/**
+ * Get an estimation of fees on the network
+ */
+export const getFeesEstimation = (currency: CryptoCurrency): Promise<FeeData> =>
+  withApi(currency, async (api) => {
+    const block = await api.getBlock("latest");
+    const currencySupports1559 = Boolean(block.baseFeePerGas);
+
+    const feeData = await (async () => {
+      if (currencySupports1559) {
+        const feeHistory: FeeHistory = await api.send("eth_feeHistory", [
+          "0x5", // Fetching the history for 5 blocks
+          "latest", // from the latest block
+          [50], // 50% percentile sample
+        ]);
+        // Taking the average priority fee used on the last 5 blocks
+        const maxPriorityFeeAverage = feeHistory.reward
+          .reduce(
+            (acc, [curr]) => acc.plus(new BigNumber(curr)),
+            new BigNumber(0)
+          )
+          .dividedToIntegerBy(feeHistory.reward.length);
+
+        // A maxPriorityFeePerGas too low might make a transaction stuck forever
+        // As a safety measure, if maxPriorityFeePerGas is zero
+        // we enforce a 1 Gwei value
+        const maxPriorityFeePerGas = maxPriorityFeeAverage.isZero()
+          ? new BigNumber(1e9) // 1 Gwei
+          : maxPriorityFeeAverage;
+
+        const nextBaseFee = new BigNumber(
+          feeHistory.baseFeePerGas[feeHistory.baseFeePerGas.length - 1]
+        );
+
+        return {
+          maxPriorityFeePerGas,
+          maxFeePerGas: nextBaseFee.multipliedBy(2).plus(maxPriorityFeePerGas),
+        };
+      } else {
+        const gasPrice = await api.getGasPrice();
+
+        return {
+          gasPrice,
+        };
+      }
+    })();
+
+    return {
+      maxFeePerGas: feeData.maxFeePerGas
+        ? new BigNumber(feeData.maxFeePerGas.toString())
+        : null,
+      maxPriorityFeePerGas: feeData.maxPriorityFeePerGas
+        ? new BigNumber(feeData.maxPriorityFeePerGas.toString())
+        : null,
+      gasPrice: feeData.gasPrice
+        ? new BigNumber(feeData.gasPrice.toString())
+        : null,
+    };
+  });
+
+/**
+ * Broadcast a serialized transaction
+ */
+export const broadcastTransaction = (
+  currency: CryptoCurrency,
+  signedTxHex: string
+): Promise<ethers.providers.TransactionResponse> =>
+  withApi(
+    currency,
+    async (api) => {
+      try {
+        return await api.sendTransaction(signedTxHex);
+      } catch (e) {
+        if ((e as Error & { code: string }).code === "INSUFFICIENT_FUNDS") {
+          log("error", "EVM Family: Wrong estimation of fees", e);
+          throw new InsufficientFunds();
+        }
+        throw e;
+      }
+    },
+    0
+  );
+
+/**
+ * Get the informations about a block by block height
+ */
+export const getBlock = (
+  currency: CryptoCurrency,
+  blockHeight: number
+): Promise<ethers.providers.Block> =>
+  withApi(currency, async (api) => {
+    return api.getBlock(blockHeight);
+  });
+
+/**
+ * Get account balances and nonce
+ */
+export const getSubAccount: (
+  currency: CryptoCurrency,
+  addr: string
+) => Promise<{
+  blockHeight: number;
+  balance: BigNumber;
+  nonce: number;
+}> = async (currency, addr) =>
+  withApi(currency, async (api) => {
+    const [balance, nonce, blockHeight] = await Promise.all([
+      getCoinBalance(currency, addr),
+      getTransactionCount(currency, addr),
+      api.getBlockNumber(),
+    ]);
+
+    return {
+      blockHeight,
+      balance: new BigNumber(balance.toString()),
+      nonce,
+    };
+  });
+
+/**
+ * ⚠️ Blockchain specific
+ *
+ * For a layer 2 like Optimism, additional fees are needed in order to
+ * take into account layer 1 settlement estimated cost.
+ * This gas price is served through a smart contract oracle.
+ *
+ * @see https://help.optimism.io/hc/en-us/articles/4411895794715-How-do-transaction-fees-on-Optimism-work-
+ */
+export const getOptimismAdditionalFees = makeLRUCache<
+  [CryptoCurrency, EvmTransaction],
+  BigNumber
+>(
+  async (currency, transaction) =>
+    withApi(currency, async (api) => {
+      if (!["optimism", "optimism_goerli"].includes(currency.id)) {
+        return new BigNumber(0);
+      }
+
+      // Fake signature is added to get the best approximation possible for the gas on L1
+      const serializedTransaction = (() => {
+        try {
+          return getSerializedTransaction(transaction, {
+            r: "0xffffffffffffffffffffffffffffffffffffffff",
+            s: "0xffffffffffffffffffffffffffffffffffffffff",
+            v: 0,
+          });
+        } catch (e) {
+          return null;
+        }
+      })();
+      if (!serializedTransaction) {
+        return new BigNumber(0);
+      }
+
+      const optimismGasOracle = new ethers.Contract(
+        // contract address provided here
+        // @see https://community.optimism.io/docs/developers/build/transaction-fees/#displaying-fees-to-users
+        "0x420000000000000000000000000000000000000F",
+        OptimismGasPriceOracleAbi,
+        api
+      );
+      const additionalL1Fees = await optimismGasOracle.getL1Fee(
+        serializedTransaction
+      );
+      return new BigNumber(additionalL1Fees.toString());
+    }),
+  (currency, transaction) => {
+    const serializedTransaction = (() => {
+      try {
+        return getSerializedTransaction(transaction);
+      } catch (e) {
+        return null;
+      }
+    })();
+
+    return "getOptimismL1BaseFee_" + currency.id + "_" + serializedTransaction;
+  },
+  { ttl: 15 * 1000 } // preventing rate limit by caching this for at least 15sec
+);
+
+export default {
+  DEFAULT_RETRIES_RPC_METHODS,
+  RPC_TIMEOUT,
+  withApi,
+  getBalanceAndBlock,
+  getTransaction,
+  getCoinBalance,
+  getTransactionCount,
+  getGasEstimation,
+  getFeesEstimation,
+  broadcastTransaction,
+  getBlock,
+  getOptimismAdditionalFees,
+};

package/src/api/rpc.native.ts

@@ -0,0 +1,5 @@
+/** ⚠️ keep this order of import. @see https://docs.ethers.io/v5/cookbook/react-native/#cookbook-reactnative ⚠️ */
+import "react-native-get-random-values";
+import "@ethersproject/shims";
+export * from "./rpc.common";
+export * as default from "./rpc.common";

package/src/api/rpc.ts

@@ -0,0 +1,2 @@
+export * from "./rpc.common";
+export * as default from "./rpc.common";

package/src/bridge/js.ts

@@ -0,0 +1,77 @@
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import {
+  DeviceCommunication,
+  makeAccountBridgeReceive,
+  makeScanAccounts,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
+import { broadcast } from "../broadcast";
+import { createTransaction } from "../createTransaction";
+import { estimateMaxSpendable } from "../estimateMaxSpendable";
+import { getTransactionStatus } from "../getTransactionStatus";
+import getAddress from "../hw-getAddress";
+import { hydrate, preload } from "../preload";
+import { prepareTransaction } from "../prepareTransaction";
+import { buildSignOperation } from "../signOperation";
+import { getAccountShape, sync } from "../synchronization";
+import type { Transaction as EvmTransaction, Transaction } from "../types";
+
+const updateTransaction: AccountBridge<EvmTransaction>["updateTransaction"] = (
+  transaction,
+  patch
+) => {
+  return { ...transaction, ...patch } as EvmTransaction;
+};
+
+export function buildCurrencyBridge(
+  deviceCommunication: DeviceCommunication
+): CurrencyBridge {
+  const scanAccounts = makeScanAccounts({
+    getAccountShape,
+    deviceCommunication,
+    getAddressFn: getAddress,
+  });
+
+  return {
+    preload,
+    hydrate,
+    scanAccounts,
+  };
+}
+
+export function buildAccountBridge(
+  deviceCommunication: DeviceCommunication
+): AccountBridge<Transaction> {
+  const receive = makeAccountBridgeReceive(
+    getAddressWrapper(getAddress),
+    deviceCommunication
+  );
+  const signOperation = buildSignOperation(deviceCommunication);
+
+  return {
+    createTransaction,
+    updateTransaction,
+    prepareTransaction,
+    getTransactionStatus,
+    sync,
+    receive,
+    signOperation,
+    broadcast,
+    estimateMaxSpendable,
+  };
+}
+
+/**
+ * FIXME: unsued network and cacheFn are passed to createBridges because of how the
+ * libs/ledger-live-common/scripts/sync-families-dispatch.mjs script works.
+ */
+export function createBridges(
+  deviceCommunication: DeviceCommunication,
+  _network: unknown,
+  _cacheFn: unknown
+) {
+  return {
+    currencyBridge: buildCurrencyBridge(deviceCommunication),
+    accountBridge: buildAccountBridge(deviceCommunication),
+  };
+}