@ledgerhq/live-common 21.36.3 → 22.0.2

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

@@ -1,27 +0,0 @@
-import type { Account } from "../../types";
-import type { Core, CoreCurrency, CoreAccount } from "../../libcore/types";
-import type { Transaction } from "./types";
-import { libcoreAmountToBigNumber } from "../../libcore/buildBigNumber";
-import buildTransaction from "./libcore-buildTransaction";
-import BigNumber from "bignumber.js";
-
-async function tezos(args: {
-  account: Account;
-  core: Core;
-  coreAccount: CoreAccount;
-  coreCurrency: CoreCurrency;
-  transaction: Transaction;
-  isPartial: boolean;
-  isCancelled: () => boolean;
-}): Promise<{ estimatedFees: BigNumber; value: BigNumber } | void> {
-  const builded = await buildTransaction(args);
-  if (!builded) return;
-  const value = await libcoreAmountToBigNumber(await builded.getValue());
-  const estimatedFees = await libcoreAmountToBigNumber(await builded.getFees());
-  return {
-    estimatedFees,
-    value,
-  };
-}
-
-export default tezos;

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

@@ -1,122 +0,0 @@
-import invariant from "invariant";
-import Xtz from "@ledgerhq/hw-app-tezos";
-import type { CoreTezosLikeTransaction, Transaction } from "./types";
-import { makeSignOperation } from "../../libcore/signOperation";
-import { libcoreAmountToBigNumber } from "../../libcore/buildBigNumber";
-import buildTransaction from "./libcore-buildTransaction";
-
-async function signTransaction({
-  account,
-  transport,
-  transaction,
-  coreTransaction,
-  isCancelled,
-  onDeviceSignatureGranted,
-  onDeviceSignatureRequested,
-}) {
-  const { freshAddressPath, balance, id, subAccounts } = account;
-  // Sign with the device
-  const hwApp = new Xtz(transport);
-  const serialized = await coreTransaction.serialize();
-  onDeviceSignatureRequested();
-  const { signature } = await hwApp.signOperation(freshAddressPath, serialized);
-  onDeviceSignatureGranted();
-  if (isCancelled()) return;
-  await coreTransaction.setSignature(signature);
-  if (isCancelled()) return;
-  const hex = await coreTransaction.serialize();
-  if (isCancelled()) return;
-  const receiver = await coreTransaction.getReceiver();
-  if (isCancelled()) return;
-  const sender = await coreTransaction.getSender();
-  if (isCancelled()) return;
-  const recipients = [
-    transaction.mode === "undelegate" ? "" : await receiver.toBase58(),
-  ];
-  if (isCancelled()) return;
-  const senders = [await sender.toBase58()];
-  if (isCancelled()) return;
-  const feesRaw = await coreTransaction.getFees();
-  if (isCancelled()) return;
-  const fee = await libcoreAmountToBigNumber(feesRaw);
-  if (isCancelled()) return;
-  // Make an optimistic response
-  let op;
-  const txHash = ""; // resolved in broadcast()
-
-  const type =
-    transaction.mode === "undelegate"
-      ? "UNDELEGATE"
-      : transaction.mode === "delegate"
-      ? "DELEGATE"
-      : "OUT";
-  const subAccount =
-    transaction.subAccountId && subAccounts
-      ? subAccounts.find((a) => a.id === transaction.subAccountId)
-      : null;
-
-  if (!subAccount) {
-    op = {
-      id: `${id}-${txHash}-${type}`,
-      hash: txHash,
-      type,
-      value: transaction.useAllAmount ? balance : transaction.amount.plus(fee),
-      fee,
-      blockHash: null,
-      blockHeight: null,
-      senders,
-      recipients,
-      accountId: id,
-      date: new Date(),
-      extra: {},
-    };
-  } else {
-    invariant(
-      subAccount.type === "ChildAccount",
-      "tezos child account is ChildAccount"
-    );
-    op = {
-      id: `${id}-${txHash}-OUT`,
-      hash: txHash,
-      type: "OUT",
-      value: fee,
-      fee,
-      blockHash: null,
-      blockHeight: null,
-      senders,
-      recipients: [subAccount.address],
-      accountId: id,
-      date: new Date(),
-      extra: {},
-      subOperations: [
-        {
-          id: `${subAccount.id}-${txHash}-${type}`,
-          hash: txHash,
-          type,
-          value: transaction.useAllAmount
-            ? subAccount.balance
-            : transaction.amount,
-          fee,
-          blockHash: null,
-          blockHeight: null,
-          senders,
-          recipients: [transaction.recipient],
-          accountId: subAccount.id,
-          date: new Date(),
-          extra: {},
-        },
-      ],
-    };
-  }
-
-  return {
-    operation: op,
-    expirationDate: null,
-    signature: hex,
-  };
-}
-
-export default makeSignOperation<Transaction, CoreTezosLikeTransaction>({
-  buildTransaction,
-  signTransaction,
-});

