@ledgerhq/coin-evm 0.2.0-next.0

package/src/signOperation.ts

@@ -0,0 +1,127 @@
+import { Observable } from "rxjs";
+import Eth, { ledgerService } from "@ledgerhq/hw-app-eth";
+import {
+  Account,
+  SignOperationFnSignature,
+  SignOperationEvent,
+} from "@ledgerhq/types-live";
+import { ResolutionConfig } from "@ledgerhq/hw-app-eth/lib/services/types";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import { prepareForSignOperation } from "./prepareTransaction";
+import { getSerializedTransaction } from "./transaction";
+import { Transaction } from "./types";
+import { DeviceCommunication } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+
+/**
+ * Transforms the ECDSA signature paremeter v hexadecimal string received
+ * from the nano into an EIP155 compatible number.
+ *
+ * Reminder EIP155 transforms v this way:
+ * v = chainId * 2 + 35
+ * (+ parity 1 or 0)
+ */
+export const applyEIP155 = (vAsHex: string, chainId: number): number => {
+  const v = parseInt(vAsHex, 16);
+
+  if (v === 0 || v === 1) {
+    // if v is 0 or 1, it's already representing parity
+    return chainId * 2 + 35 + v;
+  } else if (v === 27 || v === 28) {
+    const parity = v - 27; // transforming v into 0 or 1 to become the parity
+    return chainId * 2 + 35 + parity;
+  }
+  // When chainId is lower than 109, hw-app-eth *can* return a v with EIP155 already applied
+  // e.g. bsc's chainId is 56 -> v then equals to 147/148
+  //      optimism's chainId is 10 -> v equals to 55/56
+  //      ethereum's chainId is 1 -> v equals to 0/1
+  //      goerli's chainId is 5 -> v equals to 0/1
+  return v;
+};
+
+/**
+ * Sign Transaction with Ledger hardware
+ */
+export const buildSignOperation =
+  (withDevice: DeviceCommunication): SignOperationFnSignature<Transaction> =>
+  ({
+    account,
+    deviceId,
+    transaction,
+  }: {
+    account: Account;
+    deviceId: any;
+    transaction: Transaction;
+  }): Observable<SignOperationEvent> =>
+    withDevice(deviceId)(
+      (transport) =>
+        new Observable((o) => {
+          async function main() {
+            const preparedTransaction = await prepareForSignOperation(
+              account,
+              transaction
+            );
+            const serializedTxHexString =
+              getSerializedTransaction(preparedTransaction).slice(2); // Remove 0x prefix
+
+            // Configure type of resolutions necessary for the clear signing
+            const resolutionConfig: ResolutionConfig = {
+              externalPlugins: true,
+              erc20: true,
+              domains: transaction.recipientDomain
+                ? [transaction.recipientDomain]
+                : [],
+            };
+            // Look for resolutions for external plugins and ERC20
+            const resolution = await ledgerService.resolveTransaction(
+              serializedTxHexString,
+              {},
+              resolutionConfig
+            );
+
+            o.next({
+              type: "device-signature-requested",
+            });
+
+            // Instanciate Eth app bindings
+            const eth = new Eth(transport);
+            // Request signature on the nano
+            const sig = await eth.signTransaction(
+              account.freshAddressPath,
+              serializedTxHexString,
+              resolution
+            );
+
+            o.next({ type: "device-signature-granted" }); // Signature is done
+
+            const { chainId = 0 } = account.currency.ethereumLikeInfo || {};
+            // Create a new serialized tx with the signature now
+            const signature = await getSerializedTransaction(
+              preparedTransaction,
+              {
+                r: "0x" + sig.r,
+                s: "0x" + sig.s,
+                v: applyEIP155(sig.v, chainId),
+              }
+            );
+
+            const operation = buildOptimisticOperation(account, {
+              ...transaction,
+              nonce: preparedTransaction.nonce,
+            });
+
+            o.next({
+              type: "signed",
+              signedOperation: {
+                operation,
+                signature,
+                expirationDate: null,
+              },
+            });
+          }
+
+          main().then(
+            () => o.complete(),
+            (e) => o.error(e)
+          );
+        })
+    );

package/src/specs.ts

