@ledgerhq/coin-framework 0.0.2

package/src/account/serialization.ts

@@ -0,0 +1,189 @@
+import { BigNumber } from "bignumber.js";
+import type { Operation, OperationRaw, SubAccount } from "@ledgerhq/types-live";
+
+export type ExtractExtraFn = (
+  extra: Record<string, any>
+) => Record<string, any>;
+
+export const toOperationRaw = (
+  {
+    date,
+    value,
+    fee,
+    subOperations,
+    internalOperations,
+    nftOperations,
+    extra,
+    id,
+    hash,
+    type,
+    senders,
+    recipients,
+    blockHeight,
+    blockHash,
+    transactionSequenceNumber,
+    accountId,
+    hasFailed,
+    contract,
+    operator,
+    standard,
+    tokenId,
+    transactionRaw,
+  }: Operation,
+  preserveSubOperation?: boolean
+): OperationRaw => {
+  const copy: OperationRaw = {
+    id,
+    hash,
+    type,
+    senders,
+    recipients,
+    accountId,
+    blockHash,
+    blockHeight,
+    extra,
+    date: date.toISOString(),
+    value: value.toFixed(),
+    fee: fee.toString(),
+    contract,
+    operator,
+    standard,
+    tokenId,
+  };
+
+  if (transactionSequenceNumber !== undefined) {
+    copy.transactionSequenceNumber = transactionSequenceNumber;
+  }
+
+  if (hasFailed !== undefined) {
+    copy.hasFailed = hasFailed;
+  }
+
+  if (subOperations && preserveSubOperation) {
+    copy.subOperations = subOperations.map((o: Operation) => toOperationRaw(o));
+  }
+
+  if (internalOperations) {
+    copy.internalOperations = internalOperations.map((o: Operation) =>
+      toOperationRaw(o)
+    );
+  }
+
+  if (nftOperations) {
+    copy.nftOperations = nftOperations.map((o: Operation) => toOperationRaw(o));
+  }
+
+  if (transactionRaw !== undefined) {
+    copy.transactionRaw = transactionRaw;
+  }
+
+  return copy;
+};
+export const inferSubOperations = (
+  txHash: string,
+  subAccounts: SubAccount[]
+): Operation[] => {
+  const all: Operation[] = [];
+
+  for (let i = 0; i < subAccounts.length; i++) {
+    const ta = subAccounts[i];
+
+    for (let j = 0; j < ta.operations.length; j++) {
+      const op = ta.operations[j];
+
+      if (op.hash === txHash) {
+        all.push(op);
+      }
+    }
+
+    for (let j = 0; j < ta.pendingOperations.length; j++) {
+      const op = ta.pendingOperations[j];
+
+      if (op.hash === txHash) {
+        all.push(op);
+      }
+    }
+  }
+
+  return all;
+};
+export const fromOperationRaw = (
+  {
+    date,
+    value,
+    fee,
+    extra,
+    subOperations,
+    internalOperations,
+    nftOperations,
+    id,
+    hash,
+    type,
+    senders,
+    recipients,
+    blockHeight,
+    blockHash,
+    transactionSequenceNumber,
+    hasFailed,
+    contract,
+    operator,
+    standard,
+    tokenId,
+    transactionRaw,
+  }: OperationRaw,
+  accountId: string,
+  subAccounts?: SubAccount[] | null | undefined
+): Operation => {
+  const res: Operation = {
+    id,
+    hash,
+    type,
+    senders,
+    recipients,
+    accountId,
+    blockHash,
+    blockHeight,
+    date: new Date(date),
+    value: new BigNumber(value),
+    fee: new BigNumber(fee),
+    extra,
+    contract,
+    operator,
+    standard,
+    tokenId,
+  };
+
+  if (transactionSequenceNumber !== undefined) {
+    res.transactionSequenceNumber = transactionSequenceNumber;
+  }
+
+  if (hasFailed !== undefined) {
+    res.hasFailed = hasFailed;
+  }
+
+  if (subAccounts) {
+    res.subOperations = inferSubOperations(hash, subAccounts);
+  } else if (subOperations) {
+    res.subOperations = subOperations.map((o: OperationRaw) =>
+      fromOperationRaw(o, o.accountId)
+    );
+  }
+
+  if (internalOperations) {
+    res.internalOperations = internalOperations.map((o: OperationRaw) =>
+      fromOperationRaw(o, o.accountId)
+    );
+  }
+
+  if (nftOperations) {
+    res.nftOperations = nftOperations.map((o: OperationRaw) =>
+      fromOperationRaw(o, o.accountId)
+    );
+  }
+
+  if (transactionRaw !== undefined) {
+    res.transactionRaw = transactionRaw;
+  }
+
+  return res;
+};

package/src/account/support.ts