package/src/families/tezos/test-specifics.ts

@@ -1,19 +0,0 @@
-import { fromAccountRaw } from "../../account";
-import { accountTZrevealedDelegating } from "./test-dataset";
-import { loadAccountDelegation, listBakers } from "./bakers";
-import whitelist from "./bakers.whitelist-default";
-export default () => {
-  describe("tezos bakers", () => {
-    // FIXME Flaky test that will fail every time a Tezos baker is discontinued
-    test("getting the bakers", async () => {
-      const list = await listBakers(whitelist);
-      expect(list.map((o) => o.address)).toEqual(whitelist);
-    });
-    // TODO we'll need two accounts to test diff cases
-    test("load account baker info", async () => {
-      const account = fromAccountRaw(accountTZrevealedDelegating);
-      const delegation = await loadAccountDelegation(account);
-      expect(delegation).toBe(null);
-    });
-  });
-};

package/src/families/tron/test-specifics.ts

@@ -1,137 +0,0 @@
-import sumBy from "lodash/sumBy";
-import { syncAccount } from "../../__tests__/test-helpers/bridge";
-import dataset from "../../families/tron/test-dataset";
-import { getAccountBridge } from "../../bridge";
-import type { Account } from "../../types";
-import {
-  fromAccountRaw,
-  decodeAccountId,
-  encodeAccountId,
-} from "../../account";
-import {
-  fetchTronAccountTxs,
-  getAccountName,
-  getBrokerage,
-  getTronSuperRepresentativeData,
-} from "../../api/Tron";
-
-export default (): void => {
-  return; // FIXME LL-7611
-
-  describe("tron super representative data", () => {
-    test("max is undefined", async () => {
-      const srData = await getTronSuperRepresentativeData(undefined);
-      expect(srData.list.length).toBeGreaterThan(27);
-      expect(srData.totalVotes).toEqual(sumBy(srData.list, "voteCount"));
-      expect(srData.nextVotingDate.getTime()).toBeGreaterThanOrEqual(
-        new Date().getTime()
-      );
-    });
-    test("max is set to 27", async () => {
-      const srData = await getTronSuperRepresentativeData(27);
-      expect(srData.list.length).toEqual(27);
-      expect(srData.totalVotes).toBeGreaterThan(
-        sumBy(srData.list, "voteCount")
-      );
-      expect(srData.nextVotingDate.getTime()).toBeGreaterThanOrEqual(
-        new Date().getTime()
-      );
-    });
-  });
-
-  describe("get account name", () => {
-    test("from a top SR (binance)", async () => {
-      const name = await getAccountName("TLyqzVGLV1srkB7dToTAEqgDSfPtXRJZYH");
-      expect(name).toEqual("Binance Staking");
-    });
-    test("from an account (name is unset)", async () => {
-      const name = await getAccountName("TMn5m53QQBhg2VU1acpZpAbcccxUH2eZzr");
-      expect(name).toBeUndefined();
-    });
-  });
-
-  describe("get brokerage", () => {
-    test("from a top SR (binance)", async () => {
-      const brokerage = await getBrokerage(
-        "TLyqzVGLV1srkB7dToTAEqgDSfPtXRJZYH"
-      );
-      expect(brokerage).toEqual(20);
-    });
-  });
-
-  describe("fetch tron txs", () => {
-    test("should not contain unsupported custom smart contract tx", async () => {
-      const txs = await fetchTronAccountTxs(
-        "TPvDn5oQ5uzhDnohWNhQeDu47GJYwxBpqj",
-        (txs) => txs.length < 1000,
-        {}
-      );
-      const unsupportedTxIds = [
-        "10ea4414383fe49a53253ca1eb497b93bed862106cbe87e479b1320c0e60a8a2",
-        "45ba987d98a271d424a2f0043c72c8897d52316d709cb43ff274ca154f210d10",
-        "0b2f6c549c47c56f3524478f133bc98f8b4c89962bf3c915ed06ddb5def5ea2a",
-        "822f8af2e82aee52276b480e9937e82631cfc9ff2d6ce089c796c24baccaab31", // "80e47e1c203e06363684c007c76defce8f8d55e2f2f7f701ddcde6940c3f2567",
-        "ce7c33737d6ad3052a6f25cd6cacb8cc1496c27667ed43c2a5188044191734bf",
-      ];
-      const hasUnsupportedTxs = txs.filter((tx) =>
-        unsupportedTxIds.includes(tx.txID)
-      );
-      expect(hasUnsupportedTxs).toEqual([]);
-    });
-  });
-
-  describe("tron accounts", () => {
-    const { accounts: accountsRaw = [] } = dataset?.currencies?.tron;
-    const { implementations = [] } = dataset;
-
-    const accounts = accountsRaw.reduce((acc, account) => {
-      const accountsWithImplem = implementations.map((impl) =>
-        fromAccountRaw({
-          ...account.raw,
-          id: encodeAccountId({
-            ...decodeAccountId(account.raw.id),
-            type: impl,
-          }),
-        })
-      );
-
-      return acc.concat(accountsWithImplem);
-    }, [] as Account[]);
-
-    test.each(accounts)(
-      "accounts should always have tronResources",
-      async (account) => {
-        const bridge = getAccountBridge(account, null);
-        const { tronResources = {} } = await syncAccount(bridge, account);
-
-        expect(tronResources).toEqual(
-          expect.objectContaining({
-            votes: expect.any(Array),
-            tronPower: expect.any(Number),
-            energy: expect.toBeBigNumber(),
-            bandwidth: {
-              freeUsed: expect.toBeBigNumber(),
-              freeLimit: expect.toBeBigNumber(),
-              gainedUsed: expect.toBeBigNumber(),
-              gainedLimit: expect.toBeBigNumber(),
-            },
-            unwithdrawnReward: expect.toBeBigNumber(),
-            cacheTransactionInfoById: expect.any(Object),
-          })
-        );
-        expect([
-          "bandwidth",
-          "cacheTransactionInfoById",
-          "delegatedFrozen",
-          "energy",
-          "frozen",
-          "lastVotedDate",
-          "lastWithdrawnRewardDate",
-          "tronPower",
-          "unwithdrawnReward",
-          "votes",
-        ]).toEqual(expect.arrayContaining(Object.keys(tronResources)));
-      }
-    );
-  });
-};

