@ledgerhq/live-common 21.35.0 → 21.36.2

package/src/families/bitcoin/wallet-btc/storage/index.ts

@@ -1,15 +1,18 @@
-import { findLast, filter, uniqBy, findIndex, has } from "lodash";
+import { findLast, filter, uniqBy, findIndex, isEmpty } from "lodash";
 import Base from "../crypto/base";
 import { Input, IStorage, Output, TX, Address } from "./types";
 
 // a mock storage class that just use js objects
 // sql.js would be perfect for the job
 class BitcoinLikeStorage implements IStorage {
-  txs: TX[] = [];
+  private txs: TX[] = [];
 
-  // indexes
+  // indexe: address + hash -> tx
   primaryIndex: { [key: string]: number } = {};
 
+  // indexe: account + index -> tx
+  accountIndex: { [key: string]: number[] } = {};
+
   // accounting
   unspentUtxos: { [key: string]: Output[] } = {};
 
@@ -20,23 +23,35 @@ class BitcoinLikeStorage implements IStorage {
   // returning unordered tx within the same block)
   spentUtxos: { [key: string]: Input[] } = {};
 
-  getLastTx(txFilter: {
-    account?: number;
-    index?: number;
-    address?: string;
-    confirmed?: boolean;
-  }) {
+  getLastTx(txFilter: { account: number; index: number; confirmed?: boolean }) {
+    if (
+      typeof this.accountIndex[`${txFilter.account}-${txFilter.index}`] ===
+      "undefined"
+    ) {
+      return undefined;
+    }
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
-    const tx: TX | undefined = findLast(this.txs, (t) => {
-      return (
-        (!has(txFilter, "account") || t.account === txFilter.account) &&
-        (!has(txFilter, "index") || t.index === txFilter.index) &&
-        (!has(txFilter, "address") || t.address === txFilter.address) &&
-        (!has(txFilter, "confirmed") ||
+    const tx: TX | undefined = findLast(
+      this.accountIndex[`${txFilter.account}-${txFilter.index}`].map(
+        (i) => this.txs[i]
+      ),
+      (t) => {
+        return (
+          typeof txFilter.confirmed === "undefined" ||
           (txFilter.confirmed && t.block) ||
-          (!txFilter.confirmed && !t.block))
-      );
+          (!txFilter.confirmed && !t.block)
+        );
+      }
+    );
+    return tx;
+  }
+
+  getLastUnconfirmedTx() {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    const tx: TX | undefined = findLast(this.txs, (t) => {
+      return !t.block;
     });
     return tx;
   }
@@ -63,8 +78,14 @@ class BitcoinLikeStorage implements IStorage {
       if (this.txs[this.primaryIndex[index]]) {
         return;
       }
-
-      this.primaryIndex[index] = this.txs.push(tx) - 1;
+      if (
+        typeof this.accountIndex[`${tx.account}-${tx.index}`] === "undefined"
+      ) {
+        this.accountIndex[`${tx.account}-${tx.index}`] = [];
+      }
+      const idx = this.txs.push(tx) - 1;
+      this.primaryIndex[index] = idx;
+      this.accountIndex[`${tx.account}-${tx.index}`].push(idx);
       this.unspentUtxos[indexAddress] = this.unspentUtxos[indexAddress] || [];
       this.spentUtxos[indexAddress] = this.spentUtxos[indexAddress] || [];
 
@@ -117,7 +138,7 @@ class BitcoinLikeStorage implements IStorage {
   removeTxs(txsFilter: { account: number; index: number }) {
     const newTxs: TX[] = [];
     this.primaryIndex = {};
-
+    this.accountIndex = {};
     this.txs.forEach((tx: TX) => {
       // clean
       const indexAddress = tx.address;
@@ -131,8 +152,8 @@ class BitcoinLikeStorage implements IStorage {
       delete this.unspentUtxos[indexAddress];
       delete this.spentUtxos[indexAddress];
     });
-
     this.txs = newTxs;
+    this.createAccountIndex();
   }
 
   // We are a bit ugly because we can't rely undo unspentUTXO
@@ -141,7 +162,7 @@ class BitcoinLikeStorage implements IStorage {
     const newTxs: TX[] = [];
     const txsToReAdd: TX[] = [];
     this.primaryIndex = {};
-
+    this.accountIndex = {};
     this.txs.forEach((tx: TX) => {
       // clean
       const indexAddress = tx.address;
@@ -161,6 +182,7 @@ class BitcoinLikeStorage implements IStorage {
     });
 
     this.txs = newTxs;
+    this.createAccountIndex();
     this.appendTxs(txsToReAdd);
   }
 
@@ -175,6 +197,7 @@ class BitcoinLikeStorage implements IStorage {
     return {
       txs: this.txs,
       primaryIndex: this.primaryIndex,
+      accountIndex: this.accountIndex,
       unspentUtxos: this.unspentUtxos,
       addressCache: this.addressCache,
     };
@@ -183,14 +206,23 @@ class BitcoinLikeStorage implements IStorage {
   loadSync(data: {
     txs: TX[];
     primaryIndex: { [key: string]: number };
+    accountIndex: { [key: string]: number[] };
     unspentUtxos: { [key: string]: Output[] };
     addressCache: { [key: string]: string };
   }) {
     this.txs = data.txs;
     this.primaryIndex = data.primaryIndex;
+    this.accountIndex = data.accountIndex;
     this.unspentUtxos = data.unspentUtxos;
     this.addressCache = data.addressCache;
     Base.addressCache = { ...Base.addressCache, ...this.addressCache };
+    if (
+      (!this.accountIndex || isEmpty(this.accountIndex)) &&
+      this.txs.length > 0
+    ) {
+      this.accountIndex = {};
+      this.createAccountIndex();
+    }
   }
 
   async export() {
@@ -200,11 +232,23 @@ class BitcoinLikeStorage implements IStorage {
   async load(data: {
     txs: TX[];
     primaryIndex: { [key: string]: number };
+    accountIndex: { [key: string]: number[] };
     unspentUtxos: { [key: string]: Output[] };
     addressCache: { [key: string]: string };
   }) {
     return this.loadSync(data);
   }
+
+  private createAccountIndex() {
+    this.txs.forEach((tx: TX, idx: number) => {
+      if (
+        typeof this.accountIndex[`${tx.account}-${tx.index}`] === "undefined"
+      ) {
+        this.accountIndex[`${tx.account}-${tx.index}`] = [];
+      }
+      this.accountIndex[`${tx.account}-${tx.index}`].push(idx);
+    });
+  }
 }
 
 export default BitcoinLikeStorage;

package/src/families/bitcoin/wallet-btc/storage/types.ts

@@ -45,11 +45,11 @@ export interface IStorage {
   appendTxs(txs: TX[]): number;
   getAddressUnspentUtxos(address: Address): Output[];
   getLastTx(txFilter: {
-    account?: number;
-    index?: number;
-    address?: string;
+    account: number;
+    index: number;
     confirmed?: boolean;
   }): TX | undefined;
+  getLastUnconfirmedTx(): TX | undefined;
   getTx(address: string, hash: string): TX | undefined;
   getUniquesAddresses(addressesFilter: {
     account?: number;

package/src/families/bitcoin/wallet-btc/xpub.ts

@@ -59,7 +59,7 @@ class Xpub extends EventEmitter {
   }
 
   async syncAddress(account: number, index: number) {
-    const address = this.crypto.getAddress(
+    const address = await this.crypto.getAddress(
       this.derivationMode,
       this.xpub,
       account,
@@ -176,7 +176,7 @@ class Xpub extends EventEmitter {
     }
 
     this.emitSynced({ type: "all", account });
-    this.freshAddress = this.crypto.getAddress(
+    this.freshAddress = await this.crypto.getAddress(
       this.derivationMode,
       this.xpub,
       0,
@@ -234,7 +234,7 @@ class Xpub extends EventEmitter {
       index = lastIndex + gap;
     }
     const address: Address = {
-      address: this.crypto.getAddress(
+      address: await this.crypto.getAddress(
         this.derivationMode,
         this.xpub,
         account,

package/src/families/celo/js-synchronisation.ts

@@ -1,4 +1,3 @@
-import type { Account } from "../../types";
 import { encodeAccountId } from "../../account";
 import type { GetAccountShape } from "../../bridge/jsHelpers";
 import { makeSync, makeScanAccounts, mergeOps } from "../../bridge/jsHelpers";
@@ -32,9 +31,5 @@ const getAccountShape: GetAccountShape = async (info) => {
   return { ...shape, operations };
 };
 
-const postSync = (_initial: Account, parent: Account) => {
-  return parent;
-};
-
-export const scanAccounts = makeScanAccounts(getAccountShape);
-export const sync = makeSync(getAccountShape, postSync);
+export const scanAccounts = makeScanAccounts({ getAccountShape });
+export const sync = makeSync({ getAccountShape });

package/src/families/cosmos/bridge/js.ts

@@ -3,15 +3,12 @@ import estimateMaxSpendable from "../js-estimateMaxSpendable";
 import getTransactionStatus from "../js-getTransactionStatus";
 import prepareTransaction from "../js-prepareTransaction";
 import signOperation from "../js-signOperation";
-import { sync, getAccountShape } from "../js-synchronisation";
+import { sync, scanAccounts } from "../js-synchronisation";
 import updateTransaction from "../js-updateTransaction";
 import { AccountBridge, CurrencyBridge, CryptoCurrency } from "../../../types";
 import type { CosmosValidatorItem, Transaction } from "../types";
 import { getValidators, hydrateValidators } from "../validators";
-import {
-  makeAccountBridgeReceive,
-  makeScanAccounts,
-} from "../../../bridge/jsHelpers";
+import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
 import { broadcast } from "../api/Cosmos";
 import {
   asSafeCosmosPreloadData,
@@ -47,7 +44,7 @@ const currencyBridge: CurrencyBridge = {
     hydrateValidators(validators);
     setCosmosPreloadData(asSafeCosmosPreloadData(data));
   },
-  scanAccounts: makeScanAccounts(getAccountShape),
+  scanAccounts,
 };
 
 const accountBridge: AccountBridge<Transaction> = {

package/src/families/cosmos/js-synchronisation.ts

@@ -1,6 +1,11 @@
-import { Account, Operation, OperationType } from "../../types";
+import { Operation, OperationType } from "../../types";
 import { BigNumber } from "bignumber.js";
-import { makeSync, GetAccountShape, mergeOps } from "../../bridge/jsHelpers";
+import {
+  makeSync,
+  makeScanAccounts,
+  GetAccountShape,
+  mergeOps,
+} from "../../bridge/jsHelpers";
 import { encodeAccountId } from "../../account";
 import { getAccountInfo } from "./api/Cosmos";
 import { pubkeyToAddress, decodeBech32Pubkey } from "@cosmjs/amino";
@@ -153,8 +158,6 @@ const txToOps = (info: any, id: string, txs: any): Operation[] => {
   return ops;
 };
 
-const postSync = (initial: Account, parent: Account) => parent;
-
 export const getAccountShape: GetAccountShape = async (info) => {
   const { address, currency, derivationMode, initialAccount } = info;
   let xpubOrAddress = address;
@@ -235,4 +238,5 @@ export const getAccountShape: GetAccountShape = async (info) => {
   return { ...shape, operations };
 };
 
-export const sync = makeSync(getAccountShape, postSync);
+export const scanAccounts = makeScanAccounts({ getAccountShape });
+export const sync = makeSync({ getAccountShape });

package/src/families/crypto_org/js-synchronisation.ts

@@ -1,4 +1,3 @@
-import type { Account } from "../../types";
 import { encodeAccountId } from "../../account";
 import type { GetAccountShape } from "../../bridge/jsHelpers";
 import { makeSync, makeScanAccounts, mergeOps } from "../../bridge/jsHelpers";
@@ -59,7 +58,5 @@ const getAccountShape: GetAccountShape = async (info) => {
   return { ...shape, operations };
 };
 
-const postSync = (initial: Account, parent: Account) => parent;
-
-export const scanAccounts = makeScanAccounts(getAccountShape);
-export const sync = makeSync(getAccountShape, postSync);
+export const scanAccounts = makeScanAccounts({ getAccountShape });
+export const sync = makeSync({ getAccountShape });

package/src/families/elrond/js-synchronisation.ts

@@ -1,4 +1,3 @@
-import type { Account } from "../../types";
 import { encodeAccountId } from "../../account";
 import type { GetAccountShape } from "../../bridge/jsHelpers";
 import { makeSync, makeScanAccounts, mergeOps } from "../../bridge/jsHelpers";
@@ -36,7 +35,5 @@ const getAccountShape: GetAccountShape = async (info) => {
   return { ...shape, operations };
 };
 
-const postSync = (initial: Account, parent: Account) => parent;
-
-export const scanAccounts = makeScanAccounts(getAccountShape);
-export const sync = makeSync(getAccountShape, postSync);
+export const scanAccounts = makeScanAccounts({ getAccountShape });
+export const sync = makeSync({ getAccountShape });

package/src/families/ethereum/bridge/js.ts

@@ -45,8 +45,8 @@ const broadcast = async ({
   return patchOperationWithHash(operation, hash);
 };
 
-const scanAccounts = makeScanAccounts(getAccountShape);
-const sync = makeSync(getAccountShape, postSyncPatch);
+const scanAccounts = makeScanAccounts({ getAccountShape });
+const sync = makeSync({ getAccountShape, postSync: postSyncPatch });
 
 const createTransaction = (): Transaction => ({
   family: "ethereum",

package/src/families/ethereum/synchronisation.ts

@@ -59,20 +59,23 @@ export const getAccountShape: GetAccountShape = async (
   const txsP = fetchAllTransactions(api, address, pullFromBlockHash);
   const currentBlockP = fetchCurrentBlock(currency);
   const balanceP = api.getAccountBalance(address);
-  const [txs, currentBlock] = await Promise.all([txsP, currentBlockP]);
+  const [txs, currentBlock, balance] = await Promise.all([
+    txsP,
+    currentBlockP,
+    balanceP,
+  ]);
   const blockHeight = currentBlock.height.toNumber();
 
   if (!pullFromBlockHash && txs.length === 0) {
     log("ethereum", "no ops on " + address);
     return {
       id: accountId,
-      balance: new BigNumber(0),
+      balance,
       subAccounts: [],
       blockHeight,
     };
   }
 
-  const balance = await balanceP;
   // transform transactions into operations
   let newOps = flatMap(txs, txToOps({ address, id: accountId, currency }));
   // extracting out the sub operations by token account

package/src/families/filecoin/bridge/account.ts

@@ -173,7 +173,7 @@ const prepareTransaction = async (
   return t;
 };
 
-const sync = makeSync(getAccountShape);
+const sync = makeSync({ getAccountShape });
 
 const broadcast: BroadcastFnSignature = async ({
   signedOperation: { operation, signature },

package/src/families/filecoin/bridge/currency.ts

@@ -2,7 +2,7 @@ import { makeScanAccounts } from "../../../bridge/jsHelpers";
 import { getAccountShape } from "./utils/utils";
 import { CurrencyBridge } from "../../../types";
 
-const scanAccounts = makeScanAccounts(getAccountShape);
+const scanAccounts = makeScanAccounts({ getAccountShape });
 
 export const currencyBridge: CurrencyBridge = {
   preload: () => Promise.resolve({}),

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

@@ -23,9 +23,10 @@ const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
     {
       title: "Value",
       button: "Rr",
-      expectedValue: ({ account, transaction }) =>
-        formatCurrencyUnit(account.unit, transaction.amount, {
+      expectedValue: ({ account, status }) =>
+        formatCurrencyUnit(account.unit, status.amount, {
           disableRounding: true,
+          showAllDigits: true,
         }),
     },
     {
@@ -39,6 +40,7 @@ const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
       expectedValue: ({ account, transaction }) =>
         formatCurrencyUnit(account.unit, transaction.gasPremium, {
           disableRounding: true,
+          showAllDigits: true,
         }),
     },
     {
@@ -47,10 +49,16 @@ const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
       expectedValue: ({ account, transaction }) =>
         formatCurrencyUnit(account.unit, transaction.gasFeeCap, {
           disableRounding: true,
+          showAllDigits: true,
         }),
     },
     {
-      title: "Approve",
+      title: "Method",
+      button: "Rr",
+      expectedValue: () => "Transfer",
+    },
+    {
+      title: "APPROVE",
       button: "LRlr",
     },
   ],

package/src/families/neo/bridge/js.ts

@@ -132,8 +132,8 @@ const getAccountShape = async (info) => {
   };
 };
 
-const scanAccounts = makeScanAccounts(getAccountShape);
-const sync = makeSync(getAccountShape);
+const scanAccounts = makeScanAccounts({ getAccountShape });
+const sync = makeSync({ getAccountShape });
 const currencyBridge: CurrencyBridge = {
   preload: () => Promise.resolve({}),
   hydrate: () => {},

package/src/families/polkadot/js-synchronisation.ts

@@ -54,9 +54,5 @@ const getAccountShape: GetAccountShape = async (info) => {
   return { ...shape, operations } as Partial<Account>;
 };
 
-const postSync = (_initial: Account, parent: Account) => {
-  return parent;
-};
-
-export const scanAccounts = makeScanAccounts(getAccountShape);
-export const sync = makeSync(getAccountShape, postSync);
+export const scanAccounts = makeScanAccounts({ getAccountShape });
+export const sync = makeSync({ getAccountShape });

package/src/families/solana/api/chain/index.ts

@@ -6,6 +6,7 @@ import {
 import {
   Connection,
   FeeCalculator,
+  FetchMiddleware,
   PublicKey,
   sendAndConfirmRawTransaction,
   SignaturesForAddressOptions,
@@ -57,8 +58,24 @@ export type ChainAPI = Readonly<{
   config: Config;
 }>;
 
-export function getChainAPI(config: Config): ChainAPI {
-  const connection = () => new Connection(config.endpoint, "finalized");
+export function getChainAPI(
+  config: Config,
+  logger?: (url: string, options: any) => void
+): ChainAPI {
+  const fetchMiddleware: FetchMiddleware | undefined =
+    logger === undefined
+      ? undefined
+      : (url, options, fetch) => {
+          logger(url, options);
+          fetch(url, options);
+        };
+
+  const connection = () => {
+    return new Connection(config.endpoint, {
+      commitment: "finalized",
+      fetchMiddleware,
+    });
+  };
 
   return {
     getBalance: (address: string) =>

package/src/families/solana/api/traced.ts

@@ -0,0 +1,99 @@
+import { log } from "@ledgerhq/logs";
+import { getEnv } from "../../../env";
+import { ChainAPI } from "./chain";
+
+export function traced(api: ChainAPI): ChainAPI {
+  const state = {
+    reqId: 0,
+    reqStartTime: new Map<number, number>(),
+  };
+
+  const startReqTrace = () => {
+    state.reqId += 1;
+    state.reqStartTime.set(state.reqId, Date.now());
+    return state.reqId;
+  };
+
+  const stopReqTrace = (reqId: number) => {
+    const reqStartTime = state.reqStartTime.get(reqId);
+    if (reqStartTime === undefined) {
+      log("warn", `request start time not found for request id <${reqId}>`);
+      return {
+        duration: 0,
+      };
+    }
+    state.reqStartTime.delete(reqId);
+    return {
+      duration: Date.now() - reqStartTime,
+    };
+  };
+
+  const proxy: ChainAPI = new Proxy(api, {
+    get(target, propKey, receiver) {
+      if (typeof propKey === "symbol") {
+        throw new Error("symbols not supported");
+      }
+      const targetValue = Reflect.get(target, propKey, receiver);
+      if (typeof targetValue === "function") {
+        return function (...args: unknown[]) {
+          const reqId = startReqTrace();
+          log("network", formatMsg({ reqId, msg: `calling <${propKey}>` }), {
+            args,
+          });
+          const result = targetValue.apply(this, args);
+          if (result instanceof Promise) {
+            return result
+              .then((answer) => {
+                const { duration } = stopReqTrace(reqId);
+                log(
+                  "network-success",
+                  formatMsg({ reqId, msg: "success", duration }),
+                  getEnv("DEBUG_HTTP_RESPONSE") ? { answer } : undefined
+                );
+                return answer;
+              })
+              .catch((error) => {
+                const { duration } = stopReqTrace(reqId);
+                log(
+                  "network-error",
+                  formatMsg({ reqId, msg: "error", duration }),
+                  { error }
+                );
+                throw error;
+              });
+          } else {
+            const { duration } = stopReqTrace(reqId);
+            log(
+              "info",
+              formatMsg({ reqId, msg: "sync result", duration }),
+              getEnv("DEBUG_HTTP_RESPONSE") ? { result } : undefined
+            );
+            return result;
+          }
+        };
+      } else {
+        return targetValue;
+      }
+    },
+  });
+
+  return proxy;
+}
+
+function formatMsg({
+  reqId,
+  msg,
+  duration,
+}: {
+  reqId: number;
+  msg?: string;
+  duration?: number;
+}) {
+  const parts = [
+    `solana req id: ${reqId}`,
+    msg ?? "",
+    duration === undefined ? "" : `took ${duration.toFixed(0)}ms`,
+  ];
+
+  return parts.join(", ");
+}

package/src/families/solana/bridge/bridge.ts

@@ -69,8 +69,8 @@ function makeSyncAndScan(getChainAPI: (config: Config) => Promise<ChainAPI>) {
     return getAccountShapeWithAPI(info, chainAPI);
   };
   return {
-    sync: makeSyncHelper(getAccountShape),
-    scan: makeScanHelper(getAccountShape),
+    sync: makeSyncHelper({ getAccountShape }),
+    scan: makeScanHelper({ getAccountShape }),
   };
 }
 

package/src/families/solana/bridge/js.ts

@@ -2,9 +2,20 @@ import { cached, Config, getChainAPI, queued } from "../api";
 import { makeLRUCache } from "../../../cache";
 import { makeBridges } from "./bridge";
 import { minutes } from "../api/cached";
+import { log } from "@ledgerhq/logs";
+import { traced } from "../api/traced";
+
+const httpRequestLogger = (url: string, options: any) => {
+  log("network", url, {
+    method: options?.method,
+    body: options?.body,
+    params: options?.params,
+  });
+};
 
 const getAPI = makeLRUCache(
-  (config: Config) => Promise.resolve(getChainAPI(config)),
+  (config: Config) =>
+    Promise.resolve(traced(getChainAPI(config, httpRequestLogger))),
   (config) => config.endpoint,
   minutes(1000)
 );

package/src/families/stellar/js-synchronization.ts

@@ -1,4 +1,3 @@
-import type { Account } from "../../types";
 import { encodeAccountId } from "../../account";
 import type { GetAccountShape } from "../../bridge/jsHelpers";
 import { makeScanAccounts, makeSync, mergeOps } from "../../bridge/jsHelpers";
@@ -32,9 +31,5 @@ const getAccountShape: GetAccountShape = async (info) => {
   return { ...shape, operations };
 };
 
-const postSync = (initial: Account, parent: Account) => {
-  return parent;
-};
-
-export const sync = makeSync(getAccountShape, postSync);
-export const scanAccounts = makeScanAccounts(getAccountShape);
+export const sync = makeSync({ getAccountShape });
+export const scanAccounts = makeScanAccounts({ getAccountShape });