@@ -0,0 +1,344 @@
+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 {
+  getCryptoCurrencyById,
+  parseCurrencyUnit,
+} from "@ledgerhq/coin-framework/currencies/index";
+import { acceptTransaction } from "./speculos-deviceActions";
+import { Transaction as EvmTransaction } from "./types";
+
+const testTimeout = 10 * 60 * 1000;
+
+const ETH_UNIT = { code: "ETH", name: "ETH", magnitude: 18 };
+const MBTC_UNIT = { name: "mBTC", code: "mBTC", magnitude: 5 };
+
+const minBalancePerCurrencyId: Record<CryptoCurrencyIds, BigNumber> = {
+  arbitrum: parseCurrencyUnit(ETH_UNIT, "0.001"),
+  arbitrum_goerli: parseCurrencyUnit(ETH_UNIT, "0.001"),
+  optimism: parseCurrencyUnit(ETH_UNIT, "0.001"),
+  optimism_goerli: parseCurrencyUnit(ETH_UNIT, "0.001"),
+  boba: parseCurrencyUnit(ETH_UNIT, "0.001"),
+  metis: parseCurrencyUnit(ETH_UNIT, "0.01"),
+  moonriver: parseCurrencyUnit(ETH_UNIT, "0.1"),
+  rsk: parseCurrencyUnit(MBTC_UNIT, "0.05"),
+};
+
+/**
+ * Method in charge of verifying that both the recipient and sender of a *coin* transaction
+ * have received/lost the expected amount and have now the right balances
+ *
+ * ⚠️ Some blockchains specific rules are included
+ */
+const testCoinDestination = (
+  args: TransactionDestinationTestInput<EvmTransaction>
+) => {
+  const { sendingAccount } = args;
+  const { currency } = sendingAccount;
+
+  // Because Arbitrum is an L2, gas is used in a specific way to ensure both the L2 and the L1 are getting paid.
+  // But as of right now the `arbiscan.io` API is only returning the proposed gas price of
+  // the transaction and not the effectively used gas price, which might differ.
+  // This leads to not being able to correctly cost an operation and
+  // therefore makes it impossible infer the sender's balance
+  if (["arbitrum", "arbitrum_goerli"].includes(currency.id)) {
+    return;
+  }
+
+  return genericTestDestination(args);
+};
+
+/**
+ * Method in charge of verifying the balance of a coin account after
+ * the transaction has been confirmed
+ *
+ * ⚠️ Some blockchains specific rules are included
+ */
+const testCoinBalance: MutationSpec<EvmTransaction>["test"] = ({
+  account,
+  accountBeforeTransaction,
+  operation,
+}) => {
+  // Optimism works in a way where a transaction as a L2 cost and a L1 settlement cost
+  // The explorer API is not capable of returning the L1 cost, therefore
+  // the operation value will always be less than what
+  // has been removed from the account balance
+  //
+  // Remark is also true for Abritrum but because of the arbiscan API not returning the
+  // effectively used gas but the "bid"/proposition of gas of the transaction
+  // resulting in inconsistencies regarding the cumulated value of a tx.
+  // value + gasLimit * gasPrice <-- gasPrice can be wrong here.
+  const underValuedFeesCurrencies = ["optimism", "optimism_goerli"];
+  const overValuedFeesCurrencies = ["arbitrum", "arbitrum_goerli"];
+  const currenciesWithFlakyBehaviour = [
+    ...underValuedFeesCurrencies,
+    ...overValuedFeesCurrencies,
+  ];
+
+  // Classic test verifying exactly the balance
+  if (!currenciesWithFlakyBehaviour.includes(account.currency.id)) {
+    botTest("account balance moved with operation value", () =>
+      expect(account.balance.toString()).toBe(
+        accountBeforeTransaction.balance.minus(operation.value).toString()
+      )
+    );
+  } else {
+    // fallback test verifying the balance moved between the maximum and minimum possible values of the operation
+    botTest(
+      "account balance moved at least operation value and less than operation value plus fees",
+      () => {
+        // If the fee is undervalued like it is for optimism for example
+        // the only doable check is to verify that the account
+        // has lost *at least* the operation value + fee
+        if (underValuedFeesCurrencies.includes(account.currency.id)) {
+          const maxBalance = accountBeforeTransaction.balance.minus(
+            operation.value.minus(operation.fee) // type OUT operations value includes fees so we remove it
+          );
+
+          expect({
+            lessThanMaxBalance: account.balance.lte(maxBalance),
+          }).toEqual({
+            lessThanMaxBalance: true,
+          });
+        }
+
+        // If the fee is overvalue like it is for arbitrum for example
+        // we make sure the account has now a balance between
+        // previous balance minus only operation value &
+        // previous balance minus operation value + fee
+        if (overValuedFeesCurrencies.includes(account.currency.id)) {
+          const minBalance = accountBeforeTransaction.balance.minus(
+            operation.value // type OUT operations value includes fees
+          );
+          const maxBalance = accountBeforeTransaction.balance.minus(
+            operation.value.minus(operation.fee)
+          );
+
+          expect({
+            greaterThanMinBalance: account.balance.gte(minBalance),
+            lessThanMaxBalance: account.balance.lte(maxBalance),
+          }).toEqual({
+            greaterThanMinBalance: true,
+            lessThanMaxBalance: true,
+          });
+        }
+      }
+    );
+  }
+};
+
+const transactionCheck =
+  (currencyId: string) =>
+  ({ maxSpendable }: { maxSpendable: BigNumber }) => {
+    const currency = getCryptoCurrencyById(currencyId);
+    invariant(
+      maxSpendable.gt(
+        minBalancePerCurrencyId[currency.id] ||
+          parseCurrencyUnit(currency.units[0], "1")
+      ),
+      `${currencyId} balance is too low`
+    );
+  };
+
+const evmBasicMutations: ({
+  maxAccount,
+}: {
+  maxAccount: number;
+}) => MutationSpec<EvmTransaction>[] = ({ maxAccount }) => [
+  {
+    name: "move 50%",
+    maxRun: 2,
+    testDestination: testCoinDestination,
+    transaction: ({ account, siblings, bridge, maxSpendable }) => {
+      const sibling = pickSiblings(siblings, maxAccount);
+      const recipient = sibling.freshAddress;
+      const amount = maxSpendable.div(2).integerValue();
+      return {
+        transaction: bridge.createTransaction(account),
+        updates: [
+          {
+            recipient,
+            amount,
+          },
+        ],
+      };
+    },
+    test: ({
+      account,
+      accountBeforeTransaction,
+      operation,
+      transaction,
+      status,
+      optimisticOperation,
+    }) => {
+      // workaround for buggy explorer behavior (nodes desync)
+      invariant(
+        Date.now() - operation.date.getTime() > 60000,
+        "operation time to be older than 60s"
+      );
+      const estimatedGas = transaction.gasLimit.times(
+        transaction.gasPrice || transaction.maxFeePerGas || 0
+      );
+      botTest("operation fee is not exceeding estimated gas", () =>
+        expect(operation.fee.toNumber()).toBeLessThanOrEqual(
+          estimatedGas.toNumber()
+        )
+      );
+
+      testCoinBalance({
+        account,
+        accountBeforeTransaction,
+        operation,
+        transaction,
+        status,
+        optimisticOperation,
+      });
+    },
+  },
+  {
+    name: "send max",
+    maxRun: 1,
+    testDestination: testCoinDestination,
+    transaction: ({ account, siblings, bridge }) => {
+      const sibling = pickSiblings(siblings, maxAccount);
+      const recipient = sibling.freshAddress;
+
+      return {
+        transaction: bridge.createTransaction(account),
+        updates: [
+          {
+            recipient,
+          },
+          {
+            useAllAmount: true,
+          },
+        ],
+      };
+    },
+    test: ({
+      account,
+      accountBeforeTransaction,
+      operation,
+      transaction,
+      status,
+      optimisticOperation,
+    }) => {
+      // workaround for buggy explorer behavior (nodes desync)
+      invariant(
+        Date.now() - operation.date.getTime() > 60000,
+        "operation time to be older than 60s"
+      );
+      const estimatedGas = transaction.gasLimit.times(
+        transaction.gasPrice || transaction.maxFeePerGas || 0
+      );
+      botTest("operation fee is not exceeding estimated gas", () =>
+        expect(operation.fee.toNumber()).toBeLessThanOrEqual(
+          estimatedGas.toNumber()
+        )
+      );
+
+      testCoinBalance({
+        account,
+        accountBeforeTransaction,
+        operation,
+        transaction,
+        status,
+        optimisticOperation,
+      });
+    },
+  },
+  {
+    name: "move some ERC20",
+    maxRun: 1,
+    transaction: ({ account, siblings, bridge }) => {
+      const erc20Account = sample(
+        (account.subAccounts || []).filter((a) => a.balance.gt(0))
+      );
+      invariant(erc20Account, "no erc20 account");
+      const sibling = pickSiblings(siblings, 3);
+      const recipient = sibling.freshAddress;
+      return {
+        transaction: bridge.createTransaction(account),
+        updates: [
+          {
+            recipient,
+            subAccountId: erc20Account!.id,
+          },
+          Math.random() < 0.5
+            ? {
+                useAllAmount: true,
+              }
+            : {
+                amount: erc20Account!.balance
+                  .times(Math.random())
+                  .integerValue(),
+              },
+        ],
+      };
+    },
+    test: ({ accountBeforeTransaction, account, transaction, operation }) => {
+      // workaround for buggy explorer behavior (nodes desync)
+      invariant(
+        Date.now() - operation.date.getTime() > 60000,
+        "operation time to be older than 60s"
+      );
+      invariant(accountBeforeTransaction.subAccounts, "sub accounts before");
+      const erc20accountBefore = accountBeforeTransaction.subAccounts?.find(
+        (s) => s.id === transaction.subAccountId
+      );
+      invariant(erc20accountBefore, "erc20 acc was here before");
+      invariant(account.subAccounts, "sub accounts");
+      const erc20account = account.subAccounts!.find(
+        (s) => s.id === transaction.subAccountId
+      );
+      invariant(erc20account, "erc20 acc is still here");
+
+      if (transaction.useAllAmount) {
+        botTest("erc20 account is empty", () =>
+          expect(erc20account!.balance.toString()).toBe("0")
+        );
+      } else {
+        botTest("account balance moved with tx amount", () =>
+          expect(erc20account!.balance.toString()).toBe(
+            erc20accountBefore!.balance.minus(transaction.amount).toString()
+          )
+        );
+      }
+    },
+  },
+];
+
+export default Object.values(cryptocurrenciesById)
+  .filter((currency) => currency.family === "evm")
+  .reduce((acc, currency) => {
+    // @ts-expect-error FIXME: fix typings
+    acc[currency.id] = {
+      name: currency.name,
+      currency,
+      appQuery: {
+        model: DeviceModelId.nanoS,
+        appName: "Ethereum",
+        appVersion: "1.10.2",
+      },
+      testTimeout,
+      transactionCheck: transactionCheck(currency.id),
+      mutations: evmBasicMutations({
+        maxAccount: 3,
+      }),
+      genericDeviceAction: acceptTransaction,
+    };
+    return acc;
+  }, {});