package/src/generated/bridge/libcore.ts

@@ -1,15 +0,0 @@
-import algorand from "../../families/algorand/bridge/libcore";
-
-import bitcoin from "../../families/bitcoin/bridge/libcore";
-
-import cosmos from "../../families/cosmos/bridge/libcore";
-
-import tezos from "../../families/tezos/bridge/libcore";
-
-
-export default {
-  algorand,
-  bitcoin,
-  cosmos,
-  tezos,
-};

package/src/generated/libcore-buildOperation.ts

@@ -1,15 +0,0 @@
-import algorand from "../families/algorand/libcore-buildOperation";
-
-import bitcoin from "../families/bitcoin/libcore-buildOperation";
-
-import cosmos from "../families/cosmos/libcore-buildOperation";
-
-import tezos from "../families/tezos/libcore-buildOperation";
-
-
-export default {
-  algorand,
-  bitcoin,
-  cosmos,
-  tezos,
-};

package/src/generated/libcore-buildSubAccounts.ts

@@ -1,9 +0,0 @@
-import algorand from "../families/algorand/libcore-buildSubAccounts";
-
-import tezos from "../families/tezos/libcore-buildSubAccounts";
-
-
-export default {
-  algorand,
-  tezos,
-};

package/src/generated/libcore-getAccountNetworkInfo.ts

