@ledgerhq/coin-evm 0.2.1 → 0.2.2-nightly.0

package/src/prepareTransaction.ts

@@ -1,11 +1,7 @@
 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 { getFeesEstimation, getGasEstimation, getTransactionCount } from "./api/rpc";
 import { validateRecipient } from "./getTransactionStatus";
 import { getAdditionalLayer2Fees, getEstimatedFees } from "./logic";
 import { getTransactionData, getTypedTransaction } from "./transaction";
@@ -18,7 +14,7 @@ import { Transaction as EvmTransaction } from "./types";
  */
 export const prepareCoinTransaction = async (
   account: Account,
-  typedTransaction: EvmTransaction
+  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
@@ -36,13 +32,10 @@ export const prepareCoinTransaction = async (
       gasLimit,
     };
     const estimatedFees = getEstimatedFees(draftTransaction);
-    const additionalFees = await getAdditionalLayer2Fees(
-      account.currency,
-      draftTransaction
-    );
+    const additionalFees = await getAdditionalLayer2Fees(account.currency, draftTransaction);
     const amount = BigNumber.max(
       account.balance.minus(estimatedFees).minus(additionalFees || 0),
-      0
+      0,
     );
 
     return {
@@ -58,7 +51,7 @@ export const prepareCoinTransaction = async (
     // 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)
+    () => new BigNumber(0),
   );
   const additionalFees = await getAdditionalLayer2Fees(account.currency, {
     ...typedTransaction,
@@ -79,12 +72,10 @@ export const prepareCoinTransaction = async (
 export const prepareTokenTransaction = async (
   account: Account,
   tokenAccount: TokenAccount,
-  typedTransaction: EvmTransaction
+  typedTransaction: EvmTransaction,
 ): Promise<EvmTransaction> => {
   const [recipientErrors] = validateRecipient(account, typedTransaction);
-  const amount = typedTransaction.useAllAmount
-    ? tokenAccount.balance
-    : typedTransaction.amount;
+  const amount = typedTransaction.useAllAmount ? tokenAccount.balance : typedTransaction.amount;
   const data = !Object.keys(recipientErrors).length
     ? getTransactionData({ ...typedTransaction, amount })
     : undefined;
@@ -123,15 +114,29 @@ export const prepareTokenTransaction = async (
  */
 export const prepareTransaction = async (
   account: Account,
-  transaction: EvmTransaction
+  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 feeData = await (async () => {
+    if (transaction.feesStrategy === "custom") {
+      return {
+        gasPrice: transaction.gasPrice ?? null,
+        maxFeePerGas: transaction.maxFeePerGas ?? null,
+        maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ?? null,
+      };
+    }
+
+    if (!transaction.feesStrategy) {
+      return getFeesEstimation(currency);
+    }
+
+    const gasOption = transaction.gasOptions?.[transaction.feesStrategy];
+
+    return gasOption ?? getFeesEstimation(currency);
+  })();
+
+  const subAccount = findSubAccountById(account, transaction.subAccountId || "");
   const isTokenTransaction = subAccount?.type === "TokenAccount";
   const typedTransaction = getTypedTransaction(transaction, feeData);
 
@@ -148,17 +153,11 @@ export const prepareTransaction = async (
  */
 export const prepareForSignOperation = async (
   account: Account,
-  transaction: EvmTransaction
+  transaction: EvmTransaction,
 ): Promise<EvmTransaction> => {
-  const nonce = await getTransactionCount(
-    account.currency,
-    account.freshAddress
-  );
+  const nonce = await getTransactionCount(account.currency, account.freshAddress);
 
-  const subAccount = findSubAccountById(
-    account,
-    transaction.subAccountId || ""
-  );
+  const subAccount = findSubAccountById(account, transaction.subAccountId || "");
   const isTokenTransaction = subAccount?.type === "TokenAccount";
 
   return isTokenTransaction

package/src/signOperation.ts

@@ -1,16 +1,18 @@
 import { Observable } from "rxjs";
-import Eth, { ledgerService } from "@ledgerhq/hw-app-eth";
 import {
   Account,
   SignOperationFnSignature,
   SignOperationEvent,
+  DeviceId,
 } from "@ledgerhq/types-live";
+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 { buildOptimisticOperation } from "./buildOptimisticOperation";
 import { prepareForSignOperation } from "./prepareTransaction";
 import { getSerializedTransaction } from "./transaction";
 import { Transaction } from "./types";
-import { DeviceCommunication } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { EvmAddress, EvmSignature, EvmSigner } from "./signer";
 
 /**
  * Transforms the ECDSA signature paremeter v hexadecimal string received
@@ -42,86 +44,72 @@ export const applyEIP155 = (vAsHex: string, chainId: number): number => {
  * Sign Transaction with Ledger hardware
  */
 export const buildSignOperation =
-  (withDevice: DeviceCommunication): SignOperationFnSignature<Transaction> =>
+  (
+    signerContext: SignerContext<EvmSigner, EvmAddress | EvmSignature>,
+  ): SignOperationFnSignature<Transaction> =>
   ({
     account,
     deviceId,
     transaction,
   }: {
     account: Account;
-    deviceId: any;
+    deviceId: DeviceId;
     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
+    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
-            );
+        // 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",
-            });
+        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
-            );
+        const sig = (await signerContext(deviceId, signer =>
+          // Request signature on the nano
+          signer.signTransaction(account.freshAddressPath, serializedTxHexString, resolution),
+        )) as EvmSignature;
 
-            o.next({ type: "device-signature-granted" }); // Signature is done
+        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 { 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,
-            });
+        const operation = buildOptimisticOperation(account, {
+          ...transaction,
+          nonce: preparedTransaction.nonce,
+        });
 
-            o.next({
-              type: "signed",
-              signedOperation: {
-                operation,
-                signature,
-                expirationDate: null,
-              },
-            });
-          }
+        o.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            signature,
+            expirationDate: null,
+          },
+        });
+      }
 
-          main().then(
-            () => o.complete(),
-            (e) => o.error(e)
-          );
-        })
-    );
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+    });