package/src/speculos-deviceActions.ts

@@ -0,0 +1,83 @@
+import { findSubAccountById } from "@ledgerhq/coin-framework/account/index";
+import {
+  deviceActionFlow,
+  formatDeviceAmount,
+  SpeculosButton,
+} from "@ledgerhq/coin-framework/bot/specs";
+import type { DeviceAction } from "@ledgerhq/coin-framework/bot/types";
+import type { Transaction } from "./types";
+
+// FIXME: fix types
+const maxFeesExpectedValue = ({
+  account,
+  status,
+}: {
+  account: any;
+  status: any;
+}) => formatDeviceAmount(account.currency, status.estimatedFees);
+
+export const acceptTransaction: DeviceAction<Transaction, any> =
+  deviceActionFlow({
+    steps: [
+      {
+        title: "Review",
+        button: SpeculosButton.RIGHT,
+      },
+      {
+        title: "Type",
+        button: SpeculosButton.RIGHT,
+      },
+      {
+        title: "Amount",
+        button: SpeculosButton.RIGHT,
+        expectedValue: ({ account, status, transaction }) => {
+          const subAccount = findSubAccountById(
+            account,
+            transaction.subAccountId || ""
+          );
+
+          if (subAccount && subAccount.type === "TokenAccount") {
+            return formatDeviceAmount(subAccount.token, status.amount);
+          }
+
+          return formatDeviceAmount(account.currency, status.amount);
+        },
+      },
+      {
+        title: "Contract",
+        button: SpeculosButton.RIGHT,
+      },
+      {
+        title: "Network",
+        button: SpeculosButton.RIGHT,
+      },
+      {
+        title: "Max fees",
+        button: SpeculosButton.RIGHT,
+        expectedValue: maxFeesExpectedValue,
+      },
+      {
+        // Legacy (ETC..)
+        title: "Max Fees",
+        button: SpeculosButton.RIGHT,
+        expectedValue: maxFeesExpectedValue,
+      },
+      {
+        title: "Address",
+        button: SpeculosButton.RIGHT,
+        expectedValue: ({ transaction }) => transaction.recipient,
+      },
+      {
+        title: "Accept",
+        button: SpeculosButton.BOTH,
+      },
+      {
+        title: "Approve",
+        button: SpeculosButton.BOTH,
+      },
+    ],
+  });
+
+export default {
+  acceptTransaction,
+};