@ledgerhq/live-common 29.2.0 → 29.3.0-next.1

package/src/families/ethereum/signOperation.ts

@@ -18,9 +18,7 @@ import { mergeMap } from "rxjs/operators";
 import { Observable, from, of } from "rxjs";
 import { FeeNotLoaded } from "@ledgerhq/errors";
 import { LoadConfig } from "@ledgerhq/hw-app-eth/lib/services/types";
-import { byContractAddressAndChainId } from "@ledgerhq/hw-app-eth/erc20";
 import { ledgerService as ethLedgerServices } from "@ledgerhq/hw-app-eth";
-import { erc20SignatureInfo } from "./modules/erc20";
 import { apiForCurrency } from "../../api/Ethereum";
 import { withDevice } from "../../hw/deviceAccess";
 import type { Transaction } from "./types";
@@ -84,9 +82,11 @@ export const signOperation = ({
                 throw new FeeNotLoaded();
               }
 
-              const { ethTxObject, tx, common, fillTransactionDataResult } =
-                buildEthereumTx(account, transaction, nonce);
-
+              const { ethTxObject, tx, common } = buildEthereumTx(
+                account,
+                transaction,
+                nonce
+              );
               const to = eip55.encode((tx.to || "").toString());
               const value = new BigNumber(
                 "0x" + (tx.value.toString("hex") || "0")
@@ -123,6 +123,10 @@ export const signOperation = ({
                 ? m.getResolutionConfig(account, transaction)
                 : {};
 
+              if (transaction.recipientDomain?.type === "forward") {
+                resolutionConfig.domains = [transaction.recipientDomain];
+              }
+
               log("rawtx", txHex);
 
               const resolution = await ethLedgerServices.resolveTransaction(
@@ -134,27 +138,6 @@ export const signOperation = ({
               const eth = new Eth(transport);
               eth.setLoadConfig(loadConfig);
 
-              // FIXME this part is still required for compound to correctly display info on the device
-              const addrs =
-                (fillTransactionDataResult &&
-                  fillTransactionDataResult.erc20contracts) ||
-                [];
-
-              const erc20SignatureBlob = await erc20SignatureInfo(loadConfig);
-
-              for (const addr of addrs) {
-                const tokenInfo = byContractAddressAndChainId(
-                  addr,
-                  account.currency.ethereumLikeInfo?.chainId || 0,
-                  erc20SignatureBlob
-                );
-
-                if (tokenInfo) {
-                  await eth.provideERC20TokenInformation(tokenInfo);
-                  if (cancelled) return;
-                }
-              }
-
               o.next({ type: "device-signature-requested" });
               const result = await eth.signTransaction(
                 freshAddressPath,

package/src/families/ethereum/specs.ts

@@ -1,24 +1,12 @@
 import expect from "expect";
-import { BigNumber } from "bignumber.js";
 import invariant from "invariant";
 import sample from "lodash/sample";
 import type { Transaction } from "./types";
-import {
-  getCryptoCurrencyById,
-  parseCurrencyUnit,
-  findCompoundToken,
-} from "../../currencies";
-import {
-  makeCompoundSummaryForAccount,
-  getAccountCapabilities,
-} from "../../compound/logic";
-import { getSupplyMax } from "./modules/compound";
+import { getCryptoCurrencyById, parseCurrencyUnit } from "../../currencies";
 import { botTest, genericTestDestination, pickSiblings } from "../../bot/specs";
-import type { AppSpec } from "../../bot/types";
+import type { AppSpec, MutationSpec } from "../../bot/types";
 import { EIP1559ShouldBeUsed, getGasLimit } from "./transaction";
 import { DeviceModelId } from "@ledgerhq/devices";
-import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { CompoundAccountSummary } from "../../compound/types";
 import { acceptTransaction } from "./speculos-deviceActions";
 import { avalancheSpeculosDeviceAction } from "./speculos-deviceActions-avalanche";
 
@@ -51,7 +39,9 @@ const testBasicMutation = ({
   );
 };
 
-const ethereumBasicMutations = ({ maxAccount }) => [
+const ethereumBasicMutations = ({
+  maxAccount,
+}): MutationSpec<Transaction>[] => [
   {
     name: "move 50%",
     maxRun: 2,
@@ -95,66 +85,69 @@ const ethereumBasicMutations = ({ maxAccount }) => [
   },
 ];
 
-function findCompoundAccount(account, f: (...args: Array<any>) => any) {
-  return sample(
-    (account.subAccounts || []).filter((a) => {
-      if (
-        a.type === "TokenAccount" &&
-        a.balance.gt(0) &&
-        findCompoundToken(a.token)
-      ) {
-        const c = getAccountCapabilities(a);
-        return c && f(c, a);
-      }
-
-      return false;
-    })
-  );
-}
-
-function getCompoundResult({ account, transaction, accountBeforeTransaction }) {
-  const a = account.subAccounts?.find((a) => a.id === transaction.subAccountId);
-  const aBefore = accountBeforeTransaction.subAccounts?.find(
-    (a) => a.id === transaction.subAccountId
-  );
-  invariant(
-    a && a.type === "TokenAccount",
-    "account %s found",
-    transaction.subAccountId
-  );
-  invariant(
-    aBefore && aBefore.type === "TokenAccount",
-    "account %s found",
-    transaction.subAccountId
-  );
-  const capabilities = getAccountCapabilities(a);
-  const summary = makeCompoundSummaryForAccount(a, account);
-  const capabilitiesBefore = getAccountCapabilities(aBefore);
-  const summaryBefore = makeCompoundSummaryForAccount(
-    aBefore,
-    accountBeforeTransaction
-  );
-  invariant(
-    capabilities,
-    "account %s have no capabilities found",
-    transaction.subAccountId
-  );
-  return {
-    a,
-    capabilities,
-    summary,
-    previous: {
-      summary: summaryBefore,
-      capabilities: capabilitiesBefore,
-    },
-  };
-}
-
 const minAmountETH = parseCurrencyUnit(
   getCryptoCurrencyById("ethereum").units[0],
   "0.01"
 );
 
+const erc20mutation: MutationSpec<Transaction> = {
+  name: "move some ERC20",
+  maxRun: 1,
+  transaction: ({ account, siblings, bridge }) => {
+    const erc20Account = sample(
+      (account.subAccounts || []).filter((a) => a.balance.gt(0))
+    );
+    if (!erc20Account) throw new Error("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() - Number(operation.date) > 60000,
+      "operation time to be older than 60s"
+    );
+    invariant(accountBeforeTransaction.subAccounts, "sub accounts before");
+    const erc20accountBefore = accountBeforeTransaction.subAccounts?.find(
+      (s) => s.id === transaction.subAccountId
+    );
+    if (!erc20accountBefore) throw new Error("no erc20 account before");
+    invariant(account.subAccounts, "sub accounts");
+    const erc20account = account.subAccounts?.find(
+      (s) => s.id === transaction.subAccountId
+    );
+    if (!erc20account) throw new Error("no erc20 account");
+
+    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()
+        )
+      );
+    }
+  },
+};
+
 const ethereum: AppSpec<Transaction> = {
   name: "Ethereum",
   currency: getCryptoCurrencyById("ethereum"),
@@ -169,240 +162,9 @@ const ethereum: AppSpec<Transaction> = {
   transactionCheck: ({ maxSpendable }) => {
     invariant(maxSpendable.gt(minAmountETH), "balance is too low");
   },
-  // @ts-expect-error seriously we have to do somehting
   mutations: ethereumBasicMutations({
     maxAccount: 7,
-  }).concat([
-    {
-      name: "allow MAX a compound token",
-      maxRun: 1,
-      transaction: ({ account, bridge }) => {
-        // find an existing token which was not yet allowed
-        const a = findCompoundAccount(account, (c) => c.enabledAmount.eq(0));
-        invariant(a, "no compound account to allow");
-        const ctoken = findCompoundToken(a.token);
-        invariant(ctoken, "ctoken found");
-        return {
-          transaction: bridge.createTransaction(account) as Transaction,
-          updates: [
-            {
-              mode: "erc20.approve",
-              subAccountId: a.id,
-              recipient: (ctoken as TokenCurrency).contractAddress,
-            },
-            {
-              useAllAmount: true,
-            },
-          ] as Partial<Transaction>[],
-        };
-      },
-      test: (arg) => {
-        const { capabilities } = getCompoundResult(arg);
-        botTest("enabledAmountIsUnlimited is true", () =>
-          expect((capabilities as any).enabledAmountIsUnlimited).toBe(true)
-        );
-      },
-    },
-    {
-      name: "supply some compound token",
-      maxRun: 1,
-      transaction: ({ account, bridge }) => {
-        const a = findCompoundAccount(account, (c) => c.canSupply);
-        invariant(a, "no compound account to supply");
-        const ctoken = findCompoundToken(a.token);
-        invariant(ctoken, "ctoken found");
-        const amount = getSupplyMax(a)
-          .times(0.5 + 0.5 * Math.random())
-          .integerValue();
-        return {
-          transaction: bridge.createTransaction(account),
-          updates: [
-            {
-              mode: "compound.supply",
-              subAccountId: a.id,
-              amount,
-            },
-          ],
-        };
-      },
-      test: (arg) => {
-        const { transaction } = arg;
-        const { summary, previous } = getCompoundResult(arg);
-        invariant(
-          summary,
-          "could not find compound summary for account %s",
-          transaction.subAccountId
-        );
-        botTest("totalSupplied matches", () =>
-          expect(
-            (summary as CompoundAccountSummary).totalSupplied.gt(
-              previous.summary?.totalSupplied || new BigNumber(0)
-            )
-          ).toBe(true)
-        );
-      },
-    },
-    {
-      name: "withdraw some compound token",
-      maxRun: 1,
-      transaction: ({ account, bridge }) => {
-        const a = findCompoundAccount(
-          account,
-          (c, a) =>
-            c.canWithdraw &&
-            a.operations.length > 0 && // 7 days has passed since last operation
-            Date.now() - a.operations[0].date > 7 * 24 * 60 * 60 * 1000
-        );
-        invariant(a, "no compound account to withdraw");
-        const ctoken = findCompoundToken(a.token);
-        invariant(ctoken, "ctoken found");
-        const nonSpendableBalance = a.balance.minus(a.spendableBalance);
-        return {
-          transaction: bridge.createTransaction(account),
-          updates: [
-            {
-              mode: "compound.withdraw",
-              subAccountId: a.id,
-            },
-            Math.random() < 0.5
-              ? {
-                  useAllAmount: true,
-                }
-              : {
-                  amount: nonSpendableBalance
-                    .times(Math.random())
-                    .integerValue(),
-                },
-          ],
-        };
-      },
-      test: (arg) => {
-        const { transaction } = arg;
-        const { summary, previous } = getCompoundResult(arg);
-        invariant(
-          summary,
-          "could not find compound summary for account %s",
-          transaction.subAccountId
-        );
-        invariant(
-          previous.summary,
-          "could not find a previous compound summary for account %s",
-          transaction.subAccountId
-        );
-
-        if (arg.transaction.useAllAmount) {
-          botTest("totalSupplies matches (2)", () =>
-            expect(
-              (summary as CompoundAccountSummary).totalSupplied.eq(0)
-            ).toBe(true)
-          );
-        } else {
-          botTest("totalSupplies matches (3)", () =>
-            expect(
-              (summary as CompoundAccountSummary).totalSupplied.lt(
-                (previous.summary as CompoundAccountSummary).totalSupplied ||
-                  new BigNumber(0)
-              )
-            ).toBe(true)
-          );
-        }
-      },
-    },
-    {
-      name: "disallow a compound token",
-      maxRun: 1,
-      transaction: ({ account, bridge }) => {
-        // find an existing token which was allowed
-        // set it back to zero
-        // ? IDEA: only do it if there is nothing to withdraw
-        const a = findCompoundAccount(
-          account,
-          (c) => !c.enabledAmount.gt(0) && c.enabledAmountIsUnlimited
-        );
-        invariant(a, "no compound account to disallow");
-        const ctoken = findCompoundToken(a.token);
-        invariant(ctoken, "ctoken found");
-        return {
-          transaction: bridge.createTransaction(account),
-          updates: [
-            {
-              mode: "erc20.approve",
-              subAccountId: a.id,
-              recipient: (ctoken as TokenCurrency).contractAddress,
-            },
-            {
-              amount: new BigNumber(0),
-            },
-          ],
-        };
-      },
-      test: (arg) => {
-        const { capabilities } = getCompoundResult(arg);
-        botTest("enabledAmount is zero", () =>
-          expect((capabilities as any).enabledAmount.eq(0)).toBe(true)
-        );
-      },
-    },
-    {
-      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 > 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()
-            )
-          );
-        }
-      },
-    },
-  ]),
+  }).concat([erc20mutation]),
 };
 
 const minAmountETC = parseCurrencyUnit(
@@ -468,12 +230,11 @@ const bsc: AppSpec<Transaction> = {
     {
       name: "move some BEP20",
       maxRun: 1,
-      // @ts-expect-error rxjs stuff
       transaction: ({ account, siblings, bridge }) => {
         const bep20Account = sample(
           (account.subAccounts || []).filter((a) => a.balance.gt(0))
         );
-        invariant(bep20Account, "no bep20 account");
+        if (!bep20Account) throw new Error("no bep20 account");
         const sibling = pickSiblings(siblings, 3);
         const recipient = sibling.freshAddress;
         return {
@@ -517,12 +278,11 @@ const polygon: AppSpec<Transaction> = {
     {
       name: "move some ERC20",
       maxRun: 1,
-      // @ts-expect-error rxjs stuff
       transaction: ({ account, siblings, bridge }) => {
         const erc20Account = sample(
           (account.subAccounts || []).filter((a) => a.balance.gt(0))
         );
-        invariant(erc20Account, "no erc20 account");
+        if (!erc20Account) throw new Error("no erc20 account");
         const sibling = pickSiblings(siblings, 3);
         const recipient = sibling.freshAddress;
         return {

package/src/families/ethereum/speculos-deviceActions.ts

@@ -28,8 +28,6 @@ export const acceptTransaction: DeviceAction<Transaction, any> =
         button: SpeculosButton.RIGHT,
         expectedValue: ({ transaction }) => {
           if (transaction.mode === "erc20.approve") return "Approve";
-          if (transaction.mode === "compound.supply") return "Lend Assets";
-          if (transaction.mode === "compound.withdraw") return "Redeem Assets";
           return "";
         },
       },
@@ -49,21 +47,7 @@ export const acceptTransaction: DeviceAction<Transaction, any> =
             return "Unlimited " + a.token.ticker;
           }
 
-          const amount =
-            a &&
-            a.compoundBalance &&
-            transaction.mode === "compound.withdraw" &&
-            transaction.useAllAmount
-              ? a.compoundBalance
-              : status.amount;
-
-          if (
-            a &&
-            transaction.mode === "compound.withdraw" &&
-            transaction.useAllAmount
-          ) {
-            return formatDeviceAmount(a.compoundBalance, amount);
-          }
+          const amount = status.amount;
 
           if (a) {
             return formatDeviceAmount(a.token, amount);

package/src/families/ethereum/synchronisation.ts

@@ -15,9 +15,13 @@ import {
 } from "../../account";
 import { listTokensForCryptoCurrency } from "../../currencies";
 import { encodeAccountId } from "../../account";
-import type { Operation, TokenAccount, Account } from "@ledgerhq/types-live";
-import { API, apiForCurrency, Tx } from "../../api/Ethereum";
-import { digestTokenAccounts, prepareTokenAccounts } from "./modules";
+import type {
+  Operation,
+  TokenAccount,
+  SubAccount,
+  Account,
+} from "@ledgerhq/types-live";
+import { API, apiForCurrency, Block, Tx } from "../../api/Ethereum";
 import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets";
 import { encodeNftId, isNFTActive, nftsFromOperations } from "../../nft";
 import { encodeOperationId, encodeSubOperationId } from "../../operation";
@@ -25,6 +29,7 @@ import {
   encodeERC1155OperationId,
   encodeERC721OperationId,
 } from "../../nft/nftOperationId";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 export const getAccountShape: GetAccountShape = async (
   infoInput,
@@ -75,7 +80,7 @@ export const getAccountShape: GetAccountShape = async (
     currentBlockP,
     balanceP,
   ]);
-  const blockHeight = currentBlock.height.toNumber();
+  const blockHeight = currentBlock?.height.toNumber();
 
   if (!pullFromBlockHeight && txs.length === 0) {
     log("ethereum", "no ops on " + address);
@@ -164,9 +169,7 @@ export const getAccountShape: GetAccountShape = async (
       };
     })
     .filter(Boolean);
-  tokenAccounts = await prepareTokenAccounts(currency, tokenAccounts, address);
   tokenAccounts = await loadERC20Balances(tokenAccounts, address, api);
-  tokenAccounts = await digestTokenAccounts(currency, tokenAccounts, address);
   const subAccounts = reconciliateSubAccounts(tokenAccounts, initialAccount);
   // has sub accounts have changed, we need to relink the subOperations
   newOps = newOps.map((o) => ({
@@ -201,7 +204,7 @@ export const getAccountShape: GetAccountShape = async (
   return accountShape;
 };
 
-const safeEncodeEIP55 = (addr) => {
+const safeEncodeEIP55 = (addr: string) => {
   if (!addr || addr === "0x") return "";
 
   try {
@@ -566,22 +569,29 @@ const txToOps =
     return ops;
   };
 
-const fetchCurrentBlock = ((perCurrencyId) => (currency) => {
-  if (perCurrencyId[currency.id]) return perCurrencyId[currency.id]();
-  const api = apiForCurrency(currency);
-  const f = throttle(
-    () =>
-      api.getCurrentBlock().catch((e) => {
-        f.cancel();
-        throw e;
-      }),
-    5000
-  );
-  perCurrencyId[currency.id] = f;
-  return f();
-})({});
+const fetchCurrentBlock = (
+  (perCurrencyId) =>
+  (currency: CryptoCurrency): Promise<Block> | undefined => {
+    if (perCurrencyId[currency.id]) return perCurrencyId[currency.id]();
+    const api = apiForCurrency(currency);
+    const f = throttle(
+      () =>
+        api.getCurrentBlock().catch((e) => {
+          f.cancel();
+          throw e;
+        }),
+      5000
+    );
+    perCurrencyId[currency.id] = f;
+    return f();
+  }
+)({});
 
-export const fetchAllTransactions = async (api: API, address, blockHeight) => {
+export const fetchAllTransactions = async (
+  api: API,
+  address: string,
+  blockHeight: number | null | undefined
+): Promise<Tx[]> => {
   let accumulatedTxs: Tx[] = [];
   let currentToken: string | undefined;
 
@@ -599,13 +609,18 @@ export const fetchAllTransactions = async (api: API, address, blockHeight) => {
   return accumulatedTxs;
 };
 
-async function loadERC20Balances(tokenAccounts, address, api) {
+async function loadERC20Balances(
+  tokenAccounts: TokenAccount[],
+  address: string,
+  api: API
+): Promise<TokenAccount[]> {
   const erc20balances = await api.getERC20Balances(
     tokenAccounts.map(({ token }) => ({
       contract: token.contractAddress,
       address,
     }))
   );
+
   return tokenAccounts
     .map((a) => {
       const r = erc20balances.find(
@@ -626,12 +641,12 @@ async function loadERC20Balances(tokenAccounts, address, api) {
 
       return a;
     })
-    .filter(Boolean);
+    .filter((account): account is TokenAccount => !!account);
 }
 
 const SAFE_REORG_THRESHOLD = 80;
 
-function stableOperations(a) {
+function stableOperations(a: Account): Operation[] {
   return a.operations.filter(
     (op) =>
       op.blockHeight && a.blockHeight - op.blockHeight > SAFE_REORG_THRESHOLD
@@ -639,8 +654,11 @@ function stableOperations(a) {
 }
 
 // reconciliate the existing token accounts so that refs don't change if no changes is contained
-function reconciliateSubAccounts(tokenAccounts, initialAccount) {
-  let subAccounts;
+function reconciliateSubAccounts(
+  tokenAccounts: TokenAccount[],
+  initialAccount: Account | undefined
+): SubAccount[] {
+  let subAccounts: SubAccount[] = [];
 
   if (initialAccount) {
     const initialSubAccounts = initialAccount.subAccounts;