@ledgerhq/coin-framework 0.0.2

package/src/__snapshots__/cross.test.ts.snap

@@ -0,0 +1,57 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`encode/decode 1`] = `
+Object {
+  "accounts": Array [
+    Object {
+      "balance": "12967737976259358331",
+      "currencyId": "ethereum",
+      "derivationMode": "",
+      "freshAddress": "0xF882CE5EF3E667AAFF592AE27793E0CF40356D1E",
+      "id": "mock:1:ethereum:export_0:",
+      "index": 1,
+      "name": "uuwygRL0AmMrs9riAlv1",
+      "seedIdentifier": "mock",
+    },
+    Object {
+      "balance": "2614205810671014878",
+      "currencyId": "ethereum",
+      "derivationMode": "",
+      "freshAddress": "0x22FF1149E5C7585F99647784C2D2A8D6415979F3",
+      "id": "mock:1:ethereum:export_1:",
+      "index": 1,
+      "name": "4GEb2iRQXlUt6X1jviKzSz4umwWj",
+      "seedIdentifier": "mock",
+    },
+    Object {
+      "balance": "288566332368580450524",
+      "currencyId": "ethereum_classic",
+      "derivationMode": "",
+      "freshAddress": "0x96B35855C525CA59FEEC9F1F88B6A59645C0034D",
+      "id": "mock:0:ethereum_classic:export_2:",
+      "index": 1,
+      "name": "tzPbPqv6XS7BabfsuJff",
+      "seedIdentifier": "mock",
+    },
+  ],
+  "meta": Object {
+    "exporterName": "test",
+    "exporterVersion": "0.0.0",
+  },
+  "settings": Object {
+    "blacklistedTokenIds": Array [
+      "tokenid1",
+      "tokenid2",
+    ],
+    "counterValue": "USD",
+    "currenciesSettings": Object {
+      "bitcoin": Object {
+        "confirmationsNb": 3,
+      },
+    },
+    "pairExchanges": Object {
+      "BTC_USD": "KRAKEN",
+    },
+  },
+}
+`;

package/src/account/accountId.ts

@@ -0,0 +1,93 @@
+import memoize from "lodash/memoize";
+import invariant from "invariant";
+import { asDerivationMode } from "../derivation";
+import { getCryptoCurrencyById, findTokenById } from "../currencies";
+import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets";
+import type { AccountIdParams, DerivationMode } from "@ledgerhq/types-live";
+import type {
+  CryptoCurrency,
+  TokenCurrency,
+} from "@ledgerhq/types-cryptoassets";
+
+function ensureNoColon(value: string, ctx: string): string {
+  invariant(
+    !value.includes(":"),
+    "AccountId '%s' component must not use colon",
+    ctx
+  );
+  return value;
+}
+
+export function encodeAccountId({
+  type,
+  version,
+  currencyId,
+  xpubOrAddress,
+  derivationMode,
+}: AccountIdParams): string {
+  return `${ensureNoColon(type, "type")}:${ensureNoColon(
+    version,
+    "version"
+  )}:${ensureNoColon(currencyId, "currencyId")}:${ensureNoColon(
+    xpubOrAddress,
+    "xpubOrAddress"
+  )}:${ensureNoColon(derivationMode, "derivationMode")}`;
+}
+export function encodeTokenAccountId(
+  accountId: string,
+  token: TokenCurrency
+): string {
+  return accountId + "+" + encodeURIComponent(token.id);
+}
+export function decodeTokenAccountId(id: string): {
+  accountId: string;
+  token: TokenCurrency | null | undefined;
+} {
+  const [accountId, tokenId] = id.split("+");
+  const decodedTokenId = decodeURIComponent(tokenId);
+  let token = findTokenById(decodedTokenId);
+  if (!token) {
+    const { currencyId } = decodeAccountId(accountId);
+    token = findTokenByAddressInCurrency(decodedTokenId, currencyId);
+  }
+  return {
+    accountId,
+    token,
+  };
+}
+export function decodeAccountId(accountId: string): AccountIdParams {
+  invariant(typeof accountId === "string", "accountId is not a string");
+  const splitted = accountId.split(":");
+  invariant(splitted.length === 5, "invalid size for accountId");
+  const [type, version, currencyId, xpubOrAddress, derivationMode] = splitted;
+  return {
+    type,
+    version,
+    currencyId,
+    xpubOrAddress,
+    derivationMode: asDerivationMode(derivationMode),
+  };
+}
+// you can pass account because type is shape of Account
+// wallet name is a lib-core concept that usually identify a pool of accounts with the same (seed, cointype, derivation scheme) config.
+export function getWalletName({
+  seedIdentifier,
+  derivationMode,
+  currency,
+}: {
+  seedIdentifier: string;
+  derivationMode: DerivationMode;
+  currency: CryptoCurrency;
+}): string {
+  return `${seedIdentifier}_${currency.id}_${derivationMode}`;
+}
+export const inferFamilyFromAccountId: (
+  accountId: string
+) => string | null | undefined = memoize((accountId) => {
+  try {
+    const { currencyId } = decodeAccountId(accountId);
+    return getCryptoCurrencyById(currencyId).family;
+  } catch (e) {
+    return null;
+  }
+});

