@ledgerhq/live-common 21.31.0 → 21.32.3

package/src/api/Ethereum.ts

@@ -138,6 +138,7 @@ export const apiForCurrency = (currency: CryptoCurrency): API => {
             noinput: true,
             no_input: true,
             no_token: true,
+            filtering: true,
             block_hash,
           },
         }),

package/src/apps/logic.ts

@@ -1,7 +1,6 @@
 import { $Shape } from "utility-types";
 import { Subject } from "rxjs";
 import flatMap from "lodash/flatMap";
-import invariant from "invariant";
 import semver from "semver";
 import { getDeviceModel } from "@ledgerhq/devices";
 import type { App } from "../types/manager";
@@ -17,7 +16,7 @@ import {
   findCryptoCurrencyById,
   isCurrencySupported,
 } from "../currencies";
-import { LatestFirmwareVersionRequired } from "../errors";
+import { LatestFirmwareVersionRequired, NoSuchAppOnProvider } from "../errors";
 
 export const initState = (
   {
@@ -292,6 +291,7 @@ export const reducer = (state: State, action: Action): State => {
       // No app found but fw update is available
       if (
         !depApp &&
+        state.firmware?.updateAvailable?.final?.version &&
         semver.lt(
           state.deviceInfo.version,
           state.firmware?.updateAvailable?.final?.version
@@ -306,7 +306,10 @@ export const reducer = (state: State, action: Action): State => {
         );
       }
 
-      invariant(depApp, "no such app '%s'", name);
+      if (!depApp) {
+        throw new NoSuchAppOnProvider("", { appName: name });
+      }
+
       const deps = depApp.dependencies;
       const dependentsOfDep = flatMap(deps, (dep) =>
         findDependents(state.appByName, dep)

package/src/apps/polyfill.ts

@@ -53,6 +53,7 @@ export const whitelistDependencies = ["Decred", "Decred Testnet"];
   ["POAP", "Ethereum"],
   ["OlympusDAO", "Ethereum"],
   ["Rarible", "Ethereum"],
+  ["Ricochet", "Ethereum"],
 ].forEach(([name, dep]) => declareDep(name, dep));
 export const getDependencies = (appName: string): string[] =>
   directDep[appName] || [];

package/src/bot/engine.ts

@@ -81,6 +81,9 @@ export async function runWithAppSpec<T extends Transaction>(
   const mutationReports: MutationReport<T>[] = [];
   const { appQuery, currency, dependency } = spec;
   const appCandidate = findAppCandidate(appCandidates, appQuery);
+  if (!appCandidate) {
+    console.warn("no app found for " + spec.name, { appQuery, appCandidates });
+  }
   invariant(
     appCandidate,
     "%s: no app found. Are you sure your COINAPPS is up to date?",

package/src/errors.ts

@@ -141,6 +141,9 @@ export const SatStackDescriptorNotImported = createCustomErrorClass(
 export const SwapNoAvailableProviders = createCustomErrorClass(
   "SwapNoAvailableProviders"
 );
+export const NoSuchAppOnProvider = createCustomErrorClass(
+  "NoSuchAppOnProvider"
+);
 export const SwapExchangeRateAmountTooLow = createCustomErrorClass(
   "SwapExchangeRateAmountTooLow"
 );

package/src/exchange/platform/transfer/index.ts

@@ -32,7 +32,27 @@ const fundProviders: Record<
     curve: string;
   }
 > = {
-  // FIXME: no prod provider for now
+  baanx: {
+    /**
+     * nameAndPubkey is the concatenation of:
+     * - an empty buffer of the size of the partner name
+     * - a buffer created from the partner name string in ascii encoding
+     * - a buffer created from the hexadecimal version of the partner public key
+     */
+    nameAndPubkey: Buffer.concat([
+      Buffer.from([5]),
+      Buffer.from("Baanx", "ascii"),
+      Buffer.from(
+        "04551878b446b6a711949fa51cc5a8685602f8ffb1dfd08f6ab869019d7c125d7737a79e8b5022d860ec7dfbe062d510fec3b5fe0f6ebb1f5e55a074bb7e5dbc4e",
+        "hex"
+      ),
+    ]),
+    signature: Buffer.from(
+      "304402200345c39e93a22c5ac3f1e70f8b9938b3a60d3a4906067443cf11095af0e685a502201ee5d88dd5539ce36341e49e2505c2a1659e26d8ff08801ed33c50a9126aedd1",
+      "hex"
+    ),
+    curve: "secp256r1",
+  },
 };
 
 const getProvider = (

package/src/families/algorand/buildTransaction.ts

@@ -1,6 +1,5 @@
 import { encode as msgpackEncode } from "algo-msgpack-with-bigint";
 import type {
-  SuggestedParams as AlgoSuggestedParams,
   Transaction as AlgoTransaction,
   EncodedTransaction as AlgoTransactionPayload,
   EncodedSignedTransaction as AlgoSignedTransactionPayload,
@@ -28,8 +27,7 @@ export const buildTransactionPayload = async (
 
   const note = memo ? new TextEncoder().encode(memo) : undefined;
 
-  // Minor hack: cast the result as a algosdk.SuggestedParams, while it's actually a TransactionParametersResponse
-  const params = (await getTransactionParams()) as AlgoSuggestedParams;
+  const params = await getTransactionParams();
 
   let algoTxn: AlgoTransaction;
   if (subAccount || (assetId && mode === "optIn")) {
@@ -78,18 +76,16 @@ export const buildTransactionPayload = async (
   return sorted;
 };
 
-export const encodeToSign = async (
-  payload: AlgoTransactionPayload
-): Promise<string> => {
+export const encodeToSign = (payload: AlgoTransactionPayload): string => {
   const msgPackEncoded = msgpackEncode(payload);
 
   return Buffer.from(msgPackEncoded).toString("hex");
 };
 
-export const encodeToBroadcast = async (
+export const encodeToBroadcast = (
   payload: AlgoTransactionPayload,
   signature: Buffer
-): Promise<Buffer> => {
+): Buffer => {
   const signedPayload: AlgoSignedTransactionPayload = {
     sig: signature,
     txn: payload,

package/src/families/algorand/js-getFeesForTransaction.ts

@@ -17,7 +17,7 @@ export const getEstimatedFees = async (
   let suggestedFees = 0;
   if (params.fee) {
     const payload = await buildTransactionPayload(account, transaction);
-    const encoded = await encodeToSign(payload);
+    const encoded = encodeToSign(payload);
     suggestedFees =
       params.fee * (Buffer.from(encoded, "hex").length + SINGLE_SIGNATURE_SIZE);
   }

package/src/families/algorand/js-signOperation.ts

@@ -36,7 +36,7 @@ export const signOperation = ({
 
         const algoTx = await buildTransactionPayload(account, transaction);
 
-        const toSign = await encodeToSign(algoTx);
+        const toSign = encodeToSign(algoTx);
 
         const hwApp = new Algorand(transport);
         const { freshAddressPath } = account;
@@ -53,7 +53,7 @@ export const signOperation = ({
           throw new Error("No signature");
         }
 
-        const toBroadcast = await encodeToBroadcast(algoTx, signature);
+        const toBroadcast = encodeToBroadcast(algoTx, signature);
 
         const operation = buildOptimisticOperation(account, transaction);
 

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

@@ -291,6 +291,7 @@ const getAccountShape: GetAccountShape = async (
 
   const shape = {
     id: accountId,
+    xpub: address,
     blockHeight: round,
     balance,
     spendableBalance,

package/src/families/bitcoin/js-signOperation.ts

@@ -32,7 +32,7 @@ const signOperation = ({
       try {
         log("hw", `signTransaction ${currency.id} for account ${account.id}`);
         const txInfo = await buildTransaction(account, transaction);
-        let senders: string[] = [];
+        let senders = new Set<string>();
         let recipients: string[] = [];
         let fee = new BigNumber(0);
         // Maybe better not re-calculate these fields here, instead include them
@@ -41,9 +41,7 @@ const signOperation = ({
           account,
           transaction,
         }).then((res) => {
-          senders = res.txInputs
-            .map((i) => i.address)
-            .filter(Boolean) as string[];
+          senders = new Set(res.txInputs.map((i) => i.address).filter(Boolean));
           recipients = res.txOutputs
             .filter((o) => o.address && !o.isChange)
             .map((o) => o.address) as string[];
@@ -140,7 +138,7 @@ const signOperation = ({
           fee,
           blockHash: null,
           blockHeight: null,
-          senders,
+          senders: Array.from(senders),
           recipients,
           accountId: account.id,
           date: new Date(),

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

@@ -100,7 +100,7 @@ const mapTxToOperations = (
   const blockHeight = tx.block?.height;
   const blockHash = tx.block?.hash;
   const date = new Date(tx.block?.time || tx.received_at);
-  const senders: string[] = [];
+  const senders = new Set<string>();
   const recipients: string[] = [];
   let type: OperationType = "OUT";
   let value = new BigNumber(0);
@@ -111,7 +111,7 @@ const mapTxToOperations = (
 
   for (const input of tx.inputs) {
     if (input.address) {
-      senders.push(
+      senders.add(
         syncReplaceAddress ? syncReplaceAddress(input.address) : input.address
       );
 
@@ -195,7 +195,7 @@ const mapTxToOperations = (
       type,
       value,
       fee,
-      senders,
+      senders: Array.from(senders),
       recipients,
       blockHeight,
       blockHash,
@@ -229,7 +229,7 @@ const mapTxToOperations = (
         type,
         value,
         fee,
-        senders,
+        senders: Array.from(senders),
         recipients,
         blockHeight,
         blockHash,

package/src/families/bitcoin/wallet-btc/crypto/base.ts

@@ -84,14 +84,22 @@ class Base implements ICrypto {
   }
 
   // derive legacy address at account and index positions
-  getLegacyAddress(xpub: string, account: number, index: number): string {
+  protected getLegacyAddress(
+    xpub: string,
+    account: number,
+    index: number
+  ): string {
     const publicKeyBuffer: Buffer = this.getPubkeyAt(xpub, account, index);
     const publicKeyHash160: Buffer = bjs.crypto.hash160(publicKeyBuffer);
     return bjs.address.toBase58Check(publicKeyHash160, this.network.pubKeyHash);
   }
 
   // derive native SegWit at account and index positions
-  getNativeSegWitAddress(xpub: string, account: number, index: number): string {
+  private getNativeSegWitAddress(
+    xpub: string,
+    account: number,
+    index: number
+  ): string {
     const publicKeyBuffer: Buffer = this.getPubkeyAt(xpub, account, index);
     const publicKeyHash160: Buffer = bjs.crypto.hash160(publicKeyBuffer);
     const words: number[] = bech32.toWords(publicKeyHash160);
@@ -100,7 +108,11 @@ class Base implements ICrypto {
   }
 
   // derive SegWit at account and index positions
-  getSegWitAddress(xpub: string, account: number, index: number): string {
+  private getSegWitAddress(
+    xpub: string,
+    account: number,
+    index: number
+  ): string {
     const publicKeyBuffer: Buffer = this.getPubkeyAt(xpub, account, index);
     const redeemOutput: Buffer = bjs.script.compile([
       0,
@@ -129,28 +141,29 @@ class Base implements ICrypto {
         `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
       ];
     }
+    const res = this.customGetAddress(derivationMode, xpub, account, index);
+    Base.addressCache[
+      `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
+    ] = res;
+    return res;
+  }
+
+  customGetAddress(
+    derivationMode: string,
+    xpub: string,
+    account: number,
+    index: number
+  ): string {
     switch (derivationMode) {
       case DerivationModes.LEGACY:
-        Base.addressCache[
-          `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
-        ] = this.getLegacyAddress(xpub, account, index);
-        break;
+        return this.getLegacyAddress(xpub, account, index);
       case DerivationModes.SEGWIT:
-        Base.addressCache[
-          `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
-        ] = this.getSegWitAddress(xpub, account, index);
-        break;
+        return this.getSegWitAddress(xpub, account, index);
       case DerivationModes.NATIVE_SEGWIT:
-        Base.addressCache[
-          `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
-        ] = this.getNativeSegWitAddress(xpub, account, index);
-        break;
+        return this.getNativeSegWitAddress(xpub, account, index);
       default:
         throw new Error(`Invalid derivation Mode: ${derivationMode}`);
     }
-    return Base.addressCache[
-      `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
-    ];
   }
 
   // infer address type from its syntax

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

@@ -119,31 +119,17 @@ class Bitcoin extends Base {
   }
 
   // get address given an address type
-  getAddress(
+  customGetAddress(
     derivationMode: string,
     xpub: string,
     account: number,
     index: number
   ): string {
-    if (
-      Base.addressCache[
-        `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
-      ]
-    ) {
-      return Base.addressCache[
-        `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
-      ];
-    }
     switch (derivationMode) {
       case DerivationModes.TAPROOT:
-        Base.addressCache[
-          `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
-        ] = this.getTaprootAddress(xpub, account, index);
-        return Base.addressCache[
-          `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
-        ];
+        return this.getTaprootAddress(xpub, account, index);
       default:
-        return super.getAddress(derivationMode, xpub, account, index);
+        return super.customGetAddress(derivationMode, xpub, account, index);
     }
   }
 

package/src/families/bitcoin/wallet-btc/crypto/bitcoincash.ts

@@ -1,73 +1,44 @@
-// Fix the "More than one instance of bitcore-lib-cash" issue. Refer to https://github.com/bitpay/bitcore/issues/1457
-delete global._bitcoreCash;
-import * as bch from "bitcore-lib-cash";
 import bchaddr from "bchaddrjs";
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import { toOutputScript } from "bitcoinjs-lib/src/address";
 import { InvalidAddress } from "@ledgerhq/errors";
 import { DerivationModes } from "../types";
-import { ICrypto } from "./types";
 import Base from "./base";
 
 // a mock explorer class that just use js objects
-class BitcoinCash implements ICrypto {
+class BitcoinCash extends Base {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   network: any;
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   constructor({ network }: { network: any }) {
+    super({ network });
     this.network = network;
     this.network.dustThreshold = 5430;
     this.network.dustPolicy = "FIXED";
     this.network.usesTimestampedTransaction = false;
   }
 
-  // Based on https://github.com/go-faast/bitcoin-cash-payments/blob/54397eb97c7a9bf08b32e10bef23d5f27aa5ab01/index.js#L63-L73
   // eslint-disable-next-line
   getLegacyBitcoinCashAddress(
     xpub: string,
     account: number,
     index: number
   ): string {
-    const node = new bch.HDPublicKey(xpub);
-    const child = node.derive(account).derive(index);
-    const address = new bch.Address(child.publicKey, bch.Networks.livenet);
-    const addrstr = address.toString().split(":");
-    if (addrstr.length === 2) {
-      return bchaddr.toCashAddress(bchaddr.toLegacyAddress(addrstr[1]));
-    }
-    throw new Error(`Unable to derive cash address for ${address}`);
+    return bchaddr.toCashAddress(super.getLegacyAddress(xpub, account, index));
   }
 
   // get address given an address type
-  getAddress(
+  customGetAddress(
     derivationMode: string,
     xpub: string,
     account: number,
     index: number
   ): string {
-    if (
-      Base.addressCache[
-        `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
-      ]
-    ) {
-      return Base.addressCache[
-        `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
-      ];
-    }
-    const address = this.getLegacyBitcoinCashAddress(xpub, account, index);
-    Base.addressCache[
-      `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
-    ] = address;
-    return address;
+    return this.getLegacyBitcoinCashAddress(xpub, account, index);
   }
 
-  // infer address type from its syntax
-  //
-  // TODO: improve the prefix matching: make the expected prefix
-  // correspond to the actual type (currently, a `ltc1` prefix
-  // could match a native Bitcoin address type for instance)
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   getDerivationMode(address: string) {
     return DerivationModes.LEGACY;
@@ -85,11 +56,6 @@ class BitcoinCash implements ICrypto {
   validateAddress(address: string): boolean {
     return bchaddr.isValidAddress(address);
   }
-
-  // eslint-disable-next-line
-  isTaprootAddress(address: string): boolean {
-    return false;
-  }
 }
 
 export default BitcoinCash;

package/src/families/bitcoin/wallet-btc/crypto/decred.ts

@@ -68,21 +68,12 @@ class Decred extends Base {
   }
 
   // get address given an address type
-  getAddress(
+  customGetAddress(
     derivationMode: string,
     xpub: string,
     account: number,
     index: number
   ): string {
-    if (
-      Base.addressCache[
-        `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
-      ]
-    ) {
-      return Base.addressCache[
-        `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
-      ];
-    }
     let buffer: Buffer;
     try {
       buffer = Decred.bs58check.decode(xpub);
@@ -95,11 +86,7 @@ class Decred extends Base {
     const X = buffer.slice(45, 78);
     const hd = new BIP32(X, chainCode, this.network, depth, i);
     const publicKey = hd.derive(account).derive(index).publicKey;
-    const address = Decred.getAddressFromPk(publicKey);
-    Base.addressCache[
-      `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
-    ] = address;
-    return address;
+    return Decred.getAddressFromPk(publicKey);
   }
 }
 

package/src/families/bitcoin/wallet-btc/crypto/litecoin.ts

@@ -1,15 +1,12 @@
-import * as bjs from "bitcoinjs-lib";
-import * as bip32 from "bip32";
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import { toOutputScript } from "bitcoinjs-lib/src/address";
 import * as bech32 from "bech32";
 import { DerivationModes } from "../types";
-import { ICrypto } from "./types";
 import Base from "./base";
 
 // Todo copy paste from bitcoin.ts. we can merge them later
-class Litecoin extends Base implements ICrypto {
+class Litecoin extends Base {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   network: any;
 
@@ -21,73 +18,6 @@ class Litecoin extends Base implements ICrypto {
     this.network.usesTimestampedTransaction = false;
   }
 
-  getLegacyAddress(xpub: string, account: number, index: number): string {
-    const { address } = bjs.payments.p2pkh({
-      pubkey: bip32.fromBase58(xpub, this.network).derive(account).derive(index)
-        .publicKey,
-      network: this.network,
-    });
-    return String(address);
-  }
-
-  getSegWitAddress(xpub: string, account: number, index: number): string {
-    const { address } = bjs.payments.p2sh({
-      redeem: bjs.payments.p2wpkh({
-        pubkey: bip32
-          .fromBase58(xpub, this.network)
-          .derive(account)
-          .derive(index).publicKey,
-        network: this.network,
-      }),
-    });
-    return String(address);
-  }
-
-  getNativeSegWitAddress(xpub: string, account: number, index: number): string {
-    const { address } = bjs.payments.p2wpkh({
-      pubkey: bip32.fromBase58(xpub, this.network).derive(account).derive(index)
-        .publicKey,
-      network: this.network,
-    });
-
-    return String(address);
-  }
-
-  getAddress(
-    derivationMode: DerivationModes,
-    xpub: string,
-    account: number,
-    index: number
-  ): string {
-    if (
-      Base.addressCache[
-        `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
-      ]
-    ) {
-      return Base.addressCache[
-        `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
-      ];
-    }
-    let address: string;
-    switch (derivationMode) {
-      case DerivationModes.LEGACY:
-        address = this.getLegacyAddress(xpub, account, index);
-        break;
-      case DerivationModes.SEGWIT:
-        address = this.getSegWitAddress(xpub, account, index);
-        break;
-      case DerivationModes.NATIVE_SEGWIT:
-        address = this.getNativeSegWitAddress(xpub, account, index);
-        break;
-      default:
-        throw new Error("Should not be reachable");
-    }
-    Base.addressCache[
-      `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
-    ] = address;
-    return address;
-  }
-
   // infer address type from its syntax
   getDerivationMode(address: string) {
     if (address.match("^(ltc1).*")) {

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

@@ -7,6 +7,13 @@ export interface ICrypto {
     account: number,
     index: number
   ): string;
+  customGetAddress(
+    derivationMode: string,
+    xpub: string,
+    account: number,
+    index: number
+  ): string;
+
   getDerivationMode(address: string): string;
 
   toOutputScript(address: string): Buffer;

package/src/families/bitcoin/wallet-btc/crypto/zec.ts

@@ -8,15 +8,15 @@ import bs58check from "bs58check";
 import coininfo from "coininfo";
 import { InvalidAddress } from "@ledgerhq/errors";
 import { DerivationModes } from "../types";
-import { ICrypto } from "./types";
 import Base from "./base";
 
-class ZCash implements ICrypto {
+class ZCash extends Base {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   network: any;
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   constructor({ network }: { network: any }) {
+    super({ network });
     this.network = network;
     this.network.dustThreshold = 10000;
     this.network.dustPolicy = "FIXED";
@@ -47,26 +47,13 @@ class ZCash implements ICrypto {
     return address.toString();
   }
 
-  getAddress(
+  customGetAddress(
     derivationMode: string,
     xpub: string,
     account: number,
     index: number
   ): string {
-    if (
-      Base.addressCache[
-        `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
-      ]
-    ) {
-      return Base.addressCache[
-        `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
-      ];
-    }
-    const address = this.getLegacyAddress(xpub, account, index);
-    Base.addressCache[
-      `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
-    ] = address;
-    return address;
+    return this.getLegacyAddress(xpub, account, index);
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -89,11 +76,6 @@ class ZCash implements ICrypto {
   validateAddress(address: string): boolean {
     return zec.Address.isValid(address, "livenet");
   }
-
-  // eslint-disable-next-line
-  isTaprootAddress(address: string): boolean {
-    return false;
-  }
 }
 
 export default ZCash;