@ledgerhq/coin-evm 0.2.0-next.0

package/src/getTransactionStatus.ts

@@ -0,0 +1,186 @@
+import {
+  NotEnoughGas,
+  FeeNotLoaded,
+  InvalidAddress,
+  ETHAddressNonEIP,
+  RecipientRequired,
+  AmountRequired,
+  NotEnoughBalance,
+  GasLessThanEstimate,
+  PriorityFeeTooLow,
+} from "@ledgerhq/errors";
+import { ethers } from "ethers";
+import BigNumber from "bignumber.js";
+import { Account, AccountBridge, SubAccount } from "@ledgerhq/types-live";
+import { findSubAccountById } from "@ledgerhq/coin-framework/account/index";
+import {
+  eip1559TransactionHasFees,
+  getEstimatedFees,
+  legacyTransactionHasFees,
+} from "./logic";
+import {
+  EvmTransactionEIP1559,
+  EvmTransactionLegacy,
+  Transaction as EvmTransaction,
+} from "./types";
+
+type ValidatedTransactionFields =
+  | "recipient"
+  | "gasLimit"
+  | "gasPrice"
+  | "amount"
+  | "maxPriorityFee";
+type ValidationIssues = Partial<Record<ValidatedTransactionFields, Error>>;
+
+// This regex will not work with Starknet since addresses are 65 caracters long after the 0x
+const ethAddressRegEx = /^(0x)?[0-9a-fA-F]{40}$/;
+
+/**
+ * Validate an address for a transaction
+ */
+export const validateRecipient = (
+  account: Account,
+  tx: EvmTransaction
+): Array<ValidationIssues> => {
+  const errors: ValidationIssues = {};
+  const warnings: ValidationIssues = {};
+
+  if (tx.recipient) {
+    // Check if recipient is matching the format of a valid eth address or not
+    const isRecipientMatchingEthFormat = tx.recipient.match(ethAddressRegEx);
+
+    if (!isRecipientMatchingEthFormat) {
+      errors.recipient = new InvalidAddress("", {
+        currency: account.currency,
+      });
+    } else {
+      // Check if address is respecting EIP-55
+      try {
+        const recipientChecksumed = ethers.utils.getAddress(tx.recipient);
+        if (tx.recipient !== recipientChecksumed) {
+          // this case can happen if the user is entering an ICAP address.
+          throw new Error();
+        }
+      } catch (e) {
+        // either getAddress throws for a bad checksum or we throw manually if the recipient isn't the same.
+        warnings.recipient = new ETHAddressNonEIP(); // "Auto-verification not available: carefully verify the address"
+      }
+    }
+  } else {
+    errors.recipient = new RecipientRequired(); // ""
+  }
+
+  return [errors, warnings];
+};
+
+/**
+ * Validate the amount of a transaction for an account
+ */
+export const validateAmount = (
+  account: Account | SubAccount,
+  transaction: EvmTransaction,
+  totalSpent: BigNumber
+): Array<ValidationIssues> => {
+  const errors: ValidationIssues = {};
+  const warnings: ValidationIssues = {};
+
+  const isTokenTransaction = account?.type === "TokenAccount";
+  const isSmartContractInteraction = isTokenTransaction || transaction.data; // if the transaction is a smart contract interaction, it's normal that transaction has no amount
+  const transactionHasFees =
+    legacyTransactionHasFees(transaction as EvmTransactionLegacy) ||
+    eip1559TransactionHasFees(transaction as EvmTransactionEIP1559);
+  const canHaveZeroAmount = isSmartContractInteraction && transactionHasFees;
+
+  // if no amount or 0
+  if (
+    (!transaction.amount || transaction.amount.isZero()) &&
+    !canHaveZeroAmount
+  ) {
+    errors.amount = new AmountRequired(); // "Amount required"
+  } else if (totalSpent.isGreaterThan(account.balance)) {
+    // if not enough to make the transaction
+    errors.amount = new NotEnoughBalance(); // "Sorry, insufficient funds"
+  }
+  return [errors, warnings];
+};
+
+/**
+ * Validate gas properties of a transaction, depending on its type and the account emitter
+ */
+export const validateGas = (
+  account: Account,
+  tx: EvmTransaction,
+  gasLimit: BigNumber,
+  estimatedFees: BigNumber
+): Array<ValidationIssues> => {
+  const errors: ValidationIssues = {};
+  const warnings: ValidationIssues = {};
+
+  if (
+    // if fees are not set or wrongly set
+    !(
+      legacyTransactionHasFees(tx as EvmTransactionLegacy) ||
+      eip1559TransactionHasFees(tx as EvmTransactionEIP1559)
+    )
+  ) {
+    errors.gasPrice = new FeeNotLoaded(); // "Could not load fee rates. Please set manual fees"
+  } else if (gasLimit.isZero()) {
+    errors.gasLimit = new FeeNotLoaded(); // "Could not load fee rates. Please set manual fees"
+  } else if (gasLimit.isLessThan(21000)) {
+    // minimum gas for a tx is 21000
+    errors.gasLimit = new GasLessThanEstimate(); // "This may be too low. Please increase"
+  } else if (tx.recipient && estimatedFees.gt(account.balance)) {
+    errors.gasPrice = new NotEnoughGas(); // "The parent account balance is insufficient for network fees"
+  } else if (tx.maxPriorityFeePerGas && tx.maxPriorityFeePerGas.isZero()) {
+    errors.maxPriorityFee = new PriorityFeeTooLow();
+  }
+
+  return [errors, warnings];
+};
+
+/**
+ * Validate a transaction and get all possibles errors and warnings about it
+ */
+export const getTransactionStatus: AccountBridge<EvmTransaction>["getTransactionStatus"] =
+  async (account, tx) => {
+    const subAccount = findSubAccountById(account, tx.subAccountId || "");
+    const isTokenTransaction = subAccount?.type === "TokenAccount";
+    const { gasLimit, additionalFees, amount } = tx;
+    const estimatedFees = getEstimatedFees(tx);
+    const totalFees = estimatedFees.plus(additionalFees || 0);
+    const totalSpent = isTokenTransaction
+      ? tx.amount
+      : tx.amount.plus(totalFees);
+
+    // Recipient related errors and warnings
+    const [recipientErr, recipientWarn] = validateRecipient(account, tx);
+    // Amount related errors and warnings
+    const [amountErr, amountWarn] = validateAmount(
+      subAccount || account,
+      tx,
+      totalSpent
+    );
+    // Gas related errors and warnings
+    const [gasErr, gasWarn] = validateGas(account, tx, gasLimit, totalFees);
+
+    const errors: ValidationIssues = {
+      ...recipientErr,
+      ...gasErr,
+      ...amountErr,
+    };
+    const warnings: ValidationIssues = {
+      ...recipientWarn,
+      ...gasWarn,
+      ...amountWarn,
+    };
+
+    return {
+      errors,
+      warnings,
+      estimatedFees,
+      amount,
+      totalSpent,
+    };
+  };
+
+export default getTransactionStatus;

