@ledgerhq/live-common 21.30.1 → 21.32.2

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/bitcoin/wallet-btc/explorer/index.ts

@@ -239,6 +239,12 @@ class BitcoinLikeExplorer extends EventEmitter implements IExplorer {
     // @ts-ignore
     // eslint-disable-next-line no-param-reassign
     delete tx.confirmations;
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    delete tx.id;
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    delete tx.lock_time;
 
     // eslint-disable-next-line no-param-reassign
     tx.account = address.account;
@@ -246,7 +252,21 @@ class BitcoinLikeExplorer extends EventEmitter implements IExplorer {
     tx.index = address.index;
     // eslint-disable-next-line no-param-reassign
     tx.address = address.address;
+    tx.inputs.forEach((input) => {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      delete input.txinwitness;
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      delete input.script_signature;
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      delete input.input_index;
+    });
     tx.outputs.forEach((output) => {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      delete output.script_hex;
       // eslint-disable-next-line no-param-reassign
       output.output_hash = tx.hash;
       // eslint-disable-next-line no-param-reassign

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

@@ -24,7 +24,6 @@ export interface Output {
   address: string;
   output_hash: string;
   output_index: number;
-  script_hex: string;
   block_height: number | null;
   // TODO Write tests for RBF unconfirmed outputs
   rbf: boolean;

package/src/families/celo/api/hubble.ts

@@ -0,0 +1,93 @@
+import { BigNumber } from "bignumber.js";
+import network from "../../../network";
+import { getEnv } from "../../../env";
+import { Operation, OperationType } from "../../../types";
+import { encodeOperationId } from "../../../operation";
+
+const DEFAULT_TRANSACTIONS_LIMIT = 200;
+const getUrl = (route): string => `${getEnv("API_CELO_INDEXER")}${route || ""}`;
+
+// Indexer returns both account data and transactions in one call.
+// Transactions are just limited, there's no block height offset
+const fetchAccountDetails = async (
+  address: string,
+  transactionsLimit: number = DEFAULT_TRANSACTIONS_LIMIT
+) => {
+  const { data } = await network({
+    method: "GET",
+    url: getUrl(`/account_details/${address}?limit=${transactionsLimit}`),
+  });
+  return data;
+};
+
+const fetchStatus = async () => {
+  const { data } = await network({
+    method: "GET",
+    url: getUrl(`/status`),
+  });
+  return data;
+};
+
+const getOperationType = (type: string): OperationType => {
+  switch (type) {
+    case "InternalTransferSent":
+      return "OUT";
+    case "InternalTransferReceived":
+      return "IN";
+    case "AccountSlashed":
+      return "SLASH";
+    default:
+      return "NONE";
+  }
+};
+
+const transactionToOperation = (
+  address: string,
+  accountId: string,
+  transaction
+): Operation => {
+  const type: OperationType = getOperationType(transaction.kind);
+  const hasFailed = transaction.data.success
+    ? !transaction.data.success
+    : false;
+  const senders = transaction.data.from ? [transaction.data.from] : [];
+  const recipients = transaction.data.to ? [transaction.data.to] : [];
+
+  return {
+    id: encodeOperationId(accountId, transaction.transaction_hash, type),
+    hash: transaction.transaction_hash,
+    accountId,
+    fee: new BigNumber(0),
+    value: new BigNumber(transaction.amount),
+    type,
+    blockHeight: transaction.height,
+    date: new Date(transaction.time),
+    senders,
+    recipients,
+    hasFailed,
+    blockHash: null,
+    extra: {},
+  };
+};
+
+export const getAccountDetails = async (address: string, accountId: string) => {
+  const accountDetails = await fetchAccountDetails(address);
+  const spendableBalance = new BigNumber(accountDetails.gold_balance);
+  const lockedBalance = new BigNumber(accountDetails.total_locked_gold);
+  const balance = spendableBalance.plus(lockedBalance);
+  const indexerStatus = await fetchStatus();
+
+  const allTransactions = accountDetails.internal_transfers.concat(
+    accountDetails.transactions
+  );
+  const operations = allTransactions.map((transaction) =>
+    transactionToOperation(address, accountId, transaction)
+  );
+
+  return {
+    blockHeight: indexerStatus.last_indexed_height,
+    balance,
+    spendableBalance,
+    operations,
+  };
+};

package/src/families/celo/api/index.ts

@@ -0,0 +1 @@
+export { getAccountDetails } from "./hubble";

package/src/families/celo/api/sdk.ts

@@ -0,0 +1,8 @@
+import { ContractKit, newKit } from "@celo/contractkit";
+import { getEnv } from "../../../env";
+
+let kit: ContractKit;
+export const celoKit = () => {
+  if (!kit) kit = newKit(getEnv("API_CELO_NODE"));
+  return kit;
+};

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

@@ -0,0 +1,38 @@
+import type { AccountBridge, CurrencyBridge } from "../../../types";
+import type { Transaction } from "../types";
+import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
+import { sync, scanAccounts } from "../js-synchronisation";
+import signOperation from "../js-signOperation";
+import getTransactionStatus from "../js-getTransactionStatus";
+import broadcast from "../js-broadcast";
+import estimateMaxSpendable from "../js-estimateMaxSpendable";
+import prepareTransaction from "../js-prepareTransaction";
+import createTransaction from "../js-createTransaction";
+
+const updateTransaction = (t, patch) => ({ ...t, ...patch });
+
+const receive = makeAccountBridgeReceive();
+
+const preload = async () => Promise.resolve({});
+const hydrate = (): void => {};
+
+const currencyBridge: CurrencyBridge = {
+  preload,
+  hydrate,
+  scanAccounts,
+};
+const accountBridge: AccountBridge<Transaction> = {
+  estimateMaxSpendable,
+  createTransaction,
+  updateTransaction,
+  getTransactionStatus,
+  prepareTransaction,
+  sync,
+  receive,
+  signOperation,
+  broadcast,
+};
+export default {
+  currencyBridge,
+  accountBridge,
+};

package/src/families/celo/cli-transaction.ts

@@ -0,0 +1,41 @@
+import invariant from "invariant";
+import flatMap from "lodash/flatMap";
+
+import type {
+  Transaction,
+  Account,
+  AccountLike,
+  AccountLikeArray,
+} from "../../types";
+
+const options = [];
+
+function inferAccounts(account: Account): AccountLikeArray {
+  invariant(account.currency.family === "celo", "celo family");
+
+  const accounts: Account[] = [account];
+  return accounts;
+}
+
+function inferTransactions(
+  transactions: Array<{
+    account: AccountLike;
+    transaction: Transaction;
+    mainAccount: Account;
+  }>
+): Transaction[] {
+  return flatMap(transactions, ({ transaction }) => {
+    invariant(transaction.family === "celo", "celo family");
+
+    return {
+      ...transaction,
+      family: "celo",
+    } as Transaction;
+  });
+}
+
+export default {
+  options,
+  inferAccounts,
+  inferTransactions,
+};

package/src/families/celo/datasets/celo.scanAccounts.1.ts

@@ -0,0 +1,20 @@
+import type { CurrenciesData } from "../../../types";
+import type { Transaction } from "../types";
+
+const dataset: CurrenciesData<Transaction> = {
+  scanAccounts: [
+    {
+      name: "celo seed 1",
+      apdus: `
+      => e002000009028000002c8000ce10
+      <= 41040106794f46b69e1ae56dff904510959e59074a37341f8cc740e9ce7a0b24421c42e7023481f5ef03926739baa6bb26cac7bf48f249a24793264711d48499499528433235323935323541463035434134313939633236413838623438393463383342303330433733399000
+      => e002000015058000002c8000ce10800000000000000000000000
+      <= 41044f4998c3f81966645f25e95082f9fe7d104b1ba4286486a8ecd8fd11f79ef02bd8110f086b390a418ab619a650f3df59a3c84912ce1ea125386d7aa7732fcd0b28393634313334336638346535304143304334434133626644313244433063346231653732363544359000
+      => e002000015058000002c8000ce10800000010000000000000000
+      <= 4104630b6447b0f690520a5612f1dc57da90b84f6b59dfeb375bed1113fb34a8d0f9181ec63e40f9fde05761084dbd022ba76711eb2b36442cf4b5d2bc19def9156428343435306565646238623532333931354534393639633239646241653944354563303646453837349000
+      `,
+    },
+  ],
+};
+
+export default dataset;

package/src/families/celo/deviceTransactionConfig.ts

@@ -0,0 +1,19 @@
+import type { DeviceTransactionField } from "../../transaction";
+
+function getDeviceTransactionConfig(): Array<DeviceTransactionField> {
+  const fields: Array<DeviceTransactionField> = [];
+
+  fields.push({
+    type: "amount",
+    label: "Amount",
+  });
+
+  fields.push({
+    type: "fees",
+    label: "Fees",
+  });
+
+  return fields;
+}
+
+export default getDeviceTransactionConfig;

package/src/families/celo/hw-app-celo.ts

@@ -0,0 +1,108 @@
+import type Transport from "@ledgerhq/hw-transport";
+import { decode, encode } from "rlp";
+
+/**
+ * Heavily inspiried by celo-web-wallet
+ * https://github.com/celo-tools/celo-web-wallet/blob/master/src/features/ledger/CeloLedgerApp.ts
+ */
+export class CeloApp {
+  transport: Transport;
+
+  constructor(transport: any) {
+    this.transport = transport;
+  }
+
+  async signTransaction(
+    path: string,
+    rawTxHex: string
+  ): Promise<{
+    s: string;
+    v: string;
+    r: string;
+  }> {
+    const paths = splitPath(path);
+    const rawTx = Buffer.from(rawTxHex, "hex");
+    let offset = 0;
+    let response;
+
+    const rlpTx = decode(rawTx);
+    let rlpOffset = 0;
+    if (rlpTx.length > 6) {
+      const rlpVrs = encode(rlpTx.slice(-3));
+      rlpOffset = rawTx.length - (rlpVrs.length - 1);
+    }
+
+    while (offset !== rawTx.length) {
+      const first = offset === 0;
+      const maxChunkSize = first ? 150 - 1 - paths.length * 4 : 150;
+      let chunkSize =
+        offset + maxChunkSize > rawTx.length
+          ? rawTx.length - offset
+          : maxChunkSize;
+      if (rlpOffset != 0 && offset + chunkSize == rlpOffset) {
+        // Make sure that the chunk doesn't end right on the EIP 155 marker if set
+        chunkSize--;
+      }
+      const buffer = Buffer.alloc(
+        first ? 1 + paths.length * 4 + chunkSize : chunkSize
+      );
+      if (first) {
+        buffer[0] = paths.length;
+        paths.forEach((element, index) => {
+          buffer.writeUInt32BE(element, 1 + 4 * index);
+        });
+        rawTx.copy(buffer, 1 + 4 * paths.length, offset, offset + chunkSize);
+      } else {
+        rawTx.copy(buffer, 0, offset, offset + chunkSize);
+      }
+
+      response = await this.transport
+        .send(0xe0, 0x04, first ? 0x00 : 0x80, 0x00, buffer)
+        .catch((e) => {
+          throw e;
+        });
+
+      offset += chunkSize;
+    }
+
+    const v = response.slice(0, 1).toString("hex");
+    const r = response.slice(1, 1 + 32).toString("hex");
+    const s = response.slice(1 + 32, 1 + 32 + 32).toString("hex");
+    return { v, r, s };
+  }
+
+  provideERC20TokenInformation({ data }: { data: Buffer }): Promise<boolean> {
+    return provideERC20TokenInformation(this.transport, data);
+  }
+}
+
+function splitPath(path: string): number[] {
+  const result: number[] = [];
+  const components = path.split("/");
+  components.forEach((element) => {
+    let number = parseInt(element, 10);
+    if (isNaN(number)) {
+      return; // FIXME shouldn't it throws instead?
+    }
+    if (element.length > 1 && element[element.length - 1] === "'") {
+      number += 0x80000000;
+    }
+    result.push(number);
+  });
+  return result;
+}
+
+function provideERC20TokenInformation(
+  transport: Transport,
+  data: Buffer
+): Promise<boolean> {
+  return transport.send(0xe0, 0x0a, 0x00, 0x00, data).then(
+    () => true,
+    (e) => {
+      if (e && e.statusCode === 0x6d00) {
+        return false;
+      }
+      throw e;
+    }
+  );
+}

package/src/families/celo/hw-getAddress.ts

@@ -0,0 +1 @@
+export { default } from "../ethereum/hw-getAddress";

package/src/families/celo/js-broadcast.ts

@@ -0,0 +1,12 @@
+import { patchOperationWithHash } from "../../operation";
+import { celoKit } from "./api/sdk";
+
+const broadcast = async ({ signedOperation: { operation, signature } }) => {
+  const kit = celoKit();
+  const { transactionHash } = await kit.web3.eth.sendSignedTransaction(
+    signature
+  );
+  return patchOperationWithHash(operation, transactionHash);
+};
+
+export default broadcast;

package/src/families/celo/js-buildTransaction.ts

@@ -0,0 +1,32 @@
+import type { Transaction } from "./types";
+import type { Account } from "../../types";
+import { CeloTx } from "@celo/connect";
+import { celoKit } from "./api/sdk";
+
+const buildTransaction = async (account: Account, transaction: Transaction) => {
+  const kit = celoKit();
+  const { amount } = transaction;
+  const value = transaction.useAllAmount
+    ? account.spendableBalance.minus(transaction.fees || 0)
+    : amount;
+
+  const celoToken = await kit.contracts.getGoldToken();
+
+  const celoTransaction = {
+    from: account.freshAddress,
+    to: celoToken.address,
+    data: celoToken
+      .transfer(transaction.recipient, value.toFixed())
+      .txo.encodeABI(),
+  };
+
+  return {
+    ...celoTransaction,
+    chainId: await kit.connection.chainId(),
+    nonce: await kit.connection.nonce(account.freshAddress),
+    gas: await kit.connection.estimateGasWithInflationFactor(celoTransaction),
+    gasPrice: await kit.connection.gasPrice(),
+  } as CeloTx;
+};
+
+export default buildTransaction;