@@ -1,9 +0,0 @@
-import bitcoin from "../families/bitcoin/libcore-getAccountNetworkInfo";
-
-import tezos from "../families/tezos/libcore-getAccountNetworkInfo";
-
-
-export default {
-  bitcoin,
-  tezos,
-};

package/src/generated/libcore-getFeesForTransaction.ts

@@ -1,15 +0,0 @@
-import algorand from "../families/algorand/libcore-getFeesForTransaction";
-
-import bitcoin from "../families/bitcoin/libcore-getFeesForTransaction";
-
-import cosmos from "../families/cosmos/libcore-getFeesForTransaction";
-
-import tezos from "../families/tezos/libcore-getFeesForTransaction";
-
-
-export default {
-  algorand,
-  bitcoin,
-  cosmos,
-  tezos,
-};

package/src/generated/libcore-mergeOperations.ts

@@ -1,6 +0,0 @@
-import cosmos from "../families/cosmos/libcore-mergeOperations";
-
-
-export default {
-  cosmos,
-};

package/src/generated/libcore-postBuildAccount.ts

@@ -1,12 +0,0 @@
-import algorand from "../families/algorand/libcore-postBuildAccount";
-
-import bitcoin from "../families/bitcoin/libcore-postBuildAccount";
-
-import cosmos from "../families/cosmos/libcore-postBuildAccount";
-
-
-export default {
-  algorand,
-  bitcoin,
-  cosmos,
-};

package/src/generated/libcore-postSyncPatch.ts

@@ -1,3 +0,0 @@
-
-export default {
-};

package/src/generated/test-specifics.ts

@@ -1,15 +0,0 @@
-import cosmos from "../families/cosmos/test-specifics";
-
-import polkadot from "../families/polkadot/test-specifics";
-
-import tezos from "../families/tezos/test-specifics";
-
-import tron from "../families/tron/test-specifics";
-
-
-export default {
-  cosmos,
-  polkadot,
-  tezos,
-  tron,
-};

package/src/libcore/access.ts

