@ledgerhq/live-common 21.32.1 → 21.32.2

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;

package/src/families/bitcoin/wallet-btc/crypto/zen.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 Zen implements ICrypto {
+class Zen 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 });
     // refer to https://github.com/HorizenOfficial/zen/blob/master/src/chainparams.cpp for the blockchain params
     this.network = network;
     this.network.versions = {
@@ -67,26 +67,13 @@ class Zen implements ICrypto {
     return this.baddrToTaddr(bs58check.encode(Buffer.from(baddr)));
   }
 
-  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
@@ -122,11 +109,6 @@ class Zen implements ICrypto {
       (res[1] === 0x89 || res[1] === 0x96)
     );
   }
-
-  // eslint-disable-next-line
-  isTaprootAddress(address: string): boolean {
-    return false;
-  }
 }
 
 export default Zen;

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

@@ -34,7 +34,6 @@ const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
     {
       title: "Max Fees",
       button: "Rr",
-      expectedValue: () => "CELO",
     },
     {
       title: "No Gateway Fee",

package/src/families/ethereum/signOperation.ts

@@ -2,6 +2,7 @@ import invariant from "invariant";
 import { Observable, from, of } from "rxjs";
 import { mergeMap } from "rxjs/operators";
 import eip55 from "eip55";
+import { encode } from "rlp";
 import { BigNumber } from "bignumber.js";
 import { log } from "@ledgerhq/logs";
 import { FeeNotLoaded } from "@ledgerhq/errors";
@@ -17,6 +18,7 @@ import { modes } from "./modules";
 import { isNFTActive } from "../../nft";
 import { getEnv } from "../../env";
 import { LoadConfig } from "@ledgerhq/hw-app-eth/lib/services/types";
+import { Transaction as EthereumTx } from "@ethereumjs/tx";
 export const signOperation = ({
   account,
   deviceId,
@@ -54,18 +56,16 @@ export const signOperation = ({
                 throw new FeeNotLoaded();
               }
 
-              const { tx, fillTransactionDataResult } = buildEthereumTx(
-                account,
-                transaction,
-                nonce
-              );
-              const to = eip55.encode("0x" + tx.to.toString("hex"));
+              const { ethTxObject, tx, common, fillTransactionDataResult } =
+                buildEthereumTx(account, transaction, nonce);
+              const to = eip55.encode((tx.to || "").toString());
               const value = new BigNumber(
                 "0x" + (tx.value.toString("hex") || "0")
               );
-
-              const txHex = tx.serialize().toString("hex");
-
+              // rawData Format: `rlp([nonce, gasPrice, gasLimit, to, value, data, v, r, s])`
+              const rawData = tx.raw();
+              rawData[6] = Buffer.from([common.chainIdBN().toNumber()]);
+              const txHex = encode(rawData).toString("hex");
               const loadConfig: LoadConfig = {};
               if (isNFTActive(account.currency)) {
                 loadConfig.nftExplorerBaseURL =
@@ -106,26 +106,27 @@ export const signOperation = ({
                 }
               }
 
-              o.next({
-                type: "device-signature-requested",
-              });
+              o.next({ type: "device-signature-requested" });
               const result = await eth.signTransaction(
                 freshAddressPath,
                 txHex,
                 resolution
               );
               if (cancelled) return;
-              o.next({
-                type: "device-signature-granted",
-              });
+              o.next({ type: "device-signature-granted" });
               // Second, we re-set some tx fields from the device signature
-              const v = result.v;
+              const v = `0x${result.v}`;
+              const r = `0x${result.r}`;
+              const s = `0x${result.s}`;
+
+              const signedTx = new EthereumTx(
+                { ...ethTxObject, v, r, s },
+                { common }
+              );
 
-              tx.v = Buffer.from(v, "hex");
-              tx.r = Buffer.from(result.r, "hex");
-              tx.s = Buffer.from(result.s, "hex");
               // Generate the signature ready to be broadcasted
-              const signature = `0x${tx.serialize().toString("hex")}`;
+              const signature = `0x${signedTx.serialize().toString("hex")}`;
+
               // build optimistic operation
               const txHash = ""; // resolved at broadcast time
 

package/src/families/ethereum/specs.ts

@@ -118,7 +118,6 @@ const ethereum: AppSpec<Transaction> = {
   appQuery: {
     model: DeviceModelId.nanoS,
     appName: "Ethereum",
-    appVersion: "1.5.0-rc3",
   },
   testTimeout: 4 * 60 * 1000,
   transactionCheck: ({ maxSpendable }) => {
@@ -380,7 +379,6 @@ const ethereumRopsten: AppSpec<Transaction> = {
   appQuery: {
     model: DeviceModelId.nanoS,
     appName: "Ethereum",
-    appVersion: "1.5.0-rc3",
   },
   testTimeout: 2 * 60 * 1000,
   transactionCheck: ({ maxSpendable }) => {

package/src/families/ethereum/transaction.ts

@@ -6,8 +6,8 @@ import type {
   TransactionRaw,
   EthereumGasLimitRequest,
 } from "./types";
-import Common from "ethereumjs-common";
-import { Transaction as EthereumTx } from "ethereumjs-tx";
+import Common from "@ethereumjs/common";
+import { Transaction as EthereumTx } from "@ethereumjs/tx";
 import eip55 from "eip55";
 import {
   InvalidAddress,
@@ -196,23 +196,18 @@ function getEthereumjsTxCommon(currency) {
     `currency ${currency.id} did not set ethereumLikeInfo`
   );
   if (ethereumLikeInfo.chainId === 1) {
-    return new Common(
-      // $FlowFixMe
-      ethereumLikeInfo.baseChain || "mainnet",
-      // $FlowFixMe
-      ethereumLikeInfo.hardfork || "petersburg"
-    );
+    return new Common({
+      chain: ethereumLikeInfo.baseChain || "mainnet",
+      hardfork: ethereumLikeInfo.hardfork || "petersburg",
+    });
   }
   return Common.forCustomChain(
-    // $FlowFixMe
     ethereumLikeInfo.baseChain || "mainnet",
     {
       name: currency.ticker,
       chainId: ethereumLikeInfo.chainId,
-      // $FlowFixMe
       networkId: ethereumLikeInfo.networkId || ethereumLikeInfo.chainId,
     },
-    // $FlowFixMe
     ethereumLikeInfo.hardfork || "petersburg"
   );
 }
@@ -239,8 +234,6 @@ export function buildEthereumTx(
     "only token accounts expected"
   );
   const common = getEthereumjsTxCommon(currency);
-  invariant(common, `common not found for currency ${currency.name}`);
-  // FIXME: make sure it doesn't break
   if (!common) {
     throw new Error(`common not found for currency ${currency.name}`);
   }
@@ -258,18 +251,11 @@ export function buildEthereumTx(
     ethTxObject
   );
   log("ethereum", "buildEthereumTx", ethTxObject);
-  const tx = new EthereumTx(ethTxObject, {
-    common,
-  });
-  // these will be filled by device signature
-  tx.raw[6] = Buffer.from([common.chainId()]); // v
-
-  tx.raw[7] = Buffer.from([]); // r
-
-  tx.raw[8] = Buffer.from([]); // s
-
+  const tx = new EthereumTx(ethTxObject, { common });
   return {
     tx,
+    common,
+    ethTxObject,
     fillTransactionDataResult,
   };
 }
@@ -294,7 +280,7 @@ export function inferEthereumGasLimitRequest(
     }
 
     if (to) {
-      r.to = "0x" + to.toString("hex");
+      r.to = to.toString();
     }
 
     if (data) {

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

@@ -1,6 +1,10 @@
 // @flow
 import { BigNumber } from "bignumber.js";
-import { TezosToolkit, DEFAULT_FEE } from "@taquito/taquito";
+import {
+  TezosToolkit,
+  DEFAULT_FEE,
+  DEFAULT_STORAGE_LIMIT,
+} from "@taquito/taquito";
 import {
   AmountRequired,
   NotEnoughBalance,
@@ -201,6 +205,7 @@ const prepareTransaction = async (
           mutez: true,
           to: transaction.recipient,
           amount: amount.toNumber(),
+          storageLimit: DEFAULT_STORAGE_LIMIT.ORIGINATION, // https://github.com/TezTech/eztz/blob/master/PROTO_003_FEES.md for originating an account
         });
         break;
       case "delegate":