@ledgerhq/live-common 21.23.0 → 21.25.1

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

@@ -1,4 +1,5 @@
 import { findLast, filter, uniqBy, findIndex, has } from "lodash";
+import Base from "../crypto/base";
 import { Input, IStorage, Output, TX, Address } from "./types";
 
 // a mock storage class that just use js objects
@@ -12,12 +13,14 @@ class BitcoinLikeStorage implements IStorage {
   // accounting
   unspentUtxos: { [key: string]: Output[] } = {};
 
+  addressCache: { [key: string]: string } = {};
+
   // only needed to handle the case when the input
   // is seen before the output (typically explorer
   // returning unordered tx within the same block)
   spentUtxos: { [key: string]: Input[] } = {};
 
-  async getLastTx(txFilter: {
+  getLastTx(txFilter: {
     account?: number;
     index?: number;
     address?: string;
@@ -38,18 +41,18 @@ class BitcoinLikeStorage implements IStorage {
     return tx;
   }
 
-  async getTx(address: string, hash: string) {
+  getTx(address: string, hash: string) {
     const index = `${address}-${hash}`;
     return this.txs[this.primaryIndex[index]];
   }
 
   // TODO: only expose unspentUtxos
-  async getAddressUnspentUtxos(address: Address) {
+  getAddressUnspentUtxos(address: Address) {
     const indexAddress = address.address;
     return this.unspentUtxos[indexAddress];
   }
 
-  async appendTxs(txs: TX[]) {
+  appendTxs(txs: TX[]) {
     const lastLength = this.txs.length;
 
     txs.forEach((tx) => {
@@ -97,10 +100,7 @@ class BitcoinLikeStorage implements IStorage {
     return this.txs.length - lastLength;
   }
 
-  async getUniquesAddresses(addressesFilter: {
-    account?: number;
-    index?: number;
-  }) {
+  getUniquesAddresses(addressesFilter: { account?: number; index?: number }) {
     // TODO: to speed up, create more useful indexes in appendTxs
     return uniqBy(
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -114,7 +114,7 @@ class BitcoinLikeStorage implements IStorage {
     );
   }
 
-  async removeTxs(txsFilter: { account: number; index: number }) {
+  removeTxs(txsFilter: { account: number; index: number }) {
     const newTxs: TX[] = [];
     this.primaryIndex = {};
 
@@ -137,7 +137,7 @@ class BitcoinLikeStorage implements IStorage {
 
   // We are a bit ugly because we can't rely undo unspentUTXO
   // So we clean the address and rebuild without the pendings
-  async removePendingTxs(txsFilter: { account: number; index: number }) {
+  removePendingTxs(txsFilter: { account: number; index: number }) {
     const newTxs: TX[] = [];
     const txsToReAdd: TX[] = [];
     this.primaryIndex = {};
@@ -161,7 +161,14 @@ class BitcoinLikeStorage implements IStorage {
     });
 
     this.txs = newTxs;
-    await this.appendTxs(txsToReAdd);
+    this.appendTxs(txsToReAdd);
+  }
+
+  addAddress(key: string, address: string): void {
+    if (!this.addressCache) {
+      this.addressCache = {};
+    }
+    this.addressCache[key] = address;
   }
 
   exportSync() {
@@ -169,6 +176,7 @@ class BitcoinLikeStorage implements IStorage {
       txs: this.txs,
       primaryIndex: this.primaryIndex,
       unspentUtxos: this.unspentUtxos,
+      addressCache: this.addressCache,
     };
   }
 
@@ -176,10 +184,13 @@ class BitcoinLikeStorage implements IStorage {
     txs: TX[];
     primaryIndex: { [key: string]: number };
     unspentUtxos: { [key: string]: Output[] };
+    addressCache: { [key: string]: string };
   }) {
     this.txs = data.txs;
     this.primaryIndex = data.primaryIndex;
     this.unspentUtxos = data.unspentUtxos;
+    this.addressCache = data.addressCache;
+    Base.addressCache = { ...Base.addressCache, ...this.addressCache };
   }
 
   async export() {
@@ -190,6 +201,7 @@ class BitcoinLikeStorage implements IStorage {
     txs: TX[];
     primaryIndex: { [key: string]: number };
     unspentUtxos: { [key: string]: Output[] };
+    addressCache: { [key: string]: string };
   }) {
     return this.loadSync(data);
   }

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

@@ -43,24 +43,22 @@ export interface Address {
 }
 
 export interface IStorage {
-  appendTxs(txs: TX[]): Promise<number>;
-  getAddressUnspentUtxos(address: Address): Promise<Output[]>;
+  appendTxs(txs: TX[]): number;
+  getAddressUnspentUtxos(address: Address): Output[];
   getLastTx(txFilter: {
     account?: number;
     index?: number;
     address?: string;
     confirmed?: boolean;
-  }): Promise<TX | undefined>;
-  getTx(address: string, hash: string): Promise<TX | undefined>;
+  }): TX | undefined;
+  getTx(address: string, hash: string): TX | undefined;
   getUniquesAddresses(addressesFilter: {
     account?: number;
     index?: number;
-  }): Promise<Address[]>;
-  removeTxs(txsFilter: { account: number; index: number }): Promise<void>;
-  removePendingTxs(txsFilter: {
-    account: number;
-    index: number;
-  }): Promise<void>;
+  }): Address[];
+  removeTxs(txsFilter: { account: number; index: number }): void;
+  removePendingTxs(txsFilter: { account: number; index: number }): void;
+  addAddress(key: string, address: string): void;
   export(): Promise<unknown>;
   load(data: unknown): Promise<void>;
   exportSync(): unknown;

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

@@ -66,6 +66,10 @@ class Xpub extends EventEmitter {
       index
     );
 
+    this.storage.addAddress(
+      `${this.derivationMode}-${this.xpub}-${account}-${index}`,
+      address
+    );
     await this.whenSynced("address", address);
 
     const data = {
@@ -87,13 +91,13 @@ class Xpub extends EventEmitter {
 
       // in case pendings have changed we clean them out
       // TODO perf : bad : looping in the tx array
-      const hasPendings = !!(await this.storage.getLastTx({
+      const hasPendings = !!this.storage.getLastTx({
         confirmed: false,
         account,
         index,
-      }));
+      });
       if (hasPendings) {
-        await this.storage.removePendingTxs({ account, index });
+        this.storage.removePendingTxs({ account, index });
       }
       total = await this.fetchHydrateAndStoreNewTxs(address, account, index);
     } catch (e) {
@@ -103,7 +107,7 @@ class Xpub extends EventEmitter {
 
     this.emitSynced({ ...data, total });
 
-    const lastTx = await this.storage.getLastTx({
+    const lastTx = this.storage.getLastTx({
       account,
       index,
     });
@@ -200,7 +204,7 @@ class Xpub extends EventEmitter {
   async getAddressBalance(address: Address) {
     await this.whenSynced("address", address.address);
 
-    const unspentUtxos = await this.storage.getAddressUnspentUtxos(address);
+    const unspentUtxos = this.storage.getAddressUnspentUtxos(address);
 
     return unspentUtxos.reduce(
       (total, { value }) => total.plus(value),
@@ -419,7 +423,7 @@ class Xpub extends EventEmitter {
     let txs: TX[] = [];
     let inserted = 0;
     do {
-      const lastTx = await this.storage.getLastTx({
+      const lastTx = this.storage.getLastTx({
         account,
         index,
         confirmed: true,
@@ -433,14 +437,14 @@ class Xpub extends EventEmitter {
       if (pendingTxs.length === 0) {
         pendingTxs = txs.filter((tx) => !tx.block);
       }
-      inserted += await this.storage.appendTxs(txs.filter((tx) => tx.block)); // only insert not pending tx
+      inserted += this.storage.appendTxs(txs.filter((tx) => tx.block)); // only insert not pending tx
     } while (txs.length - pendingTxs.length >= this.txsSyncArraySize); // check whether page is full, if not, it is the last page
-    inserted += await this.storage.appendTxs(pendingTxs);
+    inserted += this.storage.appendTxs(pendingTxs);
     return inserted;
   }
 
   async checkAddressReorg(account: number, index: number) {
-    const lastTx = await this.storage.getLastTx({
+    const lastTx = this.storage.getLastTx({
       account,
       index,
       confirmed: true,
@@ -462,7 +466,7 @@ class Xpub extends EventEmitter {
     // TODO: delete only everything for this (address, block)
     // but need to think if its possible with current storage implem
 
-    await this.storage.removeTxs({
+    this.storage.removeTxs({
       account,
       index,
     });

package/src/families/crypto_org/deviceTransactionConfig.ts

@@ -0,0 +1,52 @@
+import type { AccountLike, Account, TransactionStatus } from "../../types";
+import type { Transaction } from "./types";
+import type { DeviceTransactionField } from "../../transaction";
+
+function getDeviceTransactionConfig({
+  transaction,
+  status: { estimatedFees },
+}: {
+  account: AccountLike;
+  parentAccount?: Account;
+  transaction: Transaction;
+  status: TransactionStatus;
+}): Array<DeviceTransactionField> {
+  const fields: Array<DeviceTransactionField> = [];
+
+  if (transaction.useAllAmount) {
+    fields.push({
+      type: "text",
+      label: "Method",
+      value: "Send all",
+    });
+  } else {
+    fields.push({
+      type: "text",
+      label: "Method",
+      value: "Send",
+    });
+    fields.push({
+      type: "amount",
+      label: "Amount",
+    });
+  }
+
+  if (!estimatedFees.isZero()) {
+    fields.push({
+      type: "fees",
+      label: "Fees",
+    });
+  }
+
+  if (transaction.memo) {
+    fields.push({
+      type: "text",
+      label: "Memo",
+      value: transaction.memo,
+    });
+  }
+
+  return fields;
+}
+
+export default getDeviceTransactionConfig;

package/src/families/ethereum/modules/compound.ts

@@ -160,6 +160,8 @@ const compoundSupply: ModeModule = {
       ];
     }
   },
+
+  getResolutionConfig: () => ({ erc20: true, externalPlugins: true }),
 };
 
 /**

package/src/families/ethereum/modules/erc1155.ts

@@ -122,6 +122,8 @@ const erc1155Transfer: ModeModule = {
   },
 
   prepareTransaction,
+
+  getResolutionConfig: () => ({ nft: true }),
 };
 
 function serializeTransactionData(

package/src/families/ethereum/modules/erc20.ts

@@ -138,6 +138,8 @@ const erc20approve: ModeModule = {
   fillOptimisticOperation(_account, _transaction, operation) {
     operation.type = "FEES";
   },
+
+  getResolutionConfig: () => ({ erc20: true, externalPlugins: true }),
 };
 export const modes: Record<Modes, ModeModule> = {
   "erc20.approve": erc20approve,

package/src/families/ethereum/modules/erc721.ts

@@ -119,6 +119,8 @@ const erc721Transfer: ModeModule = {
   fillOptimisticOperation(a, t, op) {
     op.type = "FEES";
   },
+
+  getResolutionConfig: () => ({ nft: true }),
 };
 
 function serializeTransactionData(

package/src/families/ethereum/modules/index.ts

@@ -20,6 +20,8 @@ import type { Modes as ERC20Modes } from "./erc20";
 import type { Modes as SendModes } from "./send";
 import type { Modes as ERC721Modes } from "./erc721";
 import type { Modes as ERC1155Modes } from "./erc1155";
+import { ResolutionConfig } from "@ledgerhq/hw-app-eth/lib/services/types";
+
 const modules = {
   erc20,
   compound,
@@ -98,6 +100,14 @@ export type ModeModule = {
     account: Account,
     transaction: Transaction
   ) => Promise<Transaction>;
+
+  /**
+   * tells what needs to be resolved in the transaction
+   */
+  getResolutionConfig?: (
+    account: Account,
+    transaction: Transaction
+  ) => ResolutionConfig;
 };
 export const modes: Record<TransactionMode, ModeModule> = {} as Record<
   TransactionMode,

package/src/families/ethereum/signOperation.ts

@@ -7,6 +7,7 @@ import { log } from "@ledgerhq/logs";
 import { FeeNotLoaded } from "@ledgerhq/errors";
 import Eth from "@ledgerhq/hw-app-eth";
 import { byContractAddressAndChainId } from "@ledgerhq/hw-app-eth/erc20";
+import ethLedgerServices from "@ledgerhq/hw-app-eth/lib/services/ledger";
 import type { Transaction } from "./types";
 import type { Operation, Account, SignOperationEvent } from "../../types";
 import { getGasLimit, buildEthereumTx } from "./transaction";
@@ -15,6 +16,7 @@ import { withDevice } from "../../hw/deviceAccess";
 import { modes } from "./modules";
 import { isNFTActive } from "../../nft";
 import { getEnv } from "../../env";
+import { LoadConfig } from "@ledgerhq/hw-app-eth/lib/services/types";
 export const signOperation = ({
   account,
   deviceId,
@@ -61,13 +63,31 @@ export const signOperation = ({
               const value = new BigNumber(
                 "0x" + (tx.value.toString("hex") || "0")
               );
-              const eth = new Eth(transport);
+
+              const txHex = tx.serialize().toString("hex");
+
+              const loadConfig: LoadConfig = {};
               if (isNFTActive(account.currency)) {
-                eth.setLoadConfig({
-                  nftExplorerBaseURL:
-                    getEnv("NFT_ETH_METADATA_SERVICE") + "/v1/ethereum",
-                });
+                loadConfig.nftExplorerBaseURL =
+                  getEnv("NFT_ETH_METADATA_SERVICE") + "/v1/ethereum";
               }
+
+              const m = modes[transaction.mode];
+              invariant(m, "missing module for mode=" + transaction.mode);
+
+              const resolutionConfig = m.getResolutionConfig
+                ? m.getResolutionConfig(account, transaction)
+                : {};
+
+              const resolution = await ethLedgerServices.resolveTransaction(
+                txHex,
+                loadConfig,
+                resolutionConfig
+              );
+
+              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 &&
@@ -91,7 +111,8 @@ export const signOperation = ({
               });
               const result = await eth.signTransaction(
                 freshAddressPath,
-                tx.serialize().toString("hex")
+                txHex,
+                resolution
               );
               if (cancelled) return;
               o.next({
@@ -131,8 +152,6 @@ export const signOperation = ({
                 date: new Date(),
                 extra: {},
               };
-              const m = modes[transaction.mode];
-              invariant(m, "missing module for mode=" + transaction.mode);
               m.fillOptimisticOperation(account, transaction, operation);
               o.next({
                 type: "signed",

package/src/families/polkadot/address.ts

@@ -1,4 +1,5 @@
-import { decodeAddress } from "@polkadot/util-crypto";
+import { encodeAddress, decodeAddress } from "@polkadot/util-crypto";
+import { hexToU8a, isHex } from "@polkadot/util";
 
 const POLKADOT_SS58_PREFIX = 0;
 
@@ -7,6 +8,7 @@ const POLKADOT_SS58_PREFIX = 0;
  *
  * @param {*} address
  */
+// TODO Cache this to improve perf
 export const isValidAddress = (
   address: string,
   ss58Format: number = POLKADOT_SS58_PREFIX
@@ -14,7 +16,11 @@ export const isValidAddress = (
   if (!address) return false;
 
   try {
-    decodeAddress(address, false, ss58Format);
+    encodeAddress(
+      isHex(address)
+        ? hexToU8a(address)
+        : decodeAddress(address, false, ss58Format)
+    );
     return true;
   } catch (err) {
     return false;

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

@@ -58,7 +58,9 @@ const getSendTransactionStatus = async (
   } else if (a.freshAddress === t.recipient) {
     errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
   } else if (!isValidAddress(t.recipient)) {
-    errors.recipient = new InvalidAddress("");
+    errors.recipient = new InvalidAddress("", {
+      currencyName: a.currency.name,
+    });
   }
 
   const estimatedFees = t.fees || new BigNumber(0);
@@ -181,7 +183,9 @@ const getTransactionStatus = async (a: Account, t: Transaction) => {
         if (!t.recipient) {
           errors.recipient = new RecipientRequired("");
         } else if (!isValidAddress(t.recipient)) {
-          errors.recipient = new InvalidAddress("");
+          errors.recipient = new InvalidAddress("", {
+            currencyName: a.currency.name,
+          });
         } else if (await isControllerAddress(t.recipient)) {
           errors.recipient = new PolkadotUnauthorizedOperation(
             "Recipient is already a controller"

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

@@ -182,11 +182,14 @@ const prepareTransaction = async (
     },
   });
 
+  const t: Transaction = { ...transaction, taquitoError: null };
+
+  let amount = transaction.amount;
   if (transaction.useAllAmount) {
     // taquito does not accept 0, so we do 1
     // only failing case is when the account precisely has fees + 1. which is
     // unlikely
-    transaction.amount = new BigNumber(1);
+    amount = new BigNumber(1);
   }
 
   try {
@@ -196,7 +199,7 @@ const prepareTransaction = async (
         out = await tezos.estimate.transfer({
           mutez: true,
           to: transaction.recipient,
-          amount: transaction.amount.toNumber(),
+          amount: amount.toNumber(),
         });
         break;
       case "delegate":
@@ -214,7 +217,7 @@ const prepareTransaction = async (
         throw new Error("unsupported mode=" + transaction.mode);
     }
 
-    if (transaction.useAllAmount) {
+    if (t.useAllAmount) {
       const totalFees = out.suggestedFeeMutez + out.burnFeeMutez;
       const maxAmount = account.balance
         .minus(totalFees + (tezosResources.revealed ? 0 : DEFAULT_FEE.REVEAL))
@@ -228,41 +231,59 @@ const prepareTransaction = async (
         return gasBuffer * MINIMAL_FEE_PER_GAS_MUTEZ + opSize;
       };
       const incr = increasedFee(gasBuffer, Number(out.opSize));
-      transaction.fees = new BigNumber(out.suggestedFeeMutez + incr);
-      transaction.gasLimit = new BigNumber(out.gasLimit + gasBuffer);
-      transaction.amount = new BigNumber(maxAmount - incr);
+      t.fees = new BigNumber(out.suggestedFeeMutez + incr);
+      t.gasLimit = new BigNumber(out.gasLimit + gasBuffer);
+      t.amount = new BigNumber(maxAmount - incr);
     } else {
-      transaction.fees = new BigNumber(out.suggestedFeeMutez);
-      transaction.gasLimit = new BigNumber(out.gasLimit);
-      transaction.storageLimit = new BigNumber(out.storageLimit);
+      t.fees = new BigNumber(out.suggestedFeeMutez);
+      t.gasLimit = new BigNumber(out.gasLimit);
+      t.storageLimit = new BigNumber(out.storageLimit);
     }
 
-    transaction.storageLimit = new BigNumber(out.storageLimit);
-    transaction.estimatedFees = transaction.fees;
+    t.storageLimit = new BigNumber(out.storageLimit);
+    t.estimatedFees = t.fees;
     if (!tezosResources.revealed) {
-      transaction.estimatedFees = transaction.estimatedFees.plus(
-        DEFAULT_FEE.REVEAL
-      );
+      t.estimatedFees = t.estimatedFees.plus(DEFAULT_FEE.REVEAL);
     }
   } catch (e) {
     if (typeof e !== "object" || !e) throw e;
     if ("id" in e) {
-      transaction.taquitoError = (e as { id: string }).id;
+      t.taquitoError = (e as { id: string }).id;
     } else if ("status" in e) {
       // in case of http 400, log & ignore (more case to handle)
       log(
         "taquito-network-error",
         String((e as { message: string }).message || ""),
-        { transaction }
+        { transaction: t }
       );
     } else {
       throw e;
     }
   }
 
-  return transaction;
+  // nothing changed
+  if (
+    bnEq(t.fees, transaction.fees) &&
+    bnEq(t.fees, transaction.fees) &&
+    bnEq(t.gasLimit, transaction.gasLimit) &&
+    bnEq(t.amount, transaction.amount) &&
+    bnEq(t.storageLimit, transaction.storageLimit) &&
+    bnEq(t.estimatedFees, transaction.estimatedFees) &&
+    t.taquitoError === transaction.taquitoError
+  ) {
+    return transaction;
+  }
+
+  return t;
 };
 
+function bnEq(
+  a: BigNumber | null | undefined,
+  b: BigNumber | null | undefined
+): boolean {
+  return !a && !b ? true : !a || !b ? false : a.eq(b);
+}
+
 const estimateMaxSpendable = async ({
   account,
   parentAccount,

package/src/families/tezos/signOperation.ts

@@ -8,6 +8,8 @@ import type { Account, SignOperationEvent } from "../../types";
 import { withDevice } from "../../hw/deviceAccess";
 import { getEnv } from "../../env";
 import { FeeNotLoaded } from "@ledgerhq/errors";
+import { upperModulo } from "../../modulo";
+import BigNumber from "bignumber.js";
 
 export const signOperation = ({
   account,
@@ -53,6 +55,16 @@ export const signOperation = ({
           storageLimit: transaction.storageLimit?.toNumber() || 0,
           gasLimit: transaction.gasLimit?.toNumber() || 0,
         };
+
+        if (["delegate", "undelegate"].includes(transaction.mode)) {
+          // https://ledgerhq.atlassian.net/browse/LL-8821
+          params.gasLimit = upperModulo(
+            transaction.gasLimit || new BigNumber(0),
+            new BigNumber(136),
+            new BigNumber(1000)
+          ).toNumber();
+        }
+
         switch (transaction.mode) {
           case "send":
             res = await tezos.contract.transfer({

package/src/families/tezos/synchronisation.ts

@@ -226,7 +226,7 @@ const txToOp =
     }
 
     return {
-      id: encodeOperationId(accountId, hash, type),
+      id: encodeOperationId(accountId, hash + String(tx.id), type),
       hash,
       type,
       value,

package/src/generated/deviceTransactionConfig.ts

@@ -4,6 +4,8 @@ import bitcoin from "../families/bitcoin/deviceTransactionConfig";
 
 import cosmos from "../families/cosmos/deviceTransactionConfig";
 
+import crypto_org from "../families/crypto_org/deviceTransactionConfig";
+
 import elrond from "../families/elrond/deviceTransactionConfig";
 
 import ethereum from "../families/ethereum/deviceTransactionConfig";
@@ -25,6 +27,7 @@ export default {
   algorand,
   bitcoin,
   cosmos,
+  crypto_org,
   elrond,
   ethereum,
   polkadot,

package/src/hw/actions/transaction.ts

@@ -17,7 +17,7 @@ import { getMainAccount } from "../../account";
 import { getAccountBridge } from "../../bridge";
 import type { ConnectAppEvent, Input as ConnectAppInput } from "../connectApp";
 import type { Action, Device } from "./types";
-import type { AppState } from "./app";
+import type { AppRequest, AppState } from "./app";
 import { createAction as createAppAction } from "./app";
 type State = {
   signedOperation: SignedOperation | null | undefined;
@@ -33,6 +33,8 @@ type TransactionRequest = {
   transaction: Transaction;
   status: TransactionStatus;
   appName?: string;
+  dependencies?: AppRequest[];
+  requireLatestFirmware?: boolean;
 };
 type TransactionResult =
   | {
@@ -112,7 +114,8 @@ export const createAction = (
     reduxDevice: Device | null | undefined,
     txRequest: TransactionRequest
   ): TransactionState => {
-    const { transaction, appName } = txRequest;
+    const { transaction, appName, dependencies, requireLatestFirmware } =
+      txRequest;
     const mainAccount = getMainAccount(
       txRequest.account,
       txRequest.parentAccount
@@ -120,6 +123,8 @@ export const createAction = (
     const appState = createAppAction(connectAppExec).useHook(reduxDevice, {
       account: mainAccount,
       appName,
+      dependencies,
+      requireLatestFirmware,
     });
     const { device, opened, inWrongDeviceForAccount, error } = appState;
     const [state, setState] = useState(initialState);