package/src/hw-getAddress.ts

@@ -0,0 +1,24 @@
+import type { Resolver } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import Eth from "@ledgerhq/hw-app-eth";
+import eip55 from "eip55";
+
+/**
+ * Eth app binding request for the address
+ */
+const getAddress: Resolver = async (transport, { path, verify }) => {
+  const ethBindings = new Eth(transport);
+  const { address, publicKey, chainCode } = await ethBindings.getAddress(
+    path,
+    verify,
+    false
+  );
+
+  return {
+    address: eip55.encode(address),
+    publicKey,
+    chainCode,
+    path,
+  };
+};
+
+export default getAddress;

package/src/logic.ts

@@ -0,0 +1,149 @@
+import { ethers } from "ethers";
+import BigNumber from "bignumber.js";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { Account, SubAccount } from "@ledgerhq/types-live";
+import { listTokensForCryptoCurrency } from "@ledgerhq/cryptoassets/tokens";
+import { getOptimismAdditionalFees } from "./api/rpc.common";
+import {
+  Transaction as EvmTransaction,
+  EvmTransactionEIP1559,
+  EvmTransactionLegacy,
+} from "./types";
+
+/**
+ * Helper to check if a legacy transaction has the right fee property
+ */
+export const legacyTransactionHasFees = (tx: EvmTransactionLegacy): boolean =>
+  Boolean((!tx.type || tx.type < 2) && tx.gasPrice);
+
+/**
+ * Helper to check if a legacy transaction has the right fee property
+ */
+export const eip1559TransactionHasFees = (tx: EvmTransactionEIP1559): boolean =>
+  Boolean(tx.type === 2 && tx.maxFeePerGas && tx.maxPriorityFeePerGas);
+
+/**
+ * Helper to get total fee value for a tx depending on its type
+ */
+export const getEstimatedFees = (tx: EvmTransaction): BigNumber => {
+  if (tx.type !== 2) {
+    return tx.gasPrice?.multipliedBy(tx.gasLimit) || new BigNumber(0);
+  }
+  return tx.maxFeePerGas?.multipliedBy(tx.gasLimit) || new BigNumber(0);
+};
+
+/**
+ * Helper returning the potential additional fees necessary for layer twos
+ * to settle the transaction on layer 1.
+ */
+export const getAdditionalLayer2Fees = async (
+  currency: CryptoCurrency,
+  transaction: EvmTransaction
+): Promise<BigNumber | undefined> => {
+  switch (currency.id) {
+    case "optimism":
+    case "optimism_goerli": {
+      const additionalFees = await getOptimismAdditionalFees(
+        currency,
+        transaction
+      );
+      return additionalFees;
+    }
+    default:
+      return;
+  }
+};
+
+/**
+ * List of properties of a sub account that can be updated when 2 "identical" accounts are found
+ */
+const updatableSubAccountProperties: { name: string; isOps: boolean }[] = [
+  { name: "balance", isOps: false },
+  { name: "spendableBalance", isOps: false },
+  { name: "balanceHistoryCache", isOps: false },
+  { name: "swapHistory", isOps: false },
+  { name: "operations", isOps: true },
+  { name: "pendingOperations", isOps: true },
+];
+
+/**
+ * In charge of smartly merging sub accounts while maintaining references as much as possible
+ */
+export const mergeSubAccounts = (
+  initialAccount: Account | undefined,
+  newSubAccounts: Partial<SubAccount>[]
+): Array<Partial<SubAccount> | SubAccount> => {
+  const oldSubAccounts: Array<Partial<SubAccount> | SubAccount> | undefined =
+    initialAccount?.subAccounts;
+  if (!oldSubAccounts) {
+    return newSubAccounts;
+  }
+
+  // Creating a map of already existing sub accounts by id
+  const oldSubAccountsById: { [key: string]: Partial<SubAccount> } = {};
+  for (const oldSubAccount of oldSubAccounts) {
+    oldSubAccountsById[oldSubAccount.id!] = oldSubAccount;
+  }
+
+  // Looping on new sub accounts to compare them with already existing ones
+  // Already existing will be updated if necessary (see `updatableSubAccountProperties`)
+  // Fresh new sub accounts will be added/pushed after already existing
+  const newSubAccountsToAdd: Partial<SubAccount>[] = [];
+  for (const newSubAccount of newSubAccounts) {
+    const duplicatedAccount: Partial<SubAccount> | undefined =
+      oldSubAccountsById[newSubAccount.id!];
+
+    // If this sub account was not already in the initialAccount
+    if (!duplicatedAccount) {
+      // We'll add it later
+      newSubAccountsToAdd.push(newSubAccount);
+      continue;
+    }
+
+    const updates: Partial<SubAccount> = {};
+    for (const { name, isOps } of updatableSubAccountProperties) {
+      if (!isOps) {
+        // @ts-expect-error FIXME: fix typings
+        if (newSubAccount[name] !== duplicatedAccount[name]) {
+          // @ts-expect-error FIXME: fix typings
+          updates[name] = newSubAccount[name];
+        }
+      } else {
+        // @ts-expect-error FIXME: fix typings
+        updates[name] = mergeOps(duplicatedAccount[name], newSubAccount[name]);
+      }
+    }
+    // Updating the operationsCount in case the mergeOps changed it
+    updates.operationsCount =
+      updates.operations?.length || duplicatedAccount?.operations?.length || 0;
+
+    // Modifying the Map with the updated sub account with a new ref
+    oldSubAccountsById[newSubAccount.id!] = {
+      ...duplicatedAccount,
+      ...updates,
+    };
+  }
+  const updatedSubAccounts = Object.values(oldSubAccountsById);
+  return [...updatedSubAccounts, ...newSubAccountsToAdd];
+};
+
+/**
+ * Method creating a hash that will help triggering or not a full synchronization on an account.
+ * As of now, it's checking if a token has been added, removed of changed regarding important properties
+ */
+export const getSyncHash = (currency: CryptoCurrency): string => {
+  const tokens = listTokensForCryptoCurrency(currency);
+  const basicTokensListString = tokens
+    .map(
+      (token) =>
+        token.id +
+        token.contractAddress +
+        token.name +
+        token.ticker +
+        token.delisted
+    )
+    .join("");
+
+  return ethers.utils.sha256(Buffer.from(basicTokensListString));
+};