package/src/account/accountName.ts

@@ -0,0 +1,25 @@
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { Account, DerivationMode } from "@ledgerhq/types-live";
+
+const MAX_ACCOUNT_NAME_SIZE = 50;
+export const getAccountPlaceholderName = ({
+  currency,
+  index,
+}: {
+  currency: CryptoCurrency;
+  index: number;
+  derivationMode: DerivationMode;
+}): string => {
+  return `${currency.name} ${index + 1}`;
+};
+export const getNewAccountPlaceholderName = getAccountPlaceholderName; // same naming
+
+export const validateNameEdition = (
+  account: Account,
+  name?: string | null | undefined
+): string =>
+  (
+    (name || account.name || "").replace(/\s+/g, " ").trim() ||
+    account.name ||
+    getAccountPlaceholderName(account)
+  ).slice(0, MAX_ACCOUNT_NAME_SIZE);

package/src/account/addAccounts.ts

@@ -0,0 +1,236 @@
+import type { Account, DerivationMode } from "@ledgerhq/types-live";
+import uniqWith from "lodash/uniqWith";
+import { validateNameEdition } from "./accountName";
+import { clearAccount } from "./helpers";
+import { findAccountMigration } from "./support";
+// Reference all possible support link
+// For now we have only one, but we can union type in future
+// We can map .id to a wording.
+export type AddAccountSupportLink = {
+  id: "segwit_or_native_segwit";
+  url: string;
+};
+export type AddAccountsSection = {
+  id: string;
+  selectable: boolean;
+  defaultSelected: boolean;
+  data: Account[];
+  supportLink?: AddAccountSupportLink;
+};
+export type AddAccountsSectionResult = {
+  sections: AddAccountsSection[];
+  alreadyEmptyAccount: Account | null | undefined;
+};
+
+function sameAccountIdentity(a: Account, b: Account) {
+  return (
+    a.id === b.id ||
+    (a.freshAddress
+      ? a.currency === b.currency && a.freshAddress === b.freshAddress
+      : false) ||
+    (a.xpub ? a.currency === b.currency && a.xpub === b.xpub : false)
+  );
+}
+
+/**
+ * logic that for the Add Accounts sectioned list
+ */
+export function groupAddAccounts(
+  existingAccounts: Account[],
+  scannedAccounts: Account[],
+  context: {
+    scanning: boolean;
+    preferredNewAccountSchemes?: DerivationMode[];
+  }
+): AddAccountsSectionResult {
+  const importedAccounts: Account[] = [];
+  const importableAccounts: Account[] = [];
+  const creatableAccounts: Account[] = [];
+  const migrateAccounts: Account[] = [];
+  let alreadyEmptyAccount: Account | null = null;
+  const scannedAccountsWithoutMigrate = [...scannedAccounts];
+  existingAccounts.forEach((existingAccount) => {
+    const migrate = findAccountMigration(
+      existingAccount,
+      scannedAccountsWithoutMigrate
+    );
+
+    if (migrate) {
+      migrateAccounts.push({ ...migrate, name: existingAccount.name });
+      const index = scannedAccountsWithoutMigrate.indexOf(migrate);
+
+      if (index !== -1) {
+        scannedAccountsWithoutMigrate[index] =
+          scannedAccountsWithoutMigrate[
+            scannedAccountsWithoutMigrate.length - 1
+          ];
+        scannedAccountsWithoutMigrate.pop();
+      }
+    }
+  });
+  scannedAccountsWithoutMigrate.forEach((acc) => {
+    const existingAccount = existingAccounts.find((a) =>
+      sameAccountIdentity(a, acc)
+    );
+
+    if (existingAccount) {
+      if (!acc.used && !alreadyEmptyAccount) {
+        alreadyEmptyAccount = existingAccount;
+      }
+
+      importedAccounts.push(existingAccount);
+    } else if (!acc.used) {
+      creatableAccounts.push(acc);
+    } else {
+      importableAccounts.push(acc);
+    }
+  });
+  const sections: Array<{
+    id: string;
+    selectable: boolean;
+    defaultSelected: boolean;
+    data: any;
+  }> = [];
+
+  if (importableAccounts.length) {
+    sections.push({
+      id: "importable",
+      selectable: true,
+      defaultSelected: true,
+      data: importableAccounts,
+    });
+  }
+
+  if (migrateAccounts.length) {
+    sections.push({
+      id: "migrate",
+      selectable: true,
+      defaultSelected: true,
+      data: migrateAccounts,
+    });
+  }
+
+  if (!context.scanning || creatableAccounts.length) {
+    // NB if data is empty, need to do custom placeholder that depends on alreadyEmptyAccount
+    sections.push({
+      id: "creatable",
+      selectable: true,
+      defaultSelected: false,
+      data:
+        context.preferredNewAccountSchemes &&
+        context.preferredNewAccountSchemes.length > 0
+          ? creatableAccounts.filter(
+              (a) =>
+                context.preferredNewAccountSchemes &&
+                // Note: we could use a simple preferredNewAccountScheme param
+                a.derivationMode === context.preferredNewAccountSchemes[0]
+            )
+          : creatableAccounts,
+    });
+  }
+
+  if (importedAccounts.length) {
+    sections.push({
+      id: "imported",
+      selectable: false,
+      defaultSelected: false,
+      data: importedAccounts,
+    });
+  }
+
+  return {
+    sections,
+    alreadyEmptyAccount,
+  };
+}
+export type AddAccountsProps = {
+  existingAccounts: Account[];
+  scannedAccounts: Account[];
+  selectedIds: string[];
+  renamings: Record<string, string>;
+};
+
+const preserveUserData = (update: Account, existing: Account): Account => ({
+  ...update,
+  name: existing.name,
+});
+
+export function migrateAccounts({
+  scannedAccounts,
+  existingAccounts,
+}: {
+  scannedAccounts: Account[];
+  existingAccounts: Account[];
+}): Account[] {
+  // subset of scannedAccounts that exists to not add them but just do migration part
+  const subset: Account[] = [];
+  existingAccounts.forEach((existing) => {
+    const migration = findAccountMigration(existing, scannedAccounts);
+
+    if (migration && !subset.some((a) => a.id === migration.id)) {
+      subset.push(migration);
+    }
+  });
+  return addAccounts({
+    scannedAccounts: subset,
+    existingAccounts,
+    selectedIds: subset.map((a) => a.id),
+    renamings: {},
+  });
+}
+export function addAccounts({
+  scannedAccounts,
+  existingAccounts,
+  selectedIds,
+  renamings,
+}: AddAccountsProps): Account[] {
+  const newAccounts: Account[] = [];
+  // scanned accounts that was selected
+  const selected = scannedAccounts.filter((a) => selectedIds.includes(a.id));
+  // we'll search for potential migration and append to newAccounts
+  existingAccounts.forEach((existing) => {
+    const migration = findAccountMigration(existing, selected);
+
+    if (migration) {
+      if (!newAccounts.some((a) => a.id === migration.id)) {
+        newAccounts.push(preserveUserData(migration, existing));
+        const index = selected.indexOf(migration);
+
+        if (index !== -1) {
+          selected[index] = selected[selected.length - 1];
+          selected.pop();
+        }
+      }
+    } else {
+      // we'll try to find an updated version of the existing account as opportunity to refresh the operations
+      const update = selected.find((a) => sameAccountIdentity(a, existing));
+
+      if (update) {
+        // preserve existing name
+        let acc = preserveUserData(update, existing);
+
+        if (update.id !== existing.id) {
+          acc = clearAccount(acc);
+        }
+
+        newAccounts.push(acc);
+      } else {
+        newAccounts.push(existing);
+      }
+    }
+  });
+  // append the new accounts
+  selected.forEach((acc) => {
+    const alreadyThere = newAccounts.find((a) => sameAccountIdentity(a, acc));
+
+    if (!alreadyThere) {
+      newAccounts.push(acc);
+    }
+  });
+  // dedup and apply the renaming
+  return uniqWith(newAccounts, sameAccountIdentity).map((a) => {
+    const name = validateNameEdition(a, renamings[a.id]);
+    if (name) return { ...a, name };
+    return a;
+  });
+}