package/src/signer.ts

@@ -0,0 +1,35 @@
+import { DomainServiceResolution } from "@ledgerhq/domain-service/types";
+
+export type EvmAddress = {
+  publicKey: string;
+  address: string;
+  chainCode?: string;
+};
+export type EvmSignature = {
+  s: string;
+  v: string;
+  r: string;
+};
+
+// Duplicate type definition from hw-app-eth.
+type LedgerEthTransactionResolution = {
+  // device serialized data that contains ERC20 data (hex format)
+  erc20Tokens: Array<string>;
+  // device serialized data that contains NFT data (hex format)
+  nfts: Array<string>;
+  // device serialized data that contains external plugin data (hex format)
+  externalPlugin: Array<{ payload: string; signature: string }>;
+  // device serialized data that contains plugin data (hex format)
+  plugin: Array<string>;
+  // device serialized data that contain trusted names data (hex format)
+  domains: DomainServiceResolution[];
+};
+
+export interface EvmSigner {
+  getAddress(path: string, boolDisplay?: boolean, boolChaincode?: boolean): Promise<EvmAddress>;
+  signTransaction(
+    path: string,
+    rawTxHex: string,
+    resolution?: LedgerEthTransactionResolution | null,
+  ): Promise<EvmSignature>;
+}

package/src/specs.ts

