@ledgerhq/live-common 21.36.3 → 22.0.2

package/src/families/algorand/libcore-buildTransaction.ts

@@ -1,115 +0,0 @@
-import { FeeNotLoaded } from "@ledgerhq/errors";
-import type { Account } from "../../types";
-import { libcoreAmountToBigNumber } from "../../libcore/buildBigNumber";
-import type { Core, CoreAccount } from "../../libcore/types";
-import type { CoreAlgorandTransaction, AlgorandTransaction } from "./types";
-import { extractTokenId } from "./tokens";
-
-const setInfo = async (
-  core,
-  buildedTransaction,
-  transaction,
-  subAccount,
-  account,
-  isPartial
-) => {
-  const { amount, recipient, assetId, mode, useAllAmount } = transaction;
-
-  if (subAccount || (assetId && mode === "optIn")) {
-    const targetAssetId =
-      subAccount && subAccount.type === "TokenAccount"
-        ? extractTokenId(subAccount.token.id)
-        : assetId
-        ? extractTokenId(assetId)
-        : "";
-
-    if (targetAssetId === "") {
-      throw new Error("Token Asset Id not found");
-    }
-
-    const asaTransferInfo = await core.AlgorandAssetTransferInfo.init(
-      targetAssetId,
-      useAllAmount && subAccount
-        ? subAccount.balance.toString()
-        : amount.toString(),
-      recipient,
-      null,
-      null,
-      null
-    );
-    await buildedTransaction.setAssetTransferInfo(asaTransferInfo);
-  } else {
-    const paymentinfo = await core.AlgorandPaymentInfo.init(
-      recipient,
-      useAllAmount
-        ? isPartial
-          ? account.spendableBalance.toString()
-          : account.spendableBalance.minus(transaction.fees || 0).toString()
-        : amount.toString(),
-      null,
-      null
-    );
-    await buildedTransaction.setPaymentInfo(paymentinfo);
-  }
-};
-
-export async function algorandBuildTransaction({
-  account,
-  core,
-  coreAccount,
-  transaction,
-  isCancelled,
-  isPartial,
-}: {
-  account: Account;
-  core: Core;
-  coreAccount: CoreAccount;
-  transaction: AlgorandTransaction;
-  isPartial: boolean;
-  isCancelled: () => boolean;
-}): Promise<CoreAlgorandTransaction | null | undefined> {
-  const { fees, memo, subAccountId } = transaction;
-  const subAccount = subAccountId
-    ? account.subAccounts &&
-      account.subAccounts.find((t) => t.id === subAccountId)
-    : null;
-
-  if (isPartial === false && !fees) {
-    throw new FeeNotLoaded();
-  }
-
-  const algorandAccount = await coreAccount.asAlgorandAccount();
-  if (isCancelled()) return;
-  const buildedTransaction = await algorandAccount.createTransaction();
-  if (isCancelled()) return;
-  // set Payment or Asset if token
-  await setInfo(
-    core,
-    buildedTransaction,
-    transaction,
-    subAccount,
-    account,
-    isPartial
-  );
-
-  // Note, maybe not available
-  if (memo) {
-    await buildedTransaction.setNote(memo);
-  }
-
-  // if Partial getEstimateFees here
-  const feesToSet = isPartial
-    ? await libcoreAmountToBigNumber(
-        await algorandAccount.getFeeEstimate(buildedTransaction)
-      )
-    : fees;
-
-  // then setFees here in any case
-  if (feesToSet) {
-    await buildedTransaction.setFee(feesToSet.toString());
-  }
-
-  // return transaction
-  return buildedTransaction;
-}
-export default algorandBuildTransaction;

package/src/families/algorand/libcore-getFeesForTransaction.ts

@@ -1,25 +0,0 @@
-import type { Account } from "../../types";
-import type { Core, CoreCurrency, CoreAccount } from "../../libcore/types";
-import type { AlgorandTransaction } from "./types";
-import buildTransaction from "./libcore-buildTransaction";
-import { BigNumber } from "bignumber.js";
-
-async function algorand(args: {
-  account: Account;
-  core: Core;
-  coreAccount: CoreAccount;
-  coreCurrency: CoreCurrency;
-  transaction: AlgorandTransaction;
-  isPartial: boolean;
-  isCancelled: () => boolean;
-}) {
-  const builded = await buildTransaction({ ...args, isPartial: true });
-  if (!builded) return;
-  const fees = await builded.getFee();
-  const estimatedFees = new BigNumber(fees);
-  return {
-    estimatedFees,
-  };
-}
-
-export default algorand;