package/src/preload.ts

@@ -0,0 +1,54 @@
+import { log } from "@ledgerhq/logs";
+import { ERC20Token } from "@ledgerhq/cryptoassets/types";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { addTokens, convertERC20 } from "@ledgerhq/cryptoassets/tokens";
+import { tokens as tokensByChainId } from "@ledgerhq/cryptoassets/data/evm/index";
+import network from "@ledgerhq/live-network/network";
+import { getEnv } from "@ledgerhq/live-env";
+
+export const fetchERC20Tokens: (
+  currency: CryptoCurrency
+) => Promise<ERC20Token[]> = async (currency) => {
+  const { ethereumLikeInfo } = currency;
+
+  const url = `${getEnv("DYNAMIC_CAL_BASE_URL")}/evm/${
+    ethereumLikeInfo?.chainId || 0
+  }/erc20.json`;
+  const dynamicTokens: ERC20Token[] | null = await network({
+    method: "GET",
+    url,
+  })
+    .then(({ data }: { data: ERC20Token[] }) => (data.length ? data : null))
+    .catch((e) => {
+      log(
+        "error",
+        "EVM Family: Couldn't fetch dynamic CAL tokens from " + url,
+        e
+      );
+      return null;
+    });
+  if (dynamicTokens) return dynamicTokens;
+
+  // @ts-expect-error FIXME: fix typings
+  const tokens = tokensByChainId[ethereumLikeInfo?.chainId || ""];
+  if (tokens) return tokens;
+
+  log(
+    "warning",
+    `EVM Family: No tokens found in CAL for currency: ${currency.id}`,
+    currency
+  );
+  return [];
+};
+
+export async function preload(currency: CryptoCurrency): Promise<ERC20Token[]> {
+  const erc20 = await fetchERC20Tokens(currency);
+  addTokens(erc20.map(convertERC20));
+  return erc20;
+}
+
+export function hydrate(value: ERC20Token[] | null | undefined): void {
+  if (!Array.isArray(value)) return;
+  addTokens(value.map(convertERC20));
+  log("evm/preload", "hydrate " + value.length + " tokens");
+}