@@ -0,0 +1,96 @@
+import {
+  AccountNotSupported,
+  CurrencyNotSupported,
+  UnavailableTezosOriginatedAccountReceive,
+} from "@ledgerhq/errors";
+import { getEnv } from "../env";
+import { decodeAccountId } from "./accountId";
+import {
+  getAllDerivationModes,
+  getDerivationModesForCurrency,
+} from "../derivation";
+import { isCurrencySupported } from "../currencies";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import type { Account, AccountLike } from "@ledgerhq/types-live";
+import type { DerivationMode } from "../derivation";
+
+export const shouldShowNewAccount = (
+  currency: CryptoCurrency,
+  derivationMode: DerivationMode
+): boolean => {
+  const modes = getDerivationModesForCurrency(currency);
+  // last mode is always creatable by convention
+  if (modes[modes.length - 1] === derivationMode) return true;
+  // legacy is only available with flag SHOW_LEGACY_NEW_ACCOUNT
+  if (
+    derivationMode === "" &&
+    (!!getEnv("SHOW_LEGACY_NEW_ACCOUNT") || currency.family === "bitcoin")
+  )
+    return true;
+  // native segwit being not yet supported everywhere, segwit is always available for creation
+  if (
+    derivationMode === "segwit" ||
+    (currency.family === "bitcoin" &&
+      (derivationMode === "native_segwit" || derivationMode === "taproot"))
+  )
+    return true;
+  return false;
+};
+export const getReceiveFlowError = (
+  account: AccountLike,
+  parentAccount: Account | null | undefined
+): Error | null | undefined => {
+  if (parentAccount && parentAccount.currency.id === "tezos") {
+    return new UnavailableTezosOriginatedAccountReceive("");
+  }
+};
+export function canBeMigrated(account: Account): boolean {
+  try {
+    const { version } = decodeAccountId(account.id);
+
+    if (getEnv("MOCK")) {
+      return version === "0";
+    }
+
+    return false;
+  } catch (e) {
+    return false;
+  }
+}
+// attempt to find an account in scanned accounts that satisfy a migration
+export function findAccountMigration(
+  account: Account,
+  scannedAccounts: Account[]
+): Account | null | undefined {
+  if (!canBeMigrated(account)) return;
+
+  if (getEnv("MOCK")) {
+    return scannedAccounts.find(
+      (a) =>
+        a.id !== account.id && // a migration assume an id changes
+        a.currency === account.currency &&
+        a.freshAddress === account.freshAddress
+    );
+  }
+}
+export function checkAccountSupported(
+  account: Account
+): Error | null | undefined {
+  if (
+    !getAllDerivationModes().includes(account.derivationMode as DerivationMode)
+  ) {
+    return new AccountNotSupported(
+      "derivation not supported " + account.derivationMode,
+      {
+        reason: account.derivationMode,
+      }
+    );
+  }
+
+  if (!isCurrencySupported(account.currency)) {
+    const currencyName = account.currency.name;
+    return new CurrencyNotSupported("currency not supported: " + currencyName, {
+      currencyName,
+    });
+  }
+}

package/src/account.test.ts