package/src/families/algorand/libcore-postBuildAccount.ts

@@ -1,42 +0,0 @@
-import type { Account } from "../../types";
-import type { CoreAccount } from "../../libcore/types";
-import { libcoreAmountToBigNumber } from "../../libcore/buildBigNumber";
-import type { AlgorandResources } from "./types";
-import { AlgorandOperationTypeEnum } from "./types";
-
-const getAlgorandResources = async (
-  coreAccount
-): Promise<AlgorandResources> => {
-  const algorandAccount = await coreAccount.asAlgorandAccount();
-  const rewardsBigInt = await algorandAccount.getPendingRewards();
-  const rewards = await libcoreAmountToBigNumber(rewardsBigInt);
-  return {
-    rewards,
-    nbAssets: 0, // unused in libcore implem
-  };
-};
-
-const getAlgorandSpendableBalance = async (coreAccount) => {
-  const algorandAccount = await coreAccount.asAlgorandAccount();
-  const spendableBalanceBigInt = await algorandAccount.getSpendableBalance(
-    AlgorandOperationTypeEnum.PAYMENT
-  );
-  const spendableBalance = await libcoreAmountToBigNumber(
-    spendableBalanceBigInt
-  );
-  return spendableBalance;
-};
-
-const postBuildAccount = async ({
-  account,
-  coreAccount,
-}: {
-  account: Account;
-  coreAccount: CoreAccount;
-}): Promise<Account> => {
-  account.algorandResources = await getAlgorandResources(coreAccount);
-  account.spendableBalance = await getAlgorandSpendableBalance(coreAccount);
-  return account;
-};
-
-export default postBuildAccount;

package/src/families/algorand/libcore-signOperation.ts

@@ -1,104 +0,0 @@
-import Algorand from "@ledgerhq/hw-app-algorand";
-import { makeSignOperation } from "../../libcore/signOperation";
-import buildTransaction from "./libcore-buildTransaction";
-import type { AlgorandTransaction, CoreAlgorandTransaction } from "./types";
-import type { Operation } from "../../types";
-import { BigNumber } from "bignumber.js";
-
-async function signTransaction({
-  account,
-  transport,
-  transaction,
-  coreTransaction,
-  isCancelled,
-  onDeviceSignatureGranted,
-  onDeviceSignatureRequested,
-}) {
-  const { freshAddressPath, spendableBalance, id, freshAddress, subAccounts } =
-    account;
-  const hwApp = new Algorand(transport);
-  const serialized = await coreTransaction.serialize();
-  onDeviceSignatureRequested();
-  // Call the hw-app signature
-  const { signature } = await hwApp.sign(freshAddressPath, serialized);
-  onDeviceSignatureGranted();
-
-  if (!signature) {
-    throw new Error("No signature");
-  }
-
-  // Set signature here
-  await coreTransaction.setSignature(signature.toString("hex"));
-  if (isCancelled()) return;
-  // Get the serialization after signature to send it to broadcast
-  const hex = await coreTransaction.serialize();
-  if (isCancelled()) return;
-  // Add fees, senders (= account.freshAddress) and recipients.
-  const senders = [freshAddress];
-  const recipients = [transaction.recipient];
-  const fee = await coreTransaction.getFee();
-  const { subAccountId } = transaction;
-
-  const getType = () => {
-    return subAccountId
-      ? "FEES"
-      : transaction.mode === "optIn"
-      ? "OPT_IN"
-      : "OUT";
-  };
-
-  const type = getType();
-  const tokenAccount = !subAccountId
-    ? null
-    : subAccounts && subAccounts.find((ta) => ta.id === subAccountId);
-  const op: Operation = {
-    id: `${id}--${type}`,
-    hash: "",
-    type,
-    value: subAccountId
-      ? new BigNumber(fee)
-      : transaction.useAllAmount
-      ? spendableBalance
-      : transaction.amount.plus(fee),
-    fee: new BigNumber(fee),
-    blockHash: null,
-    blockHeight: null,
-    senders,
-    recipients,
-    accountId: id,
-    date: new Date(),
-    extra: {},
-  };
-
-  if (tokenAccount && subAccountId) {
-    op.subOperations = [
-      {
-        id: `${subAccountId}--OUT`,
-        hash: "",
-        type: "OUT",
-        value: transaction.useAllAmount
-          ? tokenAccount.balance
-          : transaction.amount,
-        fee: new BigNumber(0),
-        blockHash: null,
-        blockHeight: null,
-        senders,
-        recipients,
-        accountId: subAccountId,
-        date: new Date(),
-        extra: {},
-      },
-    ];
-  }
-
-  return {
-    operation: op,
-    expirationDate: null,
-    signature: hex,
-  };
-}
-
-export default makeSignOperation<AlgorandTransaction, CoreAlgorandTransaction>({
-  buildTransaction,
-  signTransaction,
-});

package/src/families/bitcoin/bridge/libcore.ts

@@ -1,297 +0,0 @@
-import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets";
-import { log } from "@ledgerhq/logs";
-import { BigNumber } from "bignumber.js";
-import invariant from "invariant";
-import {
-  AmountRequired,
-  FeeNotLoaded,
-  FeeRequired,
-  FeeTooHigh,
-  NotEnoughBalance,
-} from "@ledgerhq/errors";
-import { LowerThanMinimumRelayFee } from "../../../errors";
-import { validateRecipient } from "../../../bridge/shared";
-import type { AccountBridge, CurrencyBridge } from "../../../types/bridge";
-import type { Account } from "../../../types/account";
-import type { Transaction, NetworkInfo } from "../types";
-import { sync } from "../../../libcore/syncAccount";
-import { scanAccounts } from "../../../libcore/scanAccounts";
-import { getAccountNetworkInfo } from "../../../libcore/getAccountNetworkInfo";
-import { getFeesForTransaction } from "../../../libcore/getFeesForTransaction";
-import { makeLRUCache } from "../../../cache";
-import broadcast from "../libcore-broadcast";
-import signOperation from "../libcore-signOperation";
-import { getMainAccount } from "../../../account";
-import { getMinRelayFee } from "../fees";
-import { isChangeOutput, perCoinLogic } from "../transaction";
-import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
-import { requiresSatStackReady } from "../satstack";
-import * as explorerConfigAPI from "../../../api/explorerConfig";
-import Btc from "@ledgerhq/hw-app-btc/lib/BtcOld"; // use old implementation of Btc for libcore
-import { getAddressWithBtcInstance } from "../hw-getAddress";
-
-const receive = makeAccountBridgeReceive({
-  injectGetAddressParams: (account) => {
-    const perCoin = perCoinLogic[account.currency.id];
-
-    if (perCoin && perCoin.injectGetAddressParams) {
-      return perCoin.injectGetAddressParams(account);
-    }
-  },
-});
-
-const getCacheKey = (a, t) =>
-  `${a.id}_${a.blockHeight || 0}_${t.amount.toString()}_${String(
-    t.useAllAmount
-  )}_${t.recipient}_${t.feePerByte ? t.feePerByte.toString() : ""}_${
-    t.utxoStrategy.pickUnconfirmedRBF ? 1 : 0
-  }_${t.utxoStrategy.strategy}_${String(t.rbf)}_${t.utxoStrategy.excludeUTXOs
-    .map(({ hash, outputIndex }) => `${hash}@${outputIndex}`)
-    .join("+")}`;
-
-const calculateFees = makeLRUCache(async (a, t) => {
-  return getFeesForTransaction({
-    account: a,
-    transaction: t,
-  });
-}, getCacheKey);
-
-const createTransaction = (): Transaction => ({
-  family: "bitcoin",
-  amount: new BigNumber(0),
-  utxoStrategy: {
-    strategy: 0,
-    pickUnconfirmedRBF: false,
-    excludeUTXOs: [],
-  },
-  recipient: "",
-  rbf: false,
-  feePerByte: null,
-  networkInfo: null,
-  useAllAmount: false,
-  feesStrategy: "medium",
-});
-
-const updateTransaction = (t, patch) => {
-  const updatedT = { ...t, ...patch };
-
-  if (updatedT.recipient.toLowerCase().indexOf("bc1") === 0) {
-    updatedT.recipient = updatedT.recipient.toLowerCase();
-  }
-
-  return updatedT;
-};
-
-const estimateMaxSpendable = async ({
-  account,
-  parentAccount,
-  transaction,
-}) => {
-  const mainAccount = getMainAccount(account, parentAccount);
-  const t = await prepareTransaction(mainAccount, {
-    // worse case scenario using a legacy address
-    ...createTransaction(),
-    ...transaction,
-    recipient:
-      transaction?.recipient || getAbandonSeedAddress(mainAccount.currency.id),
-    useAllAmount: true,
-  });
-  const s = await getTransactionStatus(mainAccount, t);
-  return s.amount;
-};
-
-const getTransactionStatus = async (a, t) => {
-  const errors: {
-    recipient?: Error;
-    feePerByte?: Error;
-    amount?: Error;
-  } = {};
-  const warnings: {
-    recipient?: Error;
-    feePerByte?: Error;
-    feeTooHigh?: Error;
-  } = {};
-  const useAllAmount = !!t.useAllAmount;
-  const { recipientError, recipientWarning } = await validateRecipient(
-    a.currency,
-    t.recipient
-  );
-
-  if (recipientError) {
-    errors.recipient = recipientError;
-  }
-
-  if (recipientWarning) {
-    warnings.recipient = recipientWarning;
-  }
-
-  let txInputs;
-  let txOutputs;
-  let estimatedFees = new BigNumber(0);
-
-  if (!t.feePerByte) {
-    errors.feePerByte = new FeeNotLoaded();
-  } else if (t.feePerByte.eq(0)) {
-    errors.feePerByte = new FeeRequired();
-  } else if (!errors.recipient) {
-    await calculateFees(a, t).then(
-      (res) => {
-        txInputs = res.txInputs;
-        txOutputs = res.txOutputs;
-        estimatedFees = res.estimatedFees;
-      },
-      (error) => {
-        if (error.name === "NotEnoughBalance") {
-          errors.amount = error;
-        } else {
-          throw error;
-        }
-      }
-    );
-  }
-
-  const sumOfInputs = (txInputs || []).reduce(
-    (sum, input) => sum.plus(input.value),
-    new BigNumber(0)
-  );
-  const sumOfChanges = (txOutputs || [])
-    .filter(isChangeOutput)
-    .reduce((sum, output) => sum.plus(output.value), new BigNumber(0));
-
-  if (txInputs) {
-    log("bitcoin", `${txInputs.length} inputs, sum: ${sumOfInputs.toString()}`);
-  }
-
-  if (txOutputs) {
-    log(
-      "bitcoin",
-      `${txOutputs.length} outputs, sum of changes: ${sumOfChanges.toString()}`
-    );
-  }
-
-  const totalSpent = sumOfInputs.minus(sumOfChanges);
-  const amount = useAllAmount ? totalSpent.minus(estimatedFees) : t.amount;
-  log(
-    "bitcoin",
-    `totalSpent ${totalSpent.toString()} amount ${amount.toString()}`
-  );
-
-  if (!errors.amount && !amount.gt(0)) {
-    errors.amount = useAllAmount
-      ? new NotEnoughBalance()
-      : new AmountRequired();
-  }
-
-  if (
-    process.env.EXPERIMENTAL_MIN_RELAY_FEE &&
-    estimatedFees.gt(0) &&
-    estimatedFees.lt(getMinRelayFee(a.currency))
-  ) {
-    warnings.feePerByte = new LowerThanMinimumRelayFee();
-  } else if (amount.gt(0) && estimatedFees.times(10).gt(amount)) {
-    warnings.feeTooHigh = new FeeTooHigh();
-  }
-
-  return Promise.resolve({
-    errors,
-    warnings,
-    estimatedFees,
-    amount,
-    totalSpent,
-    txInputs,
-    txOutputs,
-  });
-};
-
-const inferFeePerByte = (t: Transaction, networkInfo: NetworkInfo) => {
-  if (t.feesStrategy) {
-    const speed = networkInfo.feeItems.items.find(
-      (item) => t.feesStrategy === item.speed
-    );
-
-    if (!speed) {
-      return networkInfo.feeItems.defaultFeePerByte;
-    }
-
-    return speed.feePerByte;
-  }
-
-  return t.feePerByte || networkInfo.feeItems.defaultFeePerByte;
-};
-
-const prepareTransaction = async (
-  a: Account,
-  t: Transaction
-): Promise<Transaction> => {
-  if (a.currency.id === "bitcoin") {
-    await requiresSatStackReady();
-  }
-
-  let networkInfo = t.networkInfo;
-
-  if (!networkInfo) {
-    networkInfo = <NetworkInfo>await getAccountNetworkInfo(a);
-    invariant(
-      networkInfo && networkInfo.family === "bitcoin",
-      "bitcoin networkInfo expected"
-    );
-  }
-
-  const feePerByte = inferFeePerByte(t, networkInfo as NetworkInfo);
-
-  if (
-    t.networkInfo === networkInfo &&
-    (feePerByte === t.feePerByte || feePerByte.eq(t.feePerByte || 0)) // nothing changed
-  ) {
-    return t;
-  }
-
-  return { ...t, networkInfo, feePerByte };
-};
-
-const preload = async () => {
-  const explorerConfig = await explorerConfigAPI.preload();
-  return {
-    explorerConfig,
-  };
-};
-
-const hydrate = (maybeConfig: any) => {
-  if (maybeConfig && maybeConfig.explorerConfig) {
-    explorerConfigAPI.hydrate(maybeConfig.explorerConfig);
-  }
-};
-
-const currencyBridge: CurrencyBridge = {
-  scanAccounts: (arg) =>
-    scanAccounts({
-      ...arg,
-      getAddressFn: (transport) => {
-        const btc = new Btc(transport);
-        return (opts) => getAddressWithBtcInstance(transport, btc, opts);
-      },
-    }),
-  preload,
-  hydrate,
-};
-const accountBridge: AccountBridge<Transaction> = {
-  estimateMaxSpendable,
-  createTransaction,
-  updateTransaction,
-  prepareTransaction,
-  getTransactionStatus,
-  receive,
-  sync,
-  signOperation,
-  broadcast: async ({ account, signedOperation }) => {
-    calculateFees.reset();
-    return broadcast({
-      account,
-      signedOperation,
-    });
-  },
-};
-export default {
-  currencyBridge,
-  accountBridge,
-};

