@ledgerhq/live-common 21.23.0 → 21.24.0-beta.0

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

@@ -0,0 +1,36 @@
+import ecc from "tiny-secp256k1";
+import createHmac from "create-hmac";
+
+// the BIP32 class is inspired from https://github.com/bitcoinjs/bip32/blob/master/src/bip32.js
+class BIP32 {
+  publicKey: any;
+  chainCode: any;
+  network: any;
+  depth: number;
+  index: number;
+  constructor(
+    publicKey: any,
+    chainCode: any,
+    network: any,
+    depth = 0,
+    index = 0
+  ) {
+    this.publicKey = publicKey;
+    this.chainCode = chainCode;
+    this.network = network;
+    this.depth = depth;
+    this.index = index;
+  }
+  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 = ecc.pointAddScalar(this.publicKey, IL, true);
+    return new BIP32(Ki, IR, this.network, this.depth + 1, index);
+  }
+}
+
+export default BIP32;

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

@@ -6,149 +6,7 @@ import bs58check from "bs58check";
 import createBlakeHash from "blake-hash";
 import RIPEMD160 from "ripemd160";
 import bs58 from "bs58";
-import ecc from "tiny-secp256k1";
-import createHash from "create-hash";
-import createHmac from "create-hmac";
-
-// the BIP32 class is inspired from https://github.com/bitcoinjs/bip32/blob/master/src/bip32.js
-class BIP32 {
-  privateKey: any;
-  publicKey: any;
-  chainCode: any;
-  network: any;
-  depth: number;
-  index: number;
-  ParentFingerprint: number;
-  lowR: boolean;
-  constructor(
-    privateKey,
-    publicKey,
-    chainCode,
-    network,
-    depth = 0,
-    index = 0,
-    ParentFingerprint = 0x00000000
-  ) {
-    this.privateKey = privateKey;
-    this.publicKey = publicKey;
-    this.chainCode = chainCode;
-    this.network = network;
-    this.depth = depth;
-    this.index = index;
-    this.ParentFingerprint = ParentFingerprint;
-    this.lowR = false;
-  }
-  pk() {
-    if (this.publicKey === undefined)
-      this.publicKey = ecc.pointFromScalar(this.privateKey, true);
-    return this.publicKey;
-  }
-  isNeutered() {
-    return this.privateKey === undefined;
-  }
-  neutered() {
-    return new BIP32(
-      undefined,
-      this.pk(),
-      this.chainCode,
-      this.network,
-      this.depth,
-      this.index,
-      this.ParentFingerprint
-    );
-  }
-  hmacSHA512(key, data) {
-    return createHmac("sha512", key).update(data).digest();
-  }
-  hashSHA256(buffer) {
-    return createHash("sha256").update(buffer).digest();
-  }
-  fingerprint() {
-    return this.hashSHA256(this.pk()).slice(0, 4);
-  }
-
-  toBase58() {
-    const network = this.network;
-    const version = !this.isNeutered()
-      ? network.bip32.private
-      : network.bip32.public;
-    const buffer = Buffer.allocUnsafe(78);
-    // 4 bytes: version bytes
-    buffer.writeUInt32BE(version, 0);
-    // 1 byte: depth: 0x00 for master nodes, 0x01 for level-1 descendants, ....
-    buffer.writeUInt8(this.depth, 4);
-    // 4 bytes: the fingerprint of the parent's key (0x00000000 if master key)
-    buffer.writeUInt32BE(this.ParentFingerprint, 5);
-    // 4 bytes: child number. This is the number i in xi = xpar/i, with xi the key being serialized.
-    // This is encoded in big endian. (0x00000000 if master key)
-    buffer.writeUInt32BE(this.index, 9);
-    // 32 bytes: the chain code
-    this.chainCode.copy(buffer, 13);
-    // 33 bytes: the public key or private key data
-    if (!this.isNeutered()) {
-      // 0x00 + k for private keys
-      buffer.writeUInt8(0, 45);
-      this.privateKey.copy(buffer, 46);
-      // 33 bytes: the public key
-    } else {
-      // X9.62 encoding for public keys
-      this.pk().copy(buffer, 45);
-    }
-    return bs58check.encode(buffer);
-  }
-  // https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#child-key-derivation-ckd-functions
-  derive(index) {
-    const isHardened = index >= 0x80000000;
-    const data = Buffer.allocUnsafe(37);
-    // Hardened child
-    if (isHardened) {
-      data[0] = 0x00;
-      this.privateKey.copy(data, 1);
-      data.writeUInt32BE(index, 33);
-    } else {
-      this.pk().copy(data, 0);
-      data.writeUInt32BE(index, 33);
-    }
-    const I = this.hmacSHA512(this.chainCode, data);
-    const IL = I.slice(0, 32);
-    const IR = I.slice(32);
-    // if parse256(IL) >= n, proceed with the next value for i
-    if (!ecc.isPrivate(IL)) return this.derive(index + 1);
-    // Private parent key -> private child key
-    let hd;
-    if (!this.isNeutered()) {
-      // ki = parse256(IL) + kpar (mod n)
-      const ki = ecc.privateAdd(this.privateKey, IL);
-      // In case ki == 0, proceed with the next value for i
-      if (ki == null) return this.derive(index + 1);
-      hd = new BIP32(
-        ki,
-        undefined,
-        IR,
-        this.network,
-        this.depth + 1,
-        index,
-        this.fingerprint().readUInt32BE(0)
-      );
-    } else {
-      // Ki = point(parse256(IL)) + Kpar
-      //    = G*IL + Kpar
-      const Ki = ecc.pointAddScalar(this.pk(), IL, true);
-      // In case Ki is the point at infinity, proceed with the next value for i
-      if (Ki === null) return this.derive(index + 1);
-      hd = new BIP32(
-        undefined,
-        Ki,
-        IR,
-        this.network,
-        this.depth + 1,
-        index,
-        this.fingerprint().readUInt32BE(0)
-      );
-    }
-    return hd;
-  }
-}
+import BIP32 from "./bip32";
 
 class Decred extends Base {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -226,20 +84,11 @@ class Decred extends Base {
       buffer = bs58check.decode(xpub);
     }
     const depth = buffer[4];
-    const parentFingerprint = buffer.readUInt32BE(5);
     const i = buffer.readUInt32BE(9);
     const chainCode = buffer.slice(13, 45);
     const X = buffer.slice(45, 78);
-    const hd = new BIP32(
-      undefined,
-      X,
-      chainCode,
-      this.network,
-      depth,
-      i,
-      parentFingerprint
-    );
-    const publicKey = hd.derive(account).derive(index).pk();
+    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[`${derivationMode}-${xpub}-${account}-${index}`] =
       address;

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/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,