@ledgerhq/live-common 21.20.0 → 21.21.0-rc.2

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

@@ -0,0 +1,251 @@
+import Base from "./base";
+import { InvalidAddress } from "@ledgerhq/errors";
+import * as bjs from "bitcoinjs-lib";
+import bs58checkBase from "bs58check/base";
+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();
+  }
+  hash160(buffer) {
+    const sha256Hash = createHash("sha256").update(buffer).digest();
+    return createHash("rmd160").update(sha256Hash).digest();
+  }
+  fingerprint() {
+    return this.hash160(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;
+  }
+}
+
+class Decred extends Base {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor({ network }: { network: any }) {
+    super({ network });
+    this.network.dustThreshold = 10000;
+    this.network.dustPolicy = "FIXED";
+    this.network.usesTimestampedTransaction = false;
+  }
+  static blake256(buffer: Buffer): Buffer {
+    let b = buffer;
+    if (buffer instanceof Uint8Array) {
+      b = Buffer.from(buffer);
+    }
+    return createBlakeHash("blake256").update(b).digest();
+  }
+
+  // refer to decred spec https://devdocs.decred.org/developer-guides/addresses/
+  static getAddressFromPk(publicKey: Buffer): string {
+    const prefix = Buffer.from("073f", "hex");
+    const pkhash = Buffer.concat([
+      prefix,
+      new RIPEMD160().update(Decred.blake256(publicKey)).digest(),
+    ]);
+    const checksum = Decred._blake256x2(pkhash).slice(0, 4);
+    return bs58.encode(Buffer.concat([pkhash, checksum]));
+  }
+
+  static readonly _blake256x2 = (buffer: Buffer): Buffer =>
+    Decred.blake256(Decred.blake256(buffer));
+  static readonly bs58check = bs58checkBase(Decred._blake256x2);
+  toOutputScript(address: string): Buffer {
+    if (!this.validateAddress(address)) {
+      throw new InvalidAddress();
+    }
+    const decodeBase58 = Decred.bs58check.decode(address, Decred._blake256x2);
+    const prefix = address.toLocaleUpperCase().substring(0, 2);
+    if (prefix === "DC") {
+      return bjs.payments.p2sh({ hash: decodeBase58.slice(2) })
+        .output as Buffer;
+    } else if (prefix === "DE" || prefix === "DS") {
+      return bjs.payments.p2pkh({ hash: decodeBase58.slice(2) })
+        .output as Buffer;
+    }
+    throw new InvalidAddress();
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  validateAddress(address: string): boolean {
+    if (address.length < 25 || address.length > 36) {
+      return false;
+    }
+    try {
+      Decred.bs58check.decode(address, Decred._blake256x2);
+    } catch (error) {
+      return false;
+    }
+    return true;
+  }
+
+  // get address given an address type
+  getAddress(
+    derivationMode: string,
+    xpub: string,
+    account: number,
+    index: number
+  ): string {
+    if (Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`]) {
+      return Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`];
+    }
+    let buffer: Buffer;
+    try {
+      buffer = Decred.bs58check.decode(xpub);
+    } catch {
+      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 address = Decred.getAddressFromPk(publicKey);
+    Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`] =
+      address;
+    return address;
+  }
+}
+
+export default Decred;

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

@@ -98,6 +98,11 @@ export default function cryptoFactory(currency: Currency) {
       res = new crypto.Bitcoin({ network });
       break;
     }
+    case "decred": {
+      const network = coininfo.decred.main.toBitcoinJS();
+      res = new crypto.Decred({ network });
+      break;
+    }
     default: {
       throw new Error(`Currency ${currency} doesn't exist!`);
     }

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

@@ -15,3 +15,4 @@ export { default as Doge } from "./doge";
 export { default as Qtum } from "./qtum";
 export { default as Vertcoin } from "./vtc";
 export { default as ViaCoin } from "./via";
+export { default as Decred } from "./decred";

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

@@ -59,16 +59,26 @@ class Litecoin extends Base implements ICrypto {
     account: number,
     index: number
   ): string {
+    if (Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`]) {
+      return Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`];
+    }
+    let address: string;
     switch (derivationMode) {
       case DerivationModes.LEGACY:
-        return this.getLegacyAddress(xpub, account, index);
+        address = this.getLegacyAddress(xpub, account, index);
+        break;
       case DerivationModes.SEGWIT:
-        return this.getSegWitAddress(xpub, account, index);
+        address = this.getSegWitAddress(xpub, account, index);
+        break;
       case DerivationModes.NATIVE_SEGWIT:
-        return this.getNativeSegWitAddress(xpub, account, index);
+        address = this.getNativeSegWitAddress(xpub, account, index);
+        break;
       default:
         throw new Error("Should not be reachable");
     }
+    Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`] =
+      address;
+    return address;
   }
 
   // infer address type from its syntax

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

@@ -32,4 +32,5 @@ export type Currency =
   | "viacoin"
   | "stakenet"
   | "stealthcoin"
+  | "decred"
   | "bitcoin_testnet";

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

@@ -9,6 +9,7 @@ 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 {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -52,7 +53,13 @@ class ZCash implements ICrypto {
     account: number,
     index: number
   ): string {
-    return this.getLegacyAddress(xpub, account, index);
+    if (Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`]) {
+      return Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`];
+    }
+    const address = this.getLegacyAddress(xpub, account, index);
+    Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`] =
+      address;
+    return address;
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars

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