@@ -1,135 +0,0 @@
-import { log } from "@ledgerhq/logs";
-import invariant from "invariant";
-import { Subject, Observable } from "rxjs";
-import { map, distinctUntilChanged } from "rxjs/operators";
-import type { Core } from "./types";
-
-const GC_DELAY = 1000;
-let core: Core | null | undefined;
-let corePromise: Promise<Core> | null | undefined;
-let libcoreJobsCounter = 0;
-let lastFlush: Promise<void> = Promise.resolve();
-let flushTimeout: NodeJS.Timeout | null | number = null;
-const libcoreJobsCounterSubject: Subject<number> = new Subject();
-
-export const libcoreJobBusy: Observable<boolean> =
-  libcoreJobsCounterSubject.pipe(
-    map((v) => v > 0),
-    distinctUntilChanged()
-  );
-type AfterGCJob<R> = {
-  job: (arg0: Core) => Promise<R>;
-  resolve: (arg0: R) => void;
-};
-const afterLibcoreFlushes: Array<AfterGCJob<any>> = [];
-
-function flush(c: Core) {
-  log("libcore/access", "flush");
-  lastFlush = c
-    .flush()
-    .then(async () => {
-      let item;
-
-      while ((item = afterLibcoreFlushes.shift())) {
-        item.resolve(await item.job(c));
-      }
-
-      log("libcore/access", "flush end");
-    })
-    .catch((e) => {
-      log("libcore/access", "flush error " + String(e));
-      console.error(e);
-    });
-}
-
-export async function afterLibcoreGC<R>(
-  job: (core: Core) => Promise<R>
-): Promise<R> {
-  return new Promise((resolve) => {
-    if (!core) return;
-    log("libcore/access", "new after gc job");
-    afterLibcoreFlushes.push({
-      job,
-      resolve,
-    });
-
-    if (libcoreJobsCounter === 0) {
-      log("libcore/access", "after gc job exec now");
-      if (flushTimeout) {
-        clearTimeout(flushTimeout as number);
-      }
-      flushTimeout = setTimeout(flush.bind(null, core), GC_DELAY);
-    }
-  });
-}
-
-export async function withLibcore<R>(
-  job: (core: Core) => Promise<R>
-): Promise<R> {
-  libcoreJobsCounter++;
-  libcoreJobsCounterSubject.next(libcoreJobsCounter);
-  let c: Core | null | undefined;
-
-  try {
-    if (flushTimeout) {
-      // there is a new job so we must not do the GC yet.
-      clearTimeout(flushTimeout as number);
-      flushTimeout = null;
-    }
-
-    c = await load();
-    await lastFlush; // wait previous flush before starting anything
-
-    const res = await job(c);
-    return res;
-  } finally {
-    libcoreJobsCounter--;
-    libcoreJobsCounterSubject.next(libcoreJobsCounter);
-
-    if (c && libcoreJobsCounter === 0) {
-      flushTimeout = setTimeout(flush.bind(null, c), GC_DELAY);
-    }
-  }
-}
-
-type Fn<A extends Array<any>, R> = (...args: A) => Promise<R>;
-
-export const withLibcoreF =
-  <A extends Array<any>, R>(job: (core: Core) => Fn<A, R>): Fn<A, R> =>
-  (...args) =>
-    withLibcore((c) => job(c)(...args));
-
-let loadCoreImpl: (() => Promise<Core>) | null | undefined;
-
-// reset the libcore data
-export async function reset(): Promise<void> {
-  log("libcore/access", "reset");
-  if (!core) return;
-  invariant(libcoreJobsCounter === 0, "some libcore jobs are still running");
-  await core.getPoolInstance().freshResetAll();
-  core = null;
-  corePromise = null;
-}
-
-async function load(): Promise<Core> {
-  if (core) {
-    return core;
-  }
-
-  if (!corePromise) {
-    if (!loadCoreImpl) {
-      console.warn("loadCore implementation is missing");
-      throw new Error("loadCoreImpl missing");
-    }
-
-    log("libcore/access", "load core impl");
-    corePromise = loadCoreImpl();
-  }
-
-  core = await corePromise;
-  return core;
-}
-
-export function setLoadCoreImplementation(loadCore: () => Promise<Core>) {
-  loadCoreImpl = loadCore;
-}

package/src/libcore/broadcast.ts

@@ -1,34 +0,0 @@
-import type {
-  AccountBridge,
-  Operation,
-  Account,
-  SignedOperation,
-} from "../types";
-import type { CoreAccount } from "./types";
-import { withLibcore } from "./access";
-import { remapLibcoreErrors } from "./errors";
-import { getCoreAccount } from "./getCoreAccount";
-import { Transaction } from "../types";
-
-export type Arg = {
-  broadcast: (arg0: {
-    account: Account;
-    coreAccount: CoreAccount;
-    signedOperation: SignedOperation;
-  }) => Promise<Operation>;
-};
-
-type Broadcast = AccountBridge<Transaction>["broadcast"];
-
-export const makeBroadcast =
-  ({ broadcast }: Arg): Broadcast =>
-  ({ account, signedOperation }) =>
-    withLibcore(async (core) => {
-      const { coreAccount } = await getCoreAccount(core, account);
-      const res = await broadcast({
-        account,
-        coreAccount,
-        signedOperation,
-      });
-      return res;
-    }).catch((e) => Promise.reject(remapLibcoreErrors(e)));