package/src/prepareTransaction.ts

@@ -0,0 +1,176 @@
+import { findSubAccountById } from "@ledgerhq/coin-framework/account/index";
+import { Account, TokenAccount } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import {
+  getFeesEstimation,
+  getGasEstimation,
+  getTransactionCount,
+} from "./api/rpc";
+import { validateRecipient } from "./getTransactionStatus";
+import { getAdditionalLayer2Fees, getEstimatedFees } from "./logic";
+import { getTransactionData, getTypedTransaction } from "./transaction";
+import { Transaction as EvmTransaction } from "./types";
+
+/**
+ * Prepare basic coin transactions or smart contract interactions (other than live ERC20 transfers)
+ * Should be used for transactions coming from the wallet API
+ * Handling addition of gas limit
+ */
+export const prepareCoinTransaction = async (
+  account: Account,
+  typedTransaction: EvmTransaction
+): Promise<EvmTransaction> => {
+  // A `useAllAmount` transaction is a specific case of the live, and because we're in the
+  // context of a coinTransaction, no smart contract should be involed
+  if (typedTransaction.useAllAmount) {
+    // Since a gas estimation is done by simulating the transaction, we can't know in advanced how much
+    // we should put in the simulation.
+    // But as a coin transaction (no smart contract) should always consumme the same amount of gas, no matter
+    // the amount of coin transfered, we can infer the gasLimit with any amount.
+    const gasLimit = await getGasEstimation(account, {
+      ...typedTransaction,
+      amount: new BigNumber(0),
+    });
+    const draftTransaction = {
+      ...typedTransaction,
+      gasLimit,
+    };
+    const estimatedFees = getEstimatedFees(draftTransaction);
+    const additionalFees = await getAdditionalLayer2Fees(
+      account.currency,
+      draftTransaction
+    );
+    const amount = BigNumber.max(
+      account.balance.minus(estimatedFees).minus(additionalFees || 0),
+      0
+    );
+
+    return {
+      ...draftTransaction,
+      amount,
+      additionalFees,
+    };
+  }
+
+  const gasLimit = await getGasEstimation(account, typedTransaction).catch(
+    // in case of a smart contract interaction, the gas estimation
+    // (which is transaction simulation by the node) can fail.
+    // E.g. A DApp is creating an invalid transaction, swaping more Tokens than the user actually have -> fail
+    // This value of 0 should be catched by `getTransactionStatus`
+    // and displayed in the UI as `set the gas manually`
+    () => new BigNumber(0)
+  );
+  const additionalFees = await getAdditionalLayer2Fees(account.currency, {
+    ...typedTransaction,
+    gasLimit,
+  });
+
+  return {
+    ...typedTransaction,
+    gasLimit,
+    additionalFees,
+  };
+};
+
+/**
+ * Prepare ERC20 transactions.
+ * Handling addition of ERC20 transfer data and gas limit
+ */
+export const prepareTokenTransaction = async (
+  account: Account,
+  tokenAccount: TokenAccount,
+  typedTransaction: EvmTransaction
+): Promise<EvmTransaction> => {
+  const [recipientErrors] = validateRecipient(account, typedTransaction);
+  const amount = typedTransaction.useAllAmount
+    ? tokenAccount.balance
+    : typedTransaction.amount;
+  const data = !Object.keys(recipientErrors).length
+    ? getTransactionData({ ...typedTransaction, amount })
+    : undefined;
+  // As we're interacting with a smart contract,
+  // it's going to be the real recipient for the tx
+  const gasLimit = data
+    ? await getGasEstimation(account, {
+        ...typedTransaction,
+        amount: new BigNumber(0), // amount set to 0 as we're interacting with a smart contract
+        recipient: tokenAccount.token.contractAddress, // recipient is then the token smart contract
+        data, // buffer containing the calldata bytecode
+      }).catch(() => new BigNumber(0)) // this catch returning 0 should be handled by the `getTransactionStatus` method
+    : new BigNumber(0);
+  const additionalFees = await getAdditionalLayer2Fees(account.currency, {
+    ...typedTransaction,
+    amount: new BigNumber(0), // amount set to 0 as we're interacting with a smart contract
+    recipient: tokenAccount.token.contractAddress, // recipient is then the token smart contract
+    data, // buffer containing the calldata bytecode
+    gasLimit,
+  });
+
+  // Recipient isn't changed here as it would change on the UI end as well
+  // The change will be handled by the `prepareForSignOperation` method
+  return {
+    ...typedTransaction,
+    amount,
+    data,
+    gasLimit,
+    additionalFees,
+  };
+};
+
+/**
+ * Method called to update a transaction into a state that would make it valid
+ * (E.g. Adding fees, add smart contract data, etc...)
+ */
+export const prepareTransaction = async (
+  account: Account,
+  transaction: EvmTransaction
+): Promise<EvmTransaction> => {
+  const { currency } = account;
+  // Get the current network status fees
+  const feeData = await getFeesEstimation(currency);
+  const subAccount = findSubAccountById(
+    account,
+    transaction.subAccountId || ""
+  );
+  const isTokenTransaction = subAccount?.type === "TokenAccount";
+  const typedTransaction = getTypedTransaction(transaction, feeData);
+
+  return isTokenTransaction
+    ? await prepareTokenTransaction(account, subAccount, typedTransaction)
+    : await prepareCoinTransaction(account, typedTransaction);
+};
+
+/**
+ * Prepare the transaction for the signOperation step.
+ * For now, used to changed the recipient for TokenAccount transfers
+ * with the smart contract address as recipient and add the nonce
+ * (which would change as well in the UI if it was done before that step)
+ */
+export const prepareForSignOperation = async (
+  account: Account,
+  transaction: EvmTransaction
+): Promise<EvmTransaction> => {
+  const nonce = await getTransactionCount(
+    account.currency,
+    account.freshAddress
+  );
+
+  const subAccount = findSubAccountById(
+    account,
+    transaction.subAccountId || ""
+  );
+  const isTokenTransaction = subAccount?.type === "TokenAccount";
+
+  return isTokenTransaction
+    ? {
+        ...transaction,
+        amount: new BigNumber(0), // amount set to 0 as we're interacting with a smart contract
+        recipient: subAccount.token.contractAddress, // recipient is then the token smart contract
+        // data as already been added by the `prepareTokenTransaction` method
+        nonce,
+      }
+    : {
+        ...transaction,
+        nonce,
+      };
+};