@@ -2,18 +2,11 @@ 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 { 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 { botTest, genericTestDestination, pickSiblings } from "@ledgerhq/coin-framework/bot/specs";
 import {
   getCryptoCurrencyById,
   parseCurrencyUnit,
@@ -43,9 +36,7 @@ const minBalancePerCurrencyId: Record<CryptoCurrencyIds, BigNumber> = {
  *
  * ⚠️ Some blockchains specific rules are included
  */
-const testCoinDestination = (
-  args: TransactionDestinationTestInput<EvmTransaction>
-) => {
+const testCoinDestination = (args: TransactionDestinationTestInput<EvmTransaction>) => {
   const { sendingAccount } = args;
   const { currency } = sendingAccount;
 
@@ -83,17 +74,14 @@ const testCoinBalance: MutationSpec<EvmTransaction>["test"] = ({
   // value + gasLimit * gasPrice <-- gasPrice can be wrong here.
   const underValuedFeesCurrencies = ["optimism", "optimism_goerli"];
   const overValuedFeesCurrencies = ["arbitrum", "arbitrum_goerli"];
-  const currenciesWithFlakyBehaviour = [
-    ...underValuedFeesCurrencies,
-    ...overValuedFeesCurrencies,
-  ];
+  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()
-      )
+        accountBeforeTransaction.balance.minus(operation.value).toString(),
+      ),
     );
   } else {
     // fallback test verifying the balance moved between the maximum and minimum possible values of the operation
@@ -105,7 +93,7 @@ const testCoinBalance: MutationSpec<EvmTransaction>["test"] = ({
         // 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
+            operation.value.minus(operation.fee), // type OUT operations value includes fees so we remove it
           );
 
           expect({
@@ -121,10 +109,10 @@ const testCoinBalance: MutationSpec<EvmTransaction>["test"] = ({
         // 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
+            operation.value, // type OUT operations value includes fees
           );
           const maxBalance = accountBeforeTransaction.balance.minus(
-            operation.value.minus(operation.fee)
+            operation.value.minus(operation.fee),
           );
 
           expect({
@@ -135,7 +123,7 @@ const testCoinBalance: MutationSpec<EvmTransaction>["test"] = ({
             lessThanMaxBalance: true,
           });
         }
-      }
+      },
     );
   }
 };
@@ -146,10 +134,9 @@ const transactionCheck =
     const currency = getCryptoCurrencyById(currencyId);
     invariant(
       maxSpendable.gt(
-        minBalancePerCurrencyId[currency.id] ||
-          parseCurrencyUnit(currency.units[0], "1")
+        minBalancePerCurrencyId[currency.id] || parseCurrencyUnit(currency.units[0], "1"),
       ),
-      `${currencyId} balance is too low`
+      `${currencyId} balance is too low`,
     );
   };
 
@@ -187,15 +174,13 @@ const evmBasicMutations: ({
       // workaround for buggy explorer behavior (nodes desync)
       invariant(
         Date.now() - operation.date.getTime() > 60000,
-        "operation time to be older than 60s"
+        "operation time to be older than 60s",
       );
       const estimatedGas = transaction.gasLimit.times(
-        transaction.gasPrice || transaction.maxFeePerGas || 0
+        transaction.gasPrice || transaction.maxFeePerGas || 0,
       );
       botTest("operation fee is not exceeding estimated gas", () =>
-        expect(operation.fee.toNumber()).toBeLessThanOrEqual(
-          estimatedGas.toNumber()
-        )
+        expect(operation.fee.toNumber()).toBeLessThanOrEqual(estimatedGas.toNumber()),
       );
 
       testCoinBalance({
@@ -239,15 +224,13 @@ const evmBasicMutations: ({
       // workaround for buggy explorer behavior (nodes desync)
       invariant(
         Date.now() - operation.date.getTime() > 60000,
-        "operation time to be older than 60s"
+        "operation time to be older than 60s",
       );
       const estimatedGas = transaction.gasLimit.times(
-        transaction.gasPrice || transaction.maxFeePerGas || 0
+        transaction.gasPrice || transaction.maxFeePerGas || 0,
       );
       botTest("operation fee is not exceeding estimated gas", () =>
-        expect(operation.fee.toNumber()).toBeLessThanOrEqual(
-          estimatedGas.toNumber()
-        )
+        expect(operation.fee.toNumber()).toBeLessThanOrEqual(estimatedGas.toNumber()),
       );
 
       testCoinBalance({
@@ -264,9 +247,7 @@ const evmBasicMutations: ({
     name: "move some ERC20",
     maxRun: 1,
     transaction: ({ account, siblings, bridge }) => {
-      const erc20Account = sample(
-        (account.subAccounts || []).filter((a) => a.balance.gt(0))
-      );
+      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;
@@ -282,9 +263,7 @@ const evmBasicMutations: ({
                 useAllAmount: true,
               }
             : {
-                amount: erc20Account!.balance
-                  .times(Math.random())
-                  .integerValue(),
+                amount: erc20Account!.balance.times(Math.random()).integerValue(),
               },
         ],
       };
@@ -293,28 +272,24 @@ const evmBasicMutations: ({
       // workaround for buggy explorer behavior (nodes desync)
       invariant(
         Date.now() - operation.date.getTime() > 60000,
-        "operation time to be older than 60s"
+        "operation time to be older than 60s",
       );
       invariant(accountBeforeTransaction.subAccounts, "sub accounts before");
       const erc20accountBefore = accountBeforeTransaction.subAccounts?.find(
-        (s) => s.id === transaction.subAccountId
+        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
-      );
+      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")
-        );
+        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()
-          )
+            erc20accountBefore!.balance.minus(transaction.amount).toString(),
+          ),
         );
       }
     },
@@ -322,7 +297,7 @@ const evmBasicMutations: ({
 ];
 
 export default Object.values(cryptocurrenciesById)
-  .filter((currency) => currency.family === "evm")
+  .filter(currency => currency.family === "evm")
   .reduce((acc, currency) => {
     // @ts-expect-error FIXME: fix typings
     acc[currency.id] = {

package/src/speculos-deviceActions.ts

@@ -8,75 +8,66 @@ 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);
+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 || ""
-          );
+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);
-          }
+        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,
+        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,