@@ -0,0 +1,237 @@
+import "./test-helpers/staticTime";
+import { BigNumber } from "bignumber.js";
+import flatMap from "lodash/flatMap";
+import {
+  getCryptoCurrencyById,
+  getTokenById,
+  setSupportedCurrencies,
+} from "./currencies";
+import {
+  groupAccountOperationsByDay,
+  groupAccountsOperationsByDay,
+  shortAddressPreview,
+  accountWithMandatoryTokens,
+  withoutToken,
+} from "./account";
+import { genAccount } from "./mocks/account";
+import { Operation } from "@ledgerhq/types-live";
+import { SubAccount } from "@ledgerhq/types-live";
+
+setSupportedCurrencies(["ethereum", "ethereum_classic", "tron"]);
+
+describe("groupAccountOperationsByDay", () => {
+  test("basic", () => {
+    const account = genAccount("seed_7", {
+      operationsSize: 20,
+    });
+    const res1 = groupAccountOperationsByDay(account, {
+      count: 10,
+    });
+    expect(res1.completed).toBe(false);
+    expect(res1).toMatchSnapshot();
+    const res2 = groupAccountOperationsByDay(account, {
+      count: Infinity,
+    });
+    expect(res2.completed).toBe(true);
+    expect(
+      // $FlowFixMe
+      flatMap(res2.sections, (s) => s.data).slice(0, 10)
+    ).toMatchObject(
+      // $FlowFixMe
+      flatMap(res1.sections, (s) => s.data)
+    );
+  });
+  test("basic 2", () => {
+    const accounts = Array(10)
+      .fill(null)
+      .map((_, i) => genAccount("gaobd" + i));
+    const res1 = groupAccountsOperationsByDay(accounts, {
+      count: 100,
+    });
+    expect(res1.completed).toBe(false);
+    expect(res1).toMatchSnapshot();
+    const res2 = groupAccountsOperationsByDay(accounts, {
+      count: Infinity,
+    });
+    expect(res2.completed).toBe(true);
+    expect(
+      // $FlowFixMe
+      flatMap(res2.sections, (s) => s.data).slice(0, 100)
+    ).toMatchObject(
+      // $FlowFixMe
+      flatMap(res1.sections, (s) => s.data)
+    );
+  });
+  test("filterOperation", () => {
+    const account = genAccount("seed_7");
+    account.pendingOperations = account.operations.splice(0, 2);
+    const res1 = groupAccountOperationsByDay(account, {
+      count: 10,
+      filterOperation: () => false,
+    });
+    expect(res1.sections.length).toBe(0);
+    expect(res1.completed).toBe(true);
+    const res2 = groupAccountOperationsByDay(account, {
+      count: 10,
+      filterOperation: () => true,
+    });
+    expect(res2).toEqual(
+      groupAccountOperationsByDay(account, {
+        count: 10,
+      })
+    );
+    const res3 = groupAccountOperationsByDay(account, {
+      count: 10,
+      filterOperation: (op, acc) => {
+        expect(acc).toBe(account);
+        return op.type === "OUT";
+      },
+    });
+    expect(res3).toEqual(
+      groupAccountOperationsByDay(
+        {
+          ...account,
+          operations: account.operations.filter((op) => op.type === "OUT"),
+          pendingOperations: account.pendingOperations.filter(
+            (op) => op.type === "OUT"
+          ),
+        },
+        {
+          count: 10,
+        }
+      )
+    );
+  });
+  test("provide at least the requested count even if some op yield nothing", () => {
+    const ethAccount = genAccount("eth_1", {
+      currency: getCryptoCurrencyById("ethereum"),
+      operationsSize: 300,
+    });
+    ethAccount.operations = Array(50)
+      .fill({
+        ...ethAccount.operations[0],
+        value: new BigNumber(0),
+        type: "NONE",
+      })
+      .concat(ethAccount.operations);
+    const res1 = groupAccountOperationsByDay(ethAccount, {
+      count: 100,
+    });
+    expect(res1.completed).toBe(false);
+    expect(
+      res1.sections.reduce((acc, s) => acc.concat(s.data), <Operation[]>[])
+        .length
+    ).toBeGreaterThanOrEqual(100);
+  });
+  test("to dedup", () => {
+    const account = genAccount("seed_8");
+    account.pendingOperations = account.operations.slice(0, 3);
+    const accountClone = genAccount("seed_8");
+    const res1 = groupAccountOperationsByDay(account, {
+      count: 100,
+    });
+    const res2 = groupAccountOperationsByDay(accountClone, {
+      count: 100,
+    });
+    expect(res1).toMatchObject(res2);
+  });
+});
+test("shortAddressPreview", () => {
+  expect(
+    shortAddressPreview("0x112233445566778899001234567890aAbBcCdDeEfF")
+  ).toBe("0x112233...cCdDeEfF");
+  expect(
+    shortAddressPreview("0x112233445566778899001234567890aAbBcCdDeEfF", 30)
+  ).toBe("0x11223344556...0aAbBcCdDeEfF");
+});
+test("accountWithMandatoryTokens ethereum", () => {
+  const currency = getCryptoCurrencyById("ethereum");
+  const account = genAccount("", {
+    currency,
+    subAccountsCount: 5,
+  });
+  const enhance = accountWithMandatoryTokens(account, [
+    getTokenById("ethereum/erc20/0x_project"),
+  ]);
+  const doubleEnhance = accountWithMandatoryTokens(enhance, [
+    getTokenById("ethereum/erc20/0x_project"),
+  ]);
+  expect(doubleEnhance).toEqual(enhance);
+  expect({ ...enhance, subAccounts: [] }).toMatchObject({
+    ...account,
+    subAccounts: [],
+  });
+  expect((enhance.subAccounts || []).map((a) => a.id)).toMatchSnapshot();
+});
+test("withoutToken ethereum", () => {
+  const isTokenAccount = (account: SubAccount, tokenId: string) =>
+    account.type === "TokenAccount" && account.token.id === tokenId;
+
+  const tokenIds = [
+    "ethereum/erc20/0x_project",
+    "ethereum/erc20/leo_token",
+    "ethereum/erc20/cro",
+    "ethereum/erc20/huobitoken",
+  ];
+  const currency = getCryptoCurrencyById("ethereum");
+  const account = genAccount("", {
+    currency,
+    subAccountsCount: 0,
+  });
+  //Enhance the account with some tokens
+  const enhance = accountWithMandatoryTokens(
+    account,
+    tokenIds.map(getTokenById)
+  );
+  //Get a version of that account without all the tokens
+  let demote = enhance;
+
+  for (const tokenId of tokenIds) {
+    demote = withoutToken(demote, tokenId);
+  }
+
+  const saTokens = enhance.subAccounts || [];
+  const saNoTokens = demote.subAccounts || [];
+
+  //See if we have added/removed them correctly
+  for (const tokenId of tokenIds) {
+    expect(saTokens.find((a) => isTokenAccount(a, tokenId))).toBeTruthy();
+    expect(saNoTokens.find((a) => isTokenAccount(a, tokenId))).toBeFalsy();
+  }
+});
+test("withoutToken tron", () => {
+  const isTokenAccount = (account: SubAccount, tokenId: string) =>
+    account.type === "TokenAccount" && account.token.id === tokenId;
+
+  const tokenIds = [
+    "tron/trc10/1002000",
+    "tron/trc10/1002398",
+    "tron/trc10/1000226",
+    "tron/trc20/TLa2f6VPqDgRE67v1736s7bJ8Ray5wYjU7",
+  ];
+  const currency = getCryptoCurrencyById("tron");
+  const account = genAccount("", {
+    currency,
+    subAccountsCount: 0,
+  });
+  //Enhance the account with some tokens
+  const enhance = accountWithMandatoryTokens(
+    account,
+    tokenIds.map(getTokenById)
+  );
+  //Get a version of that account without all the tokens
+  let demote = enhance;
+
+  for (const tokenId of tokenIds) {
+    demote = withoutToken(demote, tokenId);
+  }
+
+  const saTokens = enhance.subAccounts || [];
+  const saNoTokens = demote.subAccounts || [];
+
+  //See if we have added/removed them correctly
+  for (const tokenId of tokenIds) {
+    expect(saTokens.find((a) => isTokenAccount(a, tokenId))).toBeTruthy();
+    expect(saNoTokens.find((a) => isTokenAccount(a, tokenId))).toBeFalsy();
+  }
+});