package/src/libcore/buildAccount/buildOperation.ts

@@ -1,96 +0,0 @@
-import { log } from "@ledgerhq/logs";
-import type {
-  Operation,
-  CryptoCurrency,
-  SubAccount,
-  AccountLike,
-} from "../../types";
-import { libcoreAmountToBigNumber } from "../buildBigNumber";
-import { inferSubOperations } from "../../account";
-import type { Core, CoreOperation } from "../types";
-import perFamily from "../../generated/libcore-buildOperation";
-import { getEnv } from "../../env";
-export const OperationTypeMap = {
-  "0": "OUT",
-  "1": "IN",
-};
-export async function buildOperation(arg: {
-  core: Core;
-  coreOperation: CoreOperation;
-  accountId: string;
-  currency: CryptoCurrency;
-  contextualSubAccounts?: SubAccount[] | null | undefined;
-  existingAccount: AccountLike | null | undefined;
-}): Promise<Operation | null> {
-  const { coreOperation, accountId, currency, contextualSubAccounts } = arg;
-  const buildOp = perFamily[currency.family];
-
-  if (!buildOp) {
-    throw new Error(currency.family + " family not supported");
-  }
-
-  const operationType = await coreOperation.getOperationType();
-  const type = OperationTypeMap[operationType] || "NONE";
-  const coreValue = await coreOperation.getAmount();
-  let value = await libcoreAmountToBigNumber(coreValue);
-  const coreFee = await coreOperation.getFees();
-  if (!coreFee) throw new Error("fees should not be null");
-  const fee = await libcoreAmountToBigNumber(coreFee);
-
-  if (type === "OUT") {
-    value = value.plus(fee);
-  }
-
-  const blockHeight = await coreOperation.getBlockHeight();
-  const [recipients, senders] = await Promise.all([
-    type === "IN" && currency.family === "bitcoin"
-      ? coreOperation.getSelfRecipients()
-      : coreOperation.getRecipients(),
-    coreOperation.getSenders(),
-  ]);
-  const date = new Date(await coreOperation.getDate());
-  const partialOp = {
-    type,
-    value,
-    fee,
-    senders,
-    recipients,
-    blockHeight,
-    blockHash: null,
-    accountId,
-    date,
-    extra: {},
-  };
-  const rest = await buildOp(arg, partialOp);
-  if (!rest) return null;
-  const id = `${accountId}-${rest.hash}-${rest.type || type}${
-    rest.extra && rest.extra.id ? "-" + rest.extra.id : ""
-  }`;
-  const op: Operation = {
-    id,
-    subOperations: contextualSubAccounts
-      ? inferSubOperations(rest.hash, contextualSubAccounts)
-      : undefined,
-    ...partialOp,
-    ...rest,
-  };
-  const OPERATION_ADDRESSES_LIMIT = getEnv("OPERATION_ADDRESSES_LIMIT");
-
-  if (op.recipients.length > OPERATION_ADDRESSES_LIMIT) {
-    log(
-      "warning",
-      `operation.recipients too big (${op.recipients.length} > ${OPERATION_ADDRESSES_LIMIT}) – ${id}`
-    );
-    op.recipients.splice(OPERATION_ADDRESSES_LIMIT);
-  }
-
-  if (op.senders.length > OPERATION_ADDRESSES_LIMIT) {
-    log(
-      "warning",
-      `operation.senders too big (${op.senders.length} > ${OPERATION_ADDRESSES_LIMIT}) – ${id}`
-    );
-    op.senders.splice(OPERATION_ADDRESSES_LIMIT);
-  }
-
-  return op;
-}