package/src/account/balanceHistoryCache.ts

@@ -0,0 +1,146 @@
+import type {
+  GranularityId,
+  BalanceHistoryCache,
+  BalanceHistoryDataCache,
+  AccountLike,
+  Account,
+  SubAccount,
+} from "@ledgerhq/types-live";
+import { getOperationAmountNumberWithInternals } from "../operation";
+import { granularities } from "../rangeDates";
+export const emptyHistoryCache = {
+  HOUR: {
+    latestDate: null,
+    balances: [],
+  },
+  DAY: {
+    latestDate: null,
+    balances: [],
+  },
+  WEEK: {
+    latestDate: null,
+    balances: [],
+  },
+};
+
+function generateHistoryFromOperationsG(
+  account: AccountLike,
+  g: GranularityId, // partial=true allows a faster implementation that only recompose the last part of the history
+  // to only use when we do not recalculate the history but we just want to access it
+  partial = false
+): BalanceHistoryDataCache {
+  const { increment, startOf, maxDatapoints } = granularities[g];
+  const latestDate = startOf(new Date()).getTime();
+  let balances: number[] = [];
+  let { balance } = account;
+  const operationsLength = account.operations.length;
+  let date = latestDate;
+  const reference = account.balanceHistoryCache[g];
+
+  for (let i = 0; i < operationsLength; ) {
+    if (
+      (partial && reference.latestDate && date < reference.latestDate) ||
+      balances.length > maxDatapoints
+    ) {
+      break;
+    }
+
+    // accumulate operations after time t
+    while (
+      i < operationsLength &&
+      // FIXME: added valueOf here to make typescript happy
+      account.operations[i].date.valueOf() > date
+    ) {
+      balance = balance.minus(
+        getOperationAmountNumberWithInternals(account.operations[i])
+      );
+      i++;
+    }
+
+    balances.unshift(Math.max(balance.toNumber(), 0));
+    date -= increment;
+  }
+
+  if (partial) {
+    balances = reference.balances.concat(balances);
+  }
+
+  return {
+    balances,
+    latestDate,
+  };
+}
+
+export function generateHistoryFromOperations(
+  account: AccountLike
+): BalanceHistoryCache {
+  return {
+    HOUR: generateHistoryFromOperationsG(account, "HOUR"),
+    DAY: generateHistoryFromOperationsG(account, "DAY"),
+    WEEK: generateHistoryFromOperationsG(account, "WEEK"),
+  };
+}
+
+/**
+ * get the current balance history of the account. if possible from the cache.
+ */
+export function getAccountHistoryBalances(
+  account: AccountLike,
+  g: GranularityId
+): number[] {
+  const { balances, latestDate } = account.balanceHistoryCache[g];
+  const { startOf } = granularities[g];
+  const now = startOf(new Date()).getTime();
+
+  if (latestDate && latestDate === now) {
+    return balances;
+  }
+
+  // account cache was not up to date. recalculating on the fly
+  return generateHistoryFromOperationsG(account, g, true).balances;
+}
+
+/**
+ * utility used at the end of an account synchronisation to recalculate the balance history if necessary
+ */
+export function recalculateAccountBalanceHistories(
+  res: Account,
+  prev: Account
+): Account {
+  // recalculate balance history cache
+  if (prev.balanceHistoryCache === res.balanceHistoryCache) {
+    // we only regenerate if it was not overriden by the implemenetation.
+    res = { ...res, balanceHistoryCache: generateHistoryFromOperations(res) };
+  }
+
+  const prevSubAccounts = prev.subAccounts;
+  const nextSubAccounts = res.subAccounts;
+
+  if (
+    nextSubAccounts &&
+    prevSubAccounts &&
+    prevSubAccounts !== nextSubAccounts
+  ) {
+    // when sub accounts changes, we need to recalculate
+    res.subAccounts = nextSubAccounts.map(
+      (subAccount: SubAccount): SubAccount => {
+        const old = prevSubAccounts.find((a) => a.id === subAccount.id);
+
+        if (
+          !old ||
+          old.balanceHistoryCache === subAccount.balanceHistoryCache
+        ) {
+          // we only regenerate if it was not overriden by the implemenetation.
+          subAccount = {
+            ...subAccount,
+            balanceHistoryCache: generateHistoryFromOperations(subAccount),
+          };
+        }
+
+        return subAccount;
+      }
+    );
+  }
+
+  return res;
+}