@ledgerhq/live-common 21.35.0 → 21.36.2

package/src/exchange/swap/getCompleteSwapHistory.ts

@@ -113,7 +113,7 @@ const getCompleteSwapHistory = (
       day = startOfDay(swap.operation.date);
       data = [swap];
       continue;
-    } else if (!skip) {
+    } else if (!skip && !data.find((d) => d.swapId === swap.swapId)) {
       data.push(swap);
     }
 

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

@@ -426,9 +426,5 @@ async function buildSubAccounts({
   return tokenAccounts;
 }
 
-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/bitcoin/js-synchronisation.ts

@@ -408,5 +408,8 @@ const getAddressFn = (transport) => {
   return (opts) => getAddressWithBtcInstance(transport, btc, opts);
 };
 
-export const scanAccounts = makeScanAccounts(getAccountShape, getAddressFn);
-export const sync = makeSync(getAccountShape, postSync);
+export const scanAccounts = makeScanAccounts({
+  getAccountShape,
+  getAddressFn,
+});
+export const sync = makeSync({ getAccountShape, postSync });

package/src/families/bitcoin/specs.ts

@@ -96,7 +96,8 @@ const genericTest = ({
   // verify that no utxo that was supposed to be exploded were used
   expect(
     utxosPicked.filter(
-      (u) => getUTXOStatus(u, transaction.utxoStrategy).excluded
+      (u: BitcoinOutput) =>
+        u.blockHeight && getUTXOStatus(u, transaction.utxoStrategy).excluded
     )
   ).toEqual([]);
 };
@@ -256,7 +257,7 @@ const bitcoinLikeMutations = ({
     test: ({ account }) => {
       expect(
         account.bitcoinResources?.utxos
-          .filter((u) => u.blockHeight) // Exclude pending UTXOs
+          .filter((u) => u.blockHeight && u.blockHeight < account.blockHeight) // Exclude pending UTXOs and the Utxos just written into new block
           .reduce((p, c) => p.plus(c.value), new BigNumber(0))
           .toString()
       ).toBe("0");

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

@@ -29,9 +29,8 @@ export function fallbackValidateAddress(address: string): boolean {
 class Base implements ICrypto {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   network: any;
-  protected static publickeyCache = {}; // xpub + account + index to publicKey
+  protected static bip32Cache = {}; // xpub + account + index to publicKey
   public static addressCache = {}; // derivationMode + xpub + account + index to address
-  protected static bech32Cache = {}; // xpub to bech32 interface
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   constructor({ network }: { network: any }) {
@@ -41,14 +40,24 @@ class Base implements ICrypto {
     this.network.usesTimestampedTransaction = false;
   }
 
-  protected getPubkeyAt(xpub: string, account: number, index: number): Buffer {
-    if (!Base.bech32Cache[`${this.network.name}-${xpub}`]) {
+  protected async getPubkeyAt(
+    xpub: string,
+    account: number,
+    index: number
+  ): Promise<Buffer> {
+    // a cache is stored in Base.bip32Cache to optimize the calculation
+    // at each step, we make sure the level has been calculated and calc if necessary
+
+    // 0: root level
+    const keyRoot = `${this.network.name}-${xpub}`;
+    let rootLevel = Base.bip32Cache[keyRoot]; // it's stored "in sync"
+    if (!rootLevel) {
       const buffer: Buffer = bs58.decode(xpub);
       const depth: number = buffer[4];
       const i: number = buffer.readUInt32BE(9);
       const chainCode: Buffer = buffer.slice(13, 45);
       const publicKey: Buffer = buffer.slice(45, 78);
-      Base.bech32Cache[`${this.network.name}-${xpub}`] = new BIP32(
+      Base.bip32Cache[keyRoot] = rootLevel = new BIP32(
         publicKey,
         chainCode,
         this.network,
@@ -56,51 +65,53 @@ class Base implements ICrypto {
         i
       );
     }
-    if (
-      Base.publickeyCache[`${this.network.name}-${xpub}-${account}-${index}`]
-    ) {
-      return Base.publickeyCache[
-        `${this.network.name}-${xpub}-${account}-${index}`
-      ];
+
+    // 1: account level
+    const keyAccount = `${keyRoot}-${account}`;
+    let accountLevelP = Base.bip32Cache[keyAccount]; // it's stored as promise
+    if (!accountLevelP) {
+      Base.bip32Cache[keyAccount] = accountLevelP = rootLevel.derive(account);
     }
-    if (Base.publickeyCache[`${this.network.name}-${xpub}-${account}`]) {
-      const publicKey =
-        Base.publickeyCache[`${this.network.name}-${xpub}-${account}`].derive(
-          index
-        ).publicKey;
-      Base.publickeyCache[`${this.network.name}-${xpub}-${account}-${index}`] =
-        publicKey;
-      return publicKey;
+
+    // 2: index level
+    const keyIndex = `${keyAccount}-${index}`;
+    let indexLevelP = Base.bip32Cache[keyIndex]; // it's stored as promise
+    if (!indexLevelP) {
+      Base.bip32Cache[keyIndex] = indexLevelP = accountLevelP.then((a) =>
+        a.derive(index)
+      );
     }
-    Base.publickeyCache[`${this.network.name}-${xpub}-${account}`] =
-      Base.bech32Cache[`${this.network.name}-${xpub}`].derive(account);
-    const publicKey =
-      Base.publickeyCache[`${this.network.name}-${xpub}-${account}`].derive(
-        index
-      ).publicKey;
-    Base.publickeyCache[`${this.network.name}-${xpub}-${account}-${index}`] =
-      publicKey;
-    return publicKey;
+
+    // We can finally return the publicKey. in most case, indexLevelP will be "resolved"
+    return (await indexLevelP).publicKey;
   }
 
   // derive legacy address at account and index positions
-  protected getLegacyAddress(
+  protected async getLegacyAddress(
     xpub: string,
     account: number,
     index: number
-  ): string {
-    const publicKeyBuffer: Buffer = this.getPubkeyAt(xpub, account, index);
+  ): Promise<string> {
+    const publicKeyBuffer: Buffer = await 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
-  private getNativeSegWitAddress(
+  private async getNativeSegWitAddress(
     xpub: string,
     account: number,
     index: number
-  ): string {
-    const publicKeyBuffer: Buffer = this.getPubkeyAt(xpub, account, index);
+  ): Promise<string> {
+    const publicKeyBuffer: Buffer = await this.getPubkeyAt(
+      xpub,
+      account,
+      index
+    );
     const publicKeyHash160: Buffer = bjs.crypto.hash160(publicKeyBuffer);
     const words: number[] = bech32.toWords(publicKeyHash160);
     words.unshift(0x00);
@@ -108,12 +119,16 @@ class Base implements ICrypto {
   }
 
   // derive SegWit at account and index positions
-  private getSegWitAddress(
+  private async getSegWitAddress(
     xpub: string,
     account: number,
     index: number
-  ): string {
-    const publicKeyBuffer: Buffer = this.getPubkeyAt(xpub, account, index);
+  ): Promise<string> {
+    const publicKeyBuffer: Buffer = await this.getPubkeyAt(
+      xpub,
+      account,
+      index
+    );
     const redeemOutput: Buffer = bjs.script.compile([
       0,
       bjs.crypto.hash160(publicKeyBuffer),
@@ -126,12 +141,12 @@ class Base implements ICrypto {
   }
 
   // get address given an address type
-  getAddress(
+  async getAddress(
     derivationMode: string,
     xpub: string,
     account: number,
     index: number
-  ): string {
+  ): Promise<string> {
     if (
       Base.addressCache[
         `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`
@@ -148,19 +163,19 @@ class Base implements ICrypto {
     return res;
   }
 
-  customGetAddress(
+  async customGetAddress(
     derivationMode: string,
     xpub: string,
     account: number,
     index: number
-  ): string {
+  ): Promise<string> {
     switch (derivationMode) {
       case DerivationModes.LEGACY:
-        return this.getLegacyAddress(xpub, account, index);
+        return await this.getLegacyAddress(xpub, account, index);
       case DerivationModes.SEGWIT:
-        return this.getSegWitAddress(xpub, account, index);
+        return await this.getSegWitAddress(xpub, account, index);
       case DerivationModes.NATIVE_SEGWIT:
-        return this.getNativeSegWitAddress(xpub, account, index);
+        return await this.getNativeSegWitAddress(xpub, account, index);
       default:
         throw new Error(`Invalid derivation Mode: ${derivationMode}`);
     }

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

@@ -1,5 +1,6 @@
-import { publicKeyTweakAdd } from "secp256k1";
+import invariant from "invariant";
 import createHmac from "create-hmac";
+import { getSecp256k1Instance } from "./secp256k1";
 
 // the BIP32 class is inspired from https://github.com/bitcoinjs/bip32/blob/master/src/bip32.js
 class BIP32 {
@@ -15,20 +16,24 @@ class BIP32 {
     depth = 0,
     index = 0
   ) {
+    invariant(publicKey && publicKey.length > 0, "publicKey must not be empty");
+    invariant(chainCode && chainCode.length > 0, "chainCode must not be empty");
     this.publicKey = publicKey;
     this.chainCode = chainCode;
     this.network = network;
     this.depth = depth;
     this.index = index;
   }
-  derive(index: number) {
+  async derive(index: number) {
     const data = Buffer.allocUnsafe(37);
     this.publicKey.copy(data, 0);
     data.writeUInt32BE(index, 33);
     const I = createHmac("sha512", this.chainCode).update(data).digest();
     const IL = I.slice(0, 32);
     const IR = I.slice(32);
-    const Ki = Buffer.from(publicKeyTweakAdd(this.publicKey, IL));
+    const Ki = Buffer.from(
+      await getSecp256k1Instance().publicKeyTweakAdd(this.publicKey, IL)
+    );
     return new BIP32(Ki, IR, this.network, this.depth + 1, index);
   }
 }

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

@@ -3,7 +3,7 @@
 import * as bech32 from "bech32";
 import { bech32m } from "../../bech32m";
 import * as bjs from "bitcoinjs-lib";
-import { publicKeyTweakAdd } from "secp256k1";
+import { getSecp256k1Instance } from "./secp256k1";
 import { InvalidAddress } from "@ledgerhq/errors";
 import { DerivationModes } from "../types";
 import Base from "./base";
@@ -119,15 +119,15 @@ class Bitcoin extends Base {
   }
 
   // get address given an address type
-  customGetAddress(
+  async customGetAddress(
     derivationMode: string,
     xpub: string,
     account: number,
     index: number
-  ): string {
+  ): Promise<string> {
     switch (derivationMode) {
       case DerivationModes.TAPROOT:
-        return this.getTaprootAddress(xpub, account, index);
+        return await this.getTaprootAddress(xpub, account, index);
       default:
         return super.customGetAddress(derivationMode, xpub, account, index);
     }
@@ -176,12 +176,12 @@ class Bitcoin extends Base {
     return bjs.crypto.sha256(Buffer.concat([h, h, x]));
   }
 
-  private getTaprootAddress(
+  private async getTaprootAddress(
     xpub: string,
     account: number,
     index: number
-  ): string {
-    const ecdsaPubkey = this.getPubkeyAt(xpub, account, index);
+  ): Promise<string> {
+    const ecdsaPubkey = await this.getPubkeyAt(xpub, account, index);
     // A BIP32 derived key can be converted to a schnorr pubkey by dropping
     // the first byte, which represent the oddness/evenness. In schnorr all
     // pubkeys are even.
@@ -196,7 +196,7 @@ class Bitcoin extends Base {
 
     // Q = P + int(hash_TapTweak(bytes(P)))G
     const outputEcdsaKey = Buffer.from(
-      publicKeyTweakAdd(evenEcdsaPubkey, tweak)
+      await getSecp256k1Instance().publicKeyTweakAdd(evenEcdsaPubkey, tweak)
     );
     // Convert to schnorr.
     const outputSchnorrKey = outputEcdsaKey.slice(1);

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

@@ -21,22 +21,24 @@ class BitcoinCash extends Base {
   }
 
   // eslint-disable-next-line
-  getLegacyBitcoinCashAddress(
+  async getLegacyBitcoinCashAddress(
     xpub: string,
     account: number,
     index: number
-  ): string {
-    return bchaddr.toCashAddress(super.getLegacyAddress(xpub, account, index));
+  ): Promise<string> {
+    return bchaddr.toCashAddress(
+      await super.getLegacyAddress(xpub, account, index)
+    );
   }
 
   // get address given an address type
-  customGetAddress(
+  async customGetAddress(
     derivationMode: string,
     xpub: string,
     account: number,
     index: number
-  ): string {
-    return this.getLegacyBitcoinCashAddress(xpub, account, index);
+  ): Promise<string> {
+    return await this.getLegacyBitcoinCashAddress(xpub, account, index);
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars

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

@@ -68,12 +68,12 @@ class Decred extends Base {
   }
 
   // get address given an address type
-  customGetAddress(
+  async customGetAddress(
     derivationMode: string,
     xpub: string,
     account: number,
     index: number
-  ): string {
+  ): Promise<string> {
     let buffer: Buffer;
     try {
       buffer = Decred.bs58check.decode(xpub);
@@ -85,7 +85,8 @@ class Decred extends Base {
     const chainCode = buffer.slice(13, 45);
     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 publicKey = (await (await hd.derive(account)).derive(index))
+      .publicKey;
     return Decred.getAddressFromPk(publicKey);
   }
 }

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

@@ -16,3 +16,4 @@ export { default as Qtum } from "./qtum";
 export { default as Vertcoin } from "./vtc";
 export { default as ViaCoin } from "./via";
 export { default as Decred } from "./decred";
+export { setSecp256k1Instance, getSecp256k1Instance } from "./secp256k1";

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

@@ -0,0 +1,32 @@
+import secp256k1 from "secp256k1";
+
+/**
+ * Implement the subset of secp256k1 that wallet-btc needs to work.
+ * The interface is made asynchronous to be more efficient to run in a renderer thread and defer the cryptography
+ */
+export type Secp256k1Instance = {
+  publicKeyTweakAdd(
+    publicKey: Uint8Array,
+    tweak: Uint8Array
+  ): Promise<Uint8Array>;
+};
+
+// default uses node.js's secp256k1
+let impl: Secp256k1Instance = {
+  publicKeyTweakAdd: (publicKey, tweak) =>
+    Promise.resolve(secp256k1.publicKeyTweakAdd(publicKey, tweak)),
+};
+
+/**
+ * allows to override the default Secp256k1Instance
+ */
+export function setSecp256k1Instance(override: Secp256k1Instance): void {
+  impl = override;
+}
+
+/**
+ * get the current Secp256k1Instance
+ */
+export function getSecp256k1Instance(): Secp256k1Instance {
+  return impl;
+}

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

@@ -6,13 +6,13 @@ export interface ICrypto {
     xpub: string,
     account: number,
     index: number
-  ): string;
+  ): Promise<string>;
   customGetAddress(
     derivationMode: string,
     xpub: string,
     account: number,
     index: number
-  ): string;
+  ): Promise<string>;
 
   getDerivationMode(address: string): string;
 

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

@@ -1,6 +1,3 @@
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-import zec from "zcash-bitcore-lib";
 import bs58check from "bs58check";
 import * as bjs from "bitcoinjs-lib";
 import { InvalidAddress } from "@ledgerhq/errors";
@@ -30,21 +27,21 @@ class ZCash extends Base {
   }
 
   // eslint-disable-next-line
-  getLegacyAddress(xpub: string, account: number, index: number): string {
-    const pk = bjs.crypto.hash160(this.getPubkeyAt(xpub, account, index));
+  async getLegacyAddress(xpub: string, account: number, index: number): Promise<string> {
+    const pk = bjs.crypto.hash160(await this.getPubkeyAt(xpub, account, index));
     const payload = Buffer.allocUnsafe(22);
     payload.writeUInt16BE(this.network.pubKeyHash, 0);
     pk.copy(payload, 2);
     return bs58check.encode(payload);
   }
 
-  customGetAddress(
+  async customGetAddress(
     derivationMode: string,
     xpub: string,
     account: number,
     index: number
-  ): string {
-    return this.getLegacyAddress(xpub, account, index);
+  ): Promise<string> {
+    return await this.getLegacyAddress(xpub, account, index);
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -74,7 +71,21 @@ class ZCash extends Base {
 
   // eslint-disable-next-line class-methods-use-this
   validateAddress(address: string): boolean {
-    return zec.Address.isValid(address, "livenet");
+    try {
+      const version = Number(
+        "0x" + bs58check.decode(address).slice(0, 2).toString("hex")
+      );
+      // refer to https://github.com/zcash-hackworks/bitcore-lib-zcash/blob/master/lib%2Faddress.js for the address validation
+      if (
+        version === this.network.pubKeyHash ||
+        version === this.network.scriptHash
+      ) {
+        return true;
+      }
+    } catch {
+      return false;
+    }
+    return false;
   }
 }
 

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

@@ -45,21 +45,21 @@ class Zen extends Base {
   }
 
   // eslint-disable-next-line
-  getLegacyAddress(xpub: string, account: number, index: number): string {
-    const pk = bjs.crypto.hash160(this.getPubkeyAt(xpub, account, index));
+  async getLegacyAddress(xpub: string, account: number, index: number): Promise<string> {
+    const pk = bjs.crypto.hash160(await this.getPubkeyAt(xpub, account, index));
     const payload = Buffer.allocUnsafe(22);
     payload.writeUInt16BE(this.network.pubKeyHash, 0);
     pk.copy(payload, 2);
     return bs58check.encode(payload);
   }
 
-  customGetAddress(
+  async customGetAddress(
     derivationMode: string,
     xpub: string,
     account: number,
     index: number
-  ): string {
-    return this.getLegacyAddress(xpub, account, index);
+  ): Promise<string> {
+    return await this.getLegacyAddress(xpub, account, index);
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars