@ledgerhq/live-common 21.36.3 → 22.0.2

package/src/libcore/buildAccount/buildSubAccounts.ts

@@ -1,24 +0,0 @@
-import type {
-  SubAccount,
-  Account,
-  CryptoCurrency,
-  SyncConfig,
-} from "../../types";
-import type { Core, CoreAccount } from "../types";
-import byFamily from "../../generated/libcore-buildSubAccounts";
-export async function buildSubAccounts(arg: {
-  core: Core;
-  currency: CryptoCurrency;
-  coreAccount: CoreAccount;
-  accountId: string;
-  existingAccount: Account | null | undefined;
-  syncConfig: SyncConfig;
-  logId?: number;
-}): Promise<SubAccount[] | null | undefined> {
-  const f = byFamily[arg.currency.family];
-
-  if (f) {
-    const res = await f(arg);
-    return res;
-  }
-}

package/src/libcore/buildAccount/index.ts

@@ -1,259 +0,0 @@
-import { log } from "@ledgerhq/logs";
-import last from "lodash/last";
-import {
-  encodeAccountId,
-  isAccountEmpty,
-  getAccountPlaceholderName,
-  getNewAccountPlaceholderName,
-  libcoreNoGoBalanceHistory,
-  emptyHistoryCache,
-} from "../../account";
-import type {
-  SyncConfig,
-  Account,
-  CryptoCurrency,
-  DerivationMode,
-} from "../../types";
-import { libcoreAmountToBigNumber } from "../buildBigNumber";
-import type { CoreWallet, CoreAccount, Core } from "../types";
-import { buildOperation } from "./buildOperation";
-import { buildSubAccounts } from "./buildSubAccounts";
-import { minimalOperationsBuilder } from "../../reconciliation";
-import { getOperationsPageSize } from "../../pagination";
-import getAccountBalanceHistory from "../getAccountBalanceHistory";
-import { getRanges } from "../../portfolio";
-import mergeOperationsByFamily from "../../generated/libcore-mergeOperations";
-import byFamily from "../../generated/libcore-postBuildAccount";
-// FIXME how to get that
-const OperationOrderKey = {
-  date: 0,
-};
-type F = (arg0: {
-  account: Account;
-  coreAccount: CoreAccount;
-}) => Promise<Account>;
-
-async function queryOps(coreAccount) {
-  const query = await coreAccount.queryOperations();
-  await query.addOrder(OperationOrderKey.date, false);
-  return query;
-}
-
-export async function buildAccount({
-  core,
-  coreWallet,
-  coreAccount,
-  currency,
-  accountIndex,
-  derivationMode,
-  seedIdentifier,
-  existingAccount,
-  logId,
-  syncConfig,
-}: {
-  core: Core;
-  coreWallet: CoreWallet;
-  coreAccount: CoreAccount;
-  currency: CryptoCurrency;
-  accountIndex: number;
-  derivationMode: DerivationMode;
-  seedIdentifier: string;
-  existingAccount: Account | null | undefined;
-  logId: number;
-  syncConfig: SyncConfig;
-}): Promise<Account> {
-  log("libcore", `sync(${logId}) start buildAccount`);
-  const restoreKey = await coreAccount.getRestoreKey();
-  const accountId = encodeAccountId({
-    type: "libcore",
-    version: "1",
-    currencyId: currency.id,
-    xpubOrAddress: restoreKey,
-    derivationMode,
-  });
-  const query = await queryOps(coreAccount);
-  await query.partial();
-  const partialOperations = await query.execute();
-  const operationsPageSize = getOperationsPageSize(accountId, syncConfig);
-  const paginatedPartialOperations = isFinite(operationsPageSize)
-    ? partialOperations.slice(partialOperations.length - operationsPageSize)
-    : partialOperations;
-  log("libcore", `sync(${logId}) DONE partial query ops`);
-  const nativeBalance = await coreAccount.getBalance();
-  const balance = await libcoreAmountToBigNumber(nativeBalance);
-  log("libcore", `sync(${logId}) DONE balance`);
-  const coreAccountCreationInfo = await coreWallet.getAccountCreationInfo(
-    accountIndex
-  );
-  const derivations = await coreAccountCreationInfo.getDerivations();
-  const accountPath: string = <string>last(derivations);
-  const coreBlock = await coreAccount.getLastBlock();
-  const blockHeight = await coreBlock.getHeight();
-  const coreFreshAddresses = await coreAccount.getFreshPublicAddresses();
-  if (coreFreshAddresses.length === 0)
-    throw new Error("expected at least one fresh address");
-  const freshAddresses = await Promise.all(
-    coreFreshAddresses.map(async (item) => {
-      const [address, path] = await Promise.all([
-        item.toString(),
-        item.getDerivationPath(),
-      ]);
-      const derivationPath: string = path
-        ? `${accountPath}/${path}`
-        : accountPath;
-      return {
-        address,
-        derivationPath,
-      };
-    })
-  );
-  log("libcore", `sync(${logId}) DONE coreAccount addresses`);
-  const name =
-    partialOperations.length === 0
-      ? getNewAccountPlaceholderName({
-          currency,
-          index: accountIndex,
-          derivationMode,
-        })
-      : getAccountPlaceholderName({
-          currency,
-          index: accountIndex,
-          derivationMode,
-        });
-  const subAccounts = await buildSubAccounts({
-    core,
-    currency,
-    coreAccount,
-    accountId,
-    existingAccount,
-    logId,
-    syncConfig,
-  });
-
-  // We have pre-fetched the operations in "partial" mode
-  // now we will need to complete them lazily
-  const inferCoreOperation = async (corePartialOperation) => {
-    const query = await queryOps(coreAccount);
-    await query.limit(1);
-    await query.offset(partialOperations.indexOf(corePartialOperation));
-    await query.complete();
-    const [coreOperation] = await query.execute();
-    return coreOperation;
-  };
-
-  const operations = await minimalOperationsBuilder(
-    (existingAccount && existingAccount.operations) || [],
-    paginatedPartialOperations,
-    async (corePartialOperation) =>
-      buildOperation({
-        core,
-        coreOperation: await inferCoreOperation(corePartialOperation),
-        accountId,
-        currency,
-        contextualSubAccounts: subAccounts,
-        existingAccount,
-      }),
-    mergeOperationsByFamily[currency.family]
-  );
-  let lastOperation;
-
-  if (partialOperations.length > 0) {
-    if (operations.length === partialOperations.length) {
-      // we already have lastOperation
-      lastOperation = operations[operations.length - 1];
-    } else {
-      // we need to fetch lastOperation. partialOperations is older first
-      const coreOperation = await inferCoreOperation(partialOperations[0]);
-      lastOperation = await buildOperation({
-        core,
-        coreOperation,
-        accountId,
-        currency,
-        contextualSubAccounts: subAccounts,
-        existingAccount,
-      });
-    }
-  }
-
-  log("libcore", `sync(${logId}) DONE operations`);
-  const balanceHistory = {};
-
-  if (!libcoreNoGoBalanceHistory().includes(currency.id)) {
-    await Promise.all(
-      getRanges().map(async (range) => {
-        // NB if we find this not optimized, we can implement this cache strategy:
-        // if for this range a balanceHistory exists in "existingAccount"
-        // compare the last data point {value} with `balance`, re-calc if differ
-        // also compare the last data point {date} with current date to force a re-calc every X hours.
-        const h = await getAccountBalanceHistory(coreAccount, range);
-
-        if (!h[h.length - 1].value.isEqualTo(balance)) {
-          log("libcore", "last data point DOES NOT match the balance!");
-          return;
-        }
-
-        balanceHistory[range] = h;
-      })
-    );
-  }
-
-  log("libcore", `sync(${logId}) DONE balanceHistory`);
-  let creationDate = new Date();
-
-  if (lastOperation) {
-    creationDate = lastOperation.date;
-  }
-
-  if (subAccounts) {
-    subAccounts.forEach((a) => {
-      if (a.creationDate < creationDate) {
-        creationDate = a.creationDate;
-      }
-    });
-  }
-
-  const swapHistory = existingAccount?.swapHistory || [];
-  const account: Account = {
-    type: "Account",
-    id: accountId,
-    seedIdentifier,
-    xpub: restoreKey,
-    derivationMode,
-    index: accountIndex,
-    freshAddress: freshAddresses[0].address,
-    freshAddressPath: freshAddresses[0].derivationPath,
-    freshAddresses,
-    name,
-    starred: false,
-    used: false,
-    balance,
-    balanceHistory,
-    spendableBalance: balance, // FIXME need libcore concept
-    blockHeight,
-    currency,
-    unit: currency.units[0],
-    operationsCount: partialOperations.length,
-    operations,
-    pendingOperations: [],
-    lastSyncDate: new Date(),
-    creationDate,
-    swapHistory,
-    balanceHistoryCache: emptyHistoryCache, // calculated in the syncAccount function
-  };
-
-  if (subAccounts) {
-    account.subAccounts = subAccounts;
-  }
-
-  account.used = !isAccountEmpty(account);
-  const f: F = byFamily[currency.family];
-
-  if (f) {
-    return await f({
-      account,
-      coreAccount,
-    });
-  }
-
-  return account;
-}

package/src/libcore/buildBigNumber.ts

@@ -1,28 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import type { Core, CoreCurrency, CoreAmount, CoreBigInt } from "./types";
-export function bigNumberToLibcoreAmount(
-  core: Core,
-  walletCurrency: CoreCurrency,
-  amount: BigNumber
-): Promise<CoreAmount> {
-  return core.Amount.fromHex(walletCurrency, amount.toString(16));
-}
-export function bigNumberToLibcoreBigInt(
-  core: Core,
-  n: BigNumber
-): Promise<CoreBigInt> {
-  return core.BigInt.fromIntegerString(n.toString(10), 10);
-}
-export async function libcoreBigIntToBigNumber(
-  coreBigInt: CoreBigInt
-): Promise<BigNumber> {
-  const value = await coreBigInt.toString(10);
-  return new BigNumber(value);
-}
-export async function libcoreAmountToBigNumber(
-  amountInstance: CoreAmount
-): Promise<BigNumber> {
-  const coreBigInt = await amountInstance.toBigInt();
-  const res = await libcoreBigIntToBigNumber(coreBigInt);
-  return res;
-}

package/src/libcore/createAccountFromDevice.ts

@@ -1,108 +0,0 @@
-import { log } from "@ledgerhq/logs";
-import type { Core, CoreWallet, CoreAccount } from "./types";
-import type { CryptoCurrency } from "../types";
-import type { DerivationMode } from "../derivation";
-import { GetAddressOptions, Result } from "../hw/getAddress/types";
-
-// In order to not re-query the same path, we use a temporary cache
-export class DerivationsCache {
-  store: Record<
-    string,
-    {
-      publicKey: string;
-      chainCode?: string;
-    }
-  > = {};
-}
-
-type F = (arg0: {
-  core: Core;
-  wallet: CoreWallet;
-  currency: CryptoCurrency;
-  index: number;
-  derivationMode: DerivationMode;
-  isUnsubscribed: () => boolean;
-  derivationsCache: DerivationsCache;
-  getAddress: (opts: GetAddressOptions) => Promise<Result>;
-}) => Promise<CoreAccount | null | undefined>;
-
-export const createAccountFromDevice: F = async ({
-  core,
-  wallet,
-  currency,
-  derivationMode,
-  isUnsubscribed,
-  derivationsCache,
-  getAddress,
-}) => {
-  log(
-    "libcore",
-    "createAccountFromDevice " + currency.id + " " + derivationMode
-  );
-
-  const accountCreationInfos = await wallet.getNextAccountCreationInfo();
-  if (isUnsubscribed()) return;
-
-  const chainCodes = await accountCreationInfos.getChainCodes();
-  if (isUnsubscribed()) return;
-
-  const publicKeys = await accountCreationInfos.getPublicKeys();
-  if (isUnsubscribed()) return;
-
-  const index = await accountCreationInfos.getIndex();
-  if (isUnsubscribed()) return;
-
-  const derivations = await accountCreationInfos.getDerivations();
-  if (isUnsubscribed()) return;
-
-  const owners = await accountCreationInfos.getOwners();
-  if (isUnsubscribed()) return;
-
-  await derivations.reduce(
-    (promise, derivation) =>
-      promise.then(async () => {
-        if (isUnsubscribed()) return;
-        let cache = derivationsCache.store[derivation];
-
-        if (!cache) {
-          cache = await getAddress({
-            currency,
-            path: derivation,
-            derivationMode,
-            askChainCode: true,
-            skipAppFailSafeCheck: true,
-          });
-          derivationsCache.store[derivation] = cache;
-        }
-
-        const { publicKey, chainCode } = cache;
-        publicKeys.push(publicKey);
-        if (chainCode) chainCodes.push(chainCode);
-      }),
-    Promise.resolve()
-  );
-
-  if (isUnsubscribed()) return;
-
-  log("libcore", "AccountCreationInfo.init", {
-    index,
-    owners,
-    derivations,
-    publicKeys,
-    chainCodes,
-  });
-
-  const newAccountCreationInfos = await core.AccountCreationInfo.init(
-    index,
-    owners,
-    derivations,
-    publicKeys,
-    chainCodes
-  );
-
-  if (isUnsubscribed()) return;
-
-  const account = await wallet.newAccountWithInfo(newAccountCreationInfos);
-
-  return account;
-};

package/src/libcore/errors.ts

@@ -1,20 +0,0 @@
-let impl = (e: unknown): Error =>
-  e && e instanceof Error ? e : new Error(String(e));
-
-export function setRemapLibcoreErrorsImplementation(
-  remap: (error: unknown) => Error
-): void {
-  impl = remap;
-}
-export function remapLibcoreErrors(error: unknown): Error {
-  return impl(error);
-}
-export function isNonExistingAccountError(error: Error): boolean {
-  return error.message.includes("doesn't exist");
-}
-export function isNonExistingWalletError(error: Error): boolean {
-  return error.message.includes("doesn't exist");
-}
-export function isAlreadyExistingWalletError(error: Error): boolean {
-  return error.message.includes("already exists");
-}

package/src/libcore/getAccountBalanceHistory.ts

@@ -1,56 +0,0 @@
-import { log } from "@ledgerhq/logs";
-import type { PortfolioRange, BalanceHistory } from "../types";
-import type { CoreAccount } from "./types";
-import { TimePeriod } from "./types";
-import { libcoreAmountToBigNumber } from "./buildBigNumber";
-import { promiseAllBatched } from "../promise";
-import { getDates, getPortfolioRangeConfig } from "../portfolio";
-import invariant from "invariant";
-
-const getAccountBalanceHistory = async (
-  coreA: CoreAccount,
-  range: PortfolioRange
-): Promise<BalanceHistory> => {
-  const dates = getDates(range);
-  const conf = getPortfolioRangeConfig(range);
-  const period = TimePeriod[conf.granularityId];
-  log(
-    "getAccountBalanceHistory",
-    "calc for range=" + range + " with " + dates.length + " datapoint"
-  );
-  // FIXME @gre the weird date adjustment we are doing
-  const to = new Date(conf.startOf(new Date()).getTime() + conf.increment - 1);
-  const fromISO = new Date(dates[0].valueOf() - conf.increment).toISOString();
-  const toISO = to.toISOString();
-  const rawBalances = await coreA.getBalanceHistory(fromISO, toISO, period);
-  const balances = await promiseAllBatched(
-    5,
-    rawBalances,
-    libcoreAmountToBigNumber
-  );
-  invariant(
-    balances.length === dates.length,
-    "Mismatch in sizes dates/balance"
-  );
-  const balanceHistory = balances.map((value, i) => ({
-    date: dates[i],
-    value,
-  }));
-  log(
-    "getAccountBalanceHistory",
-    "DONE. calc for range=" +
-      range +
-      ". " +
-      balanceHistory.length +
-      " datapoint. period=" +
-      period +
-      " range: [" +
-      fromISO +
-      ", " +
-      toISO +
-      "]"
-  );
-  return balanceHistory;
-};
-
-export default getAccountBalanceHistory;

package/src/libcore/getAccountNetworkInfo.ts

@@ -1,46 +0,0 @@
-import { getWalletName } from "../account";
-import type { NetworkInfo } from "../generated/types";
-import type { Account } from "../types";
-import { withLibcoreF } from "./access";
-import { remapLibcoreErrors } from "./errors";
-import { getOrCreateWallet } from "./getOrCreateWallet";
-import { getOrCreateAccount } from "./getOrCreateAccount";
-import byFamily from "../generated/libcore-getAccountNetworkInfo";
-
-type F = (arg0: Account) => Promise<NetworkInfo>;
-
-export const getAccountNetworkInfo: F = withLibcoreF(
-  (core) => async (account) => {
-    try {
-      const { derivationMode, currency } = account;
-      const f = byFamily[currency.family];
-
-      if (!f) {
-        throw new Error(
-          "getAccountNetworkInfo is not implemented by family " +
-            currency.family
-        );
-      }
-
-      const walletName = getWalletName(account);
-      const coreWallet = await getOrCreateWallet({
-        core,
-        walletName,
-        currency,
-        derivationMode,
-      });
-      const coreAccount = await getOrCreateAccount({
-        core,
-        coreWallet,
-        account,
-      });
-      const res = await f({
-        account,
-        coreAccount,
-      });
-      return res;
-    } catch (error) {
-      throw remapLibcoreErrors(error);
-    }
-  }
-);