package/src/families/bitcoin/customAddressValidation.ts

@@ -1,30 +0,0 @@
-import { InvalidAddress } from "@ledgerhq/errors";
-import type { Core } from "../../libcore/types";
-import type { CryptoCurrency } from "../../types";
-import { perCoinLogic } from "./transaction";
-export default async (
-  core: Core,
-  arg: {
-    currency: CryptoCurrency;
-    recipient: string;
-  }
-): Promise<null> => {
-  const { currency } = arg;
-  const perCoin = perCoinLogic[currency.id];
-  const recipient = perCoin?.asLibcoreTransactionRecipient
-    ? perCoin.asLibcoreTransactionRecipient(arg.recipient)
-    : arg.recipient;
-  const poolInstance = core.getPoolInstance();
-  const currencyCore = await poolInstance.getCurrency(currency.id);
-  const value = await core.Address.isValid(recipient, currencyCore);
-
-  if (value) {
-    return Promise.resolve(null);
-  }
-
-  return Promise.reject(
-    new InvalidAddress(undefined, {
-      currencyName: currency.name,
-    })
-  );
-};

package/src/families/bitcoin/libcore-broadcast.ts

@@ -1,15 +0,0 @@
-import { patchOperationWithHash } from "../../operation";
-import { makeBroadcast } from "../../libcore/broadcast";
-
-async function broadcast({
-  coreAccount,
-  signedOperation: { signature, operation },
-}) {
-  const bitcoinLikeAccount = await coreAccount.asBitcoinLikeAccount();
-  const txHash = await bitcoinLikeAccount.broadcastRawTransaction(signature);
-  return patchOperationWithHash(operation, txHash);
-}
-
-export default makeBroadcast({
-  broadcast,
-});