package/src/bot/bot-test-context.test.ts

@@ -0,0 +1,37 @@
+import { botTest, getContext } from "./bot-test-context";
+import { formatError } from "./formatters";
+
+describe("test the botTest context itself", () => {
+  test("botTest", () => {
+    const f = () => {
+      try {
+        botTest("CTX", () => expect(true).toEqual(false));
+      } catch (e) {
+        return getContext(e);
+      }
+    };
+    expect(f()).toEqual("CTX");
+  });
+
+  test("double botTest", () => {
+    const f = () => {
+      try {
+        botTest("1", () => botTest("2", () => expect(true).toEqual(false)));
+      } catch (e) {
+        return getContext(e);
+      }
+    };
+    expect(f()).toEqual("1 > 2");
+  });
+
+  test("formatError", () => {
+    const f = () => {
+      try {
+        botTest("CTX", () => expect(true).toEqual(false));
+      } catch (e) {
+        return formatError(e);
+      }
+    };
+    expect(f()?.slice(0, 8)).toEqual("TEST CTX");
+  });
+});

package/src/bot/bot-test-context.ts

@@ -0,0 +1,24 @@
+type EnhancedError = Error & {
+  _bot_context?: string[];
+};
+
+// This provides a botTest("description", () => {}) helper in order to give context in bot expect tests
+export function botTest(description: string, f: () => void): void {
+  try {
+    f();
+  } catch (e) {
+    if (e instanceof Error) {
+      const err = e as EnhancedError;
+      err._bot_context = [description].concat(err._bot_context || []);
+      throw err;
+    }
+    throw e;
+  }
+}
+
+// retrieve the text context of a given error that was thrown from inside a botTest(...)
+export function getContext(error: any): string | undefined {
+  if (error instanceof Error) {
+    return ((error as EnhancedError)._bot_context || []).join(" > ");
+  }
+}

package/src/bot/formatters.ts

@@ -0,0 +1,22 @@
+import { getContext } from "./bot-test-context";
+
+export function formatError(e: unknown, longform = false): string {
+  let out = "";
+  if (!e || typeof e !== "object") {
+    out = String(e);
+  } else if (e instanceof Error) {
+    const ctx = getContext(e);
+    if (ctx) out += `TEST ${ctx}\n`;
+    out += String(e);
+  } else {
+    try {
+      out = "raw object: " + JSON.stringify(e);
+    } catch (_e) {
+      out = String(e);
+    }
+  }
+  if (longform) {
+    return out.slice(0, 500);
+  }
+  return out.replace(/[`]/g, "").replace(/\n/g, " ").slice(0, 200);
+}