package/src/libcore/getCoreAccount.ts

@@ -1,37 +0,0 @@
-import type { Account } from "../types";
-import type { Core, CoreWallet, CoreAccount } from "./types";
-import { getWalletName } from "../account";
-import { getOrCreateWallet } from "./getOrCreateWallet";
-import { getOrCreateAccount } from "./getOrCreateAccount";
-
-export const getCoreAccount = async (
-  core: Core,
-  account: Account
-): Promise<{
-  coreWallet: CoreWallet;
-  coreAccount: CoreAccount;
-  walletName: string;
-}> => {
-  const { currency, derivationMode, seedIdentifier } = account;
-  const walletName = getWalletName({
-    currency,
-    seedIdentifier,
-    derivationMode,
-  });
-  const coreWallet = await getOrCreateWallet({
-    core,
-    walletName,
-    currency,
-    derivationMode,
-  });
-  const coreAccount = await getOrCreateAccount({
-    core,
-    coreWallet,
-    account,
-  });
-  return {
-    walletName,
-    coreWallet,
-    coreAccount,
-  };
-};

package/src/libcore/getFeesForTransaction.ts

@@ -1,46 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import type { Account, Transaction } from "../types";
-import { withLibcoreF } from "./access";
-import { remapLibcoreErrors } from "./errors";
-import { getCoreAccount } from "./getCoreAccount";
-import byFamily from "../generated/libcore-getFeesForTransaction";
-import type { BitcoinInput, BitcoinOutput } from "../families/bitcoin/types";
-
-export type Input = {
-  account: Account;
-  transaction: Transaction;
-};
-
-type F = (arg0: Input) => Promise<{
-  estimatedFees: BigNumber;
-  estimatedGas: BigNumber | null | undefined;
-  // Note: Use in Cosmos
-  value: BigNumber;
-  txInputs?: BitcoinInput[];
-  txOutputs?: BitcoinOutput[];
-}>;
-
-export const getFeesForTransaction: F = withLibcoreF(
-  (core) =>
-    async ({ account, transaction }) => {
-      try {
-        const { currency } = account;
-        const { coreWallet, coreAccount } = await getCoreAccount(core, account);
-        const coreCurrency = await coreWallet.getCurrency();
-        const f = byFamily[currency.family];
-        if (!f) throw new Error("currency " + currency.id + " not supported");
-        const fees = await f({
-          account,
-          core,
-          coreAccount,
-          coreCurrency,
-          transaction,
-          isPartial: true,
-          isCancelled: () => false,
-        });
-        return fees;
-      } catch (error) {
-        throw remapLibcoreErrors(error);
-      }
-    }
-);