package/src/families/bitcoin/libcore-buildOperation.ts

@@ -1,38 +0,0 @@
-import type { CryptoCurrency, Account, Operation } from "../../types";
-import type { CoreOperation } from "../../libcore/types";
-import { perCoinLogic } from "./transaction";
-
-async function bitcoinBuildOperation(
-  {
-    coreOperation,
-    existingAccount,
-    currency,
-  }: {
-    coreOperation: CoreOperation;
-    existingAccount: Account | null | undefined;
-    currency: CryptoCurrency;
-  },
-  partialOp: Operation
-): Promise<Partial<Operation>> {
-  const bitcoinLikeOperation = await coreOperation.asBitcoinLikeOperation();
-  const bitcoinLikeTransaction = await bitcoinLikeOperation.getTransaction();
-  const hash = await bitcoinLikeTransaction.getHash();
-  const shape: Partial<Operation> = {
-    hash,
-  };
-  const perCoin = perCoinLogic[currency.id];
-
-  if (perCoin && perCoin.syncReplaceAddress) {
-    const { syncReplaceAddress } = perCoin;
-    shape.senders = partialOp.senders.map((addr) =>
-      syncReplaceAddress(existingAccount, addr)
-    );
-    shape.recipients = partialOp.recipients.map((addr) =>
-      syncReplaceAddress(existingAccount, addr)
-    );
-  }
-
-  return shape;
-}
-
-export default bitcoinBuildOperation;