@@ -9,6 +9,7 @@ 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 {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -72,7 +73,13 @@ class Zen implements ICrypto {
     account: number,
     index: number
   ): string {
-    return this.getLegacyAddress(xpub, account, index);
+    if (Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`]) {
+      return Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`];
+    }
+    const address = this.getLegacyAddress(xpub, account, index);
+    Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`] =
+      address;
+    return address;
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars

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

@@ -137,7 +137,12 @@ function outputWeight(derivationMode: string): number {
 
 export function outputSize(currency: ICrypto, addr: string): number {
   const scriptLen = currency.toOutputScript(addr).length;
-  return 1 + 8 + scriptLen;
+  let size = 1 + 8 + scriptLen;
+  // More bytes for decred, refer to https://github.com/LedgerHQ/lib-ledger-core/blob/fc9d762b83fc2b269d072b662065747a64ab2816/core/src/wallet/bitcoin/api_impl/BitcoinLikeTransactionApi.cpp#L478
+  if (currency.network.name === "Decred") {
+    size += 8;
+  }
+  return size;
 }
 
 /**

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

@@ -212,6 +212,8 @@ class BitcoinLikeWallet {
     lockTime?: number;
     sigHashType?: number;
     segwit?: boolean;
+    hasTimestamp?: boolean;
+    initialTimestamp?: number;
     additionals?: Array<string>;
     expiryHeight?: Buffer;
     hasExtraData?: boolean;
@@ -227,6 +229,8 @@ class BitcoinLikeWallet {
       btc,
       fromAccount,
       txInfo,
+      hasTimestamp,
+      initialTimestamp,
       additionals,
       hasExtraData,
       onDeviceSignatureRequested,
@@ -234,15 +238,24 @@ class BitcoinLikeWallet {
       onDeviceStreaming,
     } = params;
 
-    const length = txInfo.outputs.reduce((sum, output) => {
+    let length = txInfo.outputs.reduce((sum, output) => {
       return sum + 8 + output.script.length + 1;
     }, 1);
+    // refer to https://github.com/LedgerHQ/lib-ledger-core/blob/fc9d762b83fc2b269d072b662065747a64ab2816/core/src/wallet/bitcoin/api_impl/BitcoinLikeTransactionApi.cpp#L478
+    // Decred has a witness and an expiry height
+    if (additionals && additionals.includes("decred")) {
+      length += 2 * txInfo.outputs.length;
+    }
     const buffer = Buffer.allocUnsafe(length);
     const bufferWriter = new BufferWriter(buffer, 0);
     bufferWriter.writeVarInt(txInfo.outputs.length);
     txInfo.outputs.forEach((txOut) => {
       // xpub splits output into smaller outputs than SAFE_MAX_INT anyway
       bufferWriter.writeUInt64(txOut.value.toNumber());
+      if (additionals && additionals.includes("decred")) {
+        bufferWriter.writeVarInt(0);
+        bufferWriter.writeVarInt(0);
+      }
       bufferWriter.writeVarSlice(txOut.script);
     });
     const outputScriptHex = buffer.toString("hex");
@@ -260,7 +273,7 @@ class BitcoinLikeWallet {
       log("hw", `splitTransaction`, {
         transactionHex: i.txHex,
         isSegwitSupported: true,
-        hasTimestamp: false,
+        hasTimestamp,
         hasExtraData,
         additionals,
       });
@@ -268,7 +281,7 @@ class BitcoinLikeWallet {
         btc.splitTransaction(
           i.txHex,
           true,
-          false, // FIXME hasTimestamp needed for LL-7539
+          hasTimestamp,
           hasExtraData,
           additionals
         ),
@@ -287,7 +300,7 @@ class BitcoinLikeWallet {
       ...(params.lockTime && { lockTime: params.lockTime }),
       ...(params.sigHashType && { sigHashType: params.sigHashType }),
       ...(params.segwit && { segwit: params.segwit }),
-      // initialTimestamp,
+      initialTimestamp,
       ...(params.expiryHeight && { expiryHeight: params.expiryHeight }),
       ...(txInfo.outputs[lastOutputIndex]?.isChange && {
         changePath: `${fromAccount.params.path}/${fromAccount.params.index}'/${txInfo.changeAddress.account}/${txInfo.changeAddress.index}`,
@@ -302,7 +315,7 @@ class BitcoinLikeWallet {
       ...(params.lockTime && { lockTime: params.lockTime }),
       ...(params.sigHashType && { sigHashType: params.sigHashType }),
       ...(params.segwit && { segwit: params.segwit }),
-      // initialTimestamp,
+      initialTimestamp,
       ...(params.expiryHeight && { expiryHeight: params.expiryHeight }),
       ...(txInfo.outputs[lastOutputIndex]?.isChange && {
         changePath: `${fromAccount.params.path}/${fromAccount.params.index}'/${txInfo.changeAddress.account}/${txInfo.changeAddress.index}`,

package/src/families/ethereum/synchronisation.ts

@@ -167,7 +167,10 @@ export const getAccountShape: GetAccountShape = async (
   const operations = mergeOps(initialStableOperations, newOps);
 
   const nfts = isNFTActive(currency)
-    ? mergeNfts(initialAccount?.nfts || [], nftsFromOperations(operations))
+    ? mergeNfts(
+        initialAccount?.nfts || [],
+        nftsFromOperations(operations).filter((n) => n.amount.gt(0))
+      )
     : undefined;
 
   const accountShape: Partial<Account> = {
@@ -441,7 +444,7 @@ const txToOps =
               if (receiving) {
                 const type = "NFT_IN";
                 all.push({
-                  id: `${nftId}-${hash}-${type}-i${i}`,
+                  id: `${nftId}-${hash}-${type}-i${i}_${j}`,
                   senders: [sender],
                   recipients: [receiver],
                   contract,

package/src/families/polkadot/api/sidecar.ts

@@ -275,10 +275,10 @@ const fetchStakingProgress =
  * @returns {SidecarTransactionMaterial}
  */
 const fetchTransactionMaterial = async (
+  // By default we don't want any metadata.
   withMetadata = false
 ): Promise<SidecarTransactionMaterial> => {
-  // By default we don't want any metadata.
-  const params = withMetadata ? "" : "?noMeta=true";
+  const params = withMetadata ? "?metadata=scale" : "?noMeta=true";
   const {
     data,
   }: {

package/src/families/solana/api/cached.ts

@@ -0,0 +1,89 @@
+import { makeLRUCache } from "../../../cache";
+import { ChainAPI } from "./chain";
+import hash from "object-hash";
+
+export function seconds(num: number, max = 100): Record<string, any> {
+  return {
+    max,
+    maxAge: num * 1000,
+  };
+}
+
+export function minutes(num: number, max = 100): Record<string, any> {
+  return seconds(num * 60, max);
+}
+
+const cacheKeyAddress = (address: string) => address;
+const cacheKeyEmpty = () => "" as const;
+const cacheKeyAssocTokenAccAddress = (owner: string, mint: string) =>
+  `${owner}:${mint}`;
+
+const cacheKeyTransactions = (signatures: string[]) =>
+  hash([...signatures].sort());
+
+const cacheKeyByArgs = (...args: any[]) => hash(args);
+
+export function cached(api: ChainAPI): ChainAPI {
+  return {
+    findAssocTokenAccAddress: makeLRUCache(
+      api.findAssocTokenAccAddress,
+      cacheKeyAssocTokenAccAddress,
+      minutes(1000)
+    ),
+
+    getAccountInfo: makeLRUCache(
+      api.getAccountInfo,
+      cacheKeyAddress,
+      seconds(30)
+    ),
+
+    getAssocTokenAccMinNativeBalance: makeLRUCache(
+      api.getAssocTokenAccMinNativeBalance,
+      cacheKeyEmpty,
+      minutes(5)
+    ),
+
+    getBalance: makeLRUCache(api.getBalance, cacheKeyAddress, seconds(30)),
+
+    getBalanceAndContext: makeLRUCache(
+      api.getBalanceAndContext,
+      cacheKeyAddress,
+      seconds(30)
+    ),
+
+    getParsedConfirmedTransactions: makeLRUCache(
+      api.getParsedConfirmedTransactions,
+      cacheKeyTransactions,
+      seconds(30)
+    ),
+
+    getParsedTokenAccountsByOwner: makeLRUCache(
+      api.getParsedTokenAccountsByOwner,
+      cacheKeyAddress,
+      minutes(1)
+    ),
+
+    getRecentBlockhash: makeLRUCache(
+      api.getRecentBlockhash,
+      cacheKeyEmpty,
+      seconds(5)
+    ),
+
+    getTxFeeCalculator: makeLRUCache(
+      api.getTxFeeCalculator,
+      cacheKeyEmpty,
+      minutes(5)
+    ),
+
+    getSignaturesForAddress: makeLRUCache(
+      api.getSignaturesForAddress,
+      cacheKeyByArgs,
+      seconds(30)
+    ),
+
+    // do not cache
+    sendRawTransaction: api.sendRawTransaction,
+
+    config: api.config,
+  };
+}

package/src/families/solana/api/chain/account/index.ts

@@ -0,0 +1 @@
+export { tryParseAsTokenAccount, parseTokenAccountInfo } from "./parser";

package/src/families/solana/api/chain/account/parser.ts

@@ -0,0 +1,35 @@
+import { ParsedAccountData } from "@solana/web3.js";
+import { create } from "superstruct";
+import { ParsedInfo } from "../validators";
+import { TokenAccount, TokenAccountInfo } from "./token";
+
+export function parseTokenAccountInfo(info: unknown): TokenAccountInfo {
+  return create(info, TokenAccountInfo);
+}
+
+export function tryParseAsTokenAccount(
+  data: ParsedAccountData
+): TokenAccountInfo | undefined | Error {
+  const routine = () => {
+    const info = create(data.parsed, ParsedInfo);
+
+    if (data.program === "spl-token") {
+      const parsed = create(info, TokenAccount);
+      if (parsed.type === "account") {
+        return parseTokenAccountInfo(parsed.info);
+      }
+    }
+
+    return undefined;
+  };
+
+  return onThrowReturnError(routine);
+}
+
+function onThrowReturnError<R>(fn: () => R) {
+  try {
+    return fn();
+  } catch (e) {
+    return e instanceof Error ? e : new Error(JSON.stringify(e));
+  }
+}

package/src/families/solana/api/chain/account/stake.ts

@@ -0,0 +1,50 @@
+/* eslint-disable @typescript-eslint/no-redeclare */
+
+import { Infer, number, nullable, enums, type } from "superstruct";
+import { PublicKeyFromString } from "../validators/pubkey";
+import { BigNumFromString } from "../validators/bignum";
+
+export type StakeAccountType = Infer<typeof StakeAccountType>;
+export const StakeAccountType = enums([
+  "uninitialized",
+  "initialized",
+  "delegated",
+  "rewardsPool",
+]);
+
+export type StakeMeta = Infer<typeof StakeMeta>;
+export const StakeMeta = type({
+  rentExemptReserve: BigNumFromString,
+  authorized: type({
+    staker: PublicKeyFromString,
+    withdrawer: PublicKeyFromString,
+  }),
+  lockup: type({
+    unixTimestamp: number(),
+    epoch: number(),
+    custodian: PublicKeyFromString,
+  }),
+});
+
+export type StakeAccountInfo = Infer<typeof StakeAccountInfo>;
+export const StakeAccountInfo = type({
+  meta: StakeMeta,
+  stake: nullable(
+    type({
+      delegation: type({
+        voter: PublicKeyFromString,
+        stake: BigNumFromString,
+        activationEpoch: BigNumFromString,
+        deactivationEpoch: BigNumFromString,
+        warmupCooldownRate: number(),
+      }),
+      creditsObserved: number(),
+    })
+  ),
+});
+
+export type StakeAccount = Infer<typeof StakeAccount>;
+export const StakeAccount = type({
+  type: StakeAccountType,
+  info: StakeAccountInfo,
+});