@ledgerhq/coin-framework 0.0.2

package/src/operation.ts

@@ -0,0 +1,212 @@
+import type { Account, AccountLike, Operation } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+
+export function findOperationInAccount(
+  { operations, pendingOperations }: AccountLike,
+  operationId: string
+): Operation | null | undefined {
+  for (let i = 0; i < operations.length; i++) {
+    const op = operations[i];
+    if (op.id === operationId) return op;
+
+    if (op.internalOperations) {
+      const internalOps = op.internalOperations;
+
+      for (let j = 0; j < internalOps.length; j++) {
+        const internalOp = internalOps[j];
+        if (internalOp.id === operationId) return internalOp;
+      }
+    }
+
+    if (op.nftOperations) {
+      const nftOps = op.nftOperations;
+
+      for (let j = 0; j < nftOps.length; j++) {
+        const nftOp = nftOps[j];
+
+        if (nftOp.id === operationId) return nftOp;
+      }
+    }
+  }
+
+  for (let i = 0; i < pendingOperations.length; i++) {
+    const op = pendingOperations[i];
+    if (op.id === operationId) return op;
+
+    if (op.nftOperations) {
+      const nftOps = op.nftOperations;
+
+      for (let j = 0; j < nftOps.length; j++) {
+        const nftOp = nftOps[j];
+
+        if (nftOp.id === operationId) return nftOp;
+      }
+    }
+  }
+
+  return null;
+}
+
+export function encodeOperationId(
+  accountId: string,
+  hash: string,
+  type: string
+): string {
+  return `${accountId}-${hash}-${type}`;
+}
+
+export function decodeOperationId(id: string): {
+  accountId: string;
+  hash: string;
+  type: string;
+} {
+  const [accountId, hash, type] = id.split("-");
+  return {
+    accountId,
+    hash,
+    type,
+  };
+}
+
+export function encodeSubOperationId(
+  accountId: string,
+  hash: string,
+  type: string,
+  index: string | number
+): string {
+  return `${accountId}-${hash}-${type}-i${index}`;
+}
+
+export function decodeSubOperationId(id: string): {
+  accountId: string;
+  hash: string;
+  type: string;
+  index: number;
+} {
+  const [accountId, hash, type, index] = id.split("-");
+  return {
+    accountId,
+    hash,
+    type,
+    index: Number(index),
+  };
+}
+
+export function patchOperationWithHash(
+  operation: Operation,
+  hash: string
+): Operation {
+  return {
+    ...operation,
+    hash,
+    id: encodeOperationId(operation.accountId, hash, operation.type),
+    subOperations:
+      operation.subOperations &&
+      operation.subOperations.map((op) => ({
+        ...op,
+        hash,
+        id: encodeOperationId(op.accountId, hash, op.type),
+      })),
+  };
+}
+
+export function flattenOperationWithInternalsAndNfts(
+  op: Operation
+): Operation[] {
+  let ops: Operation[] = [];
+
+  // ops of type NONE does not appear in lists
+  if (op.type !== "NONE") {
+    ops.push(op);
+  }
+
+  // all internal operations are expanded after the main op
+  if (op.internalOperations) {
+    ops = ops.concat(op.internalOperations);
+  }
+
+  // all nfts operations are expanded after the main op
+  if (op.nftOperations) {
+    ops = ops.concat(op.nftOperations);
+  }
+
+  return ops;
+}
+
+export function getOperationAmountNumber(op: Operation): BigNumber {
+  switch (op.type) {
+    case "IN":
+    case "REWARD":
+    case "REWARD_PAYOUT":
+    case "SUPPLY":
+    case "WITHDRAW":
+      return op.value;
+
+    case "OUT":
+    case "REVEAL":
+    case "CREATE":
+    case "FEES":
+    case "DELEGATE":
+    case "REDELEGATE":
+    case "UNDELEGATE":
+    case "OPT_IN":
+    case "OPT_OUT":
+    case "REDEEM":
+    case "SLASH":
+    case "LOCK":
+      return op.value.negated();
+
+    case "FREEZE":
+    case "UNFREEZE":
+    case "VOTE":
+    case "BOND":
+    case "UNBOND":
+    case "WITHDRAW_UNBONDED":
+    case "SET_CONTROLLER":
+    case "NOMINATE":
+    case "CHILL":
+    case "REVOKE":
+    case "APPROVE":
+    case "ACTIVATE":
+    case "UNLOCK":
+    case "STAKE":
+    case "UNSTAKE":
+    case "WITHDRAW_UNSTAKED":
+      return op.fee.negated();
+
+    default:
+      return new BigNumber(0);
+  }
+}
+
+export function getOperationAmountNumberWithInternals(
+  op: Operation
+): BigNumber {
+  return flattenOperationWithInternalsAndNfts(op).reduce(
+    (amount: BigNumber, op) => amount.plus(getOperationAmountNumber(op)),
+    new BigNumber(0)
+  );
+}
+
+export const getOperationConfirmationNumber = (
+  operation: Operation,
+  account: Account
+): number =>
+  operation.blockHeight ? account.blockHeight - operation.blockHeight + 1 : 0;
+
+export const getOperationConfirmationDisplayableNumber = (
+  operation: Operation,
+  account: Account
+): string =>
+  account.blockHeight && operation.blockHeight && account.currency.blockAvgTime
+    ? String(account.blockHeight - operation.blockHeight + 1)
+    : "";
+
+export const isConfirmedOperation = (
+  operation: Operation,
+  account: Account,
+  confirmationsNb: number
+): boolean =>
+  operation.blockHeight
+    ? account.blockHeight - operation.blockHeight + 1 >= confirmationsNb
+    : false;

package/src/promise.test.ts

@@ -0,0 +1,20 @@
+import { promiseAllBatched } from "./promise";
+test("promiseAllBatched", async () => {
+  const promisifyIdPlusOne = (a: number) => Promise.resolve(a + 1);
+
+  const p = promiseAllBatched(5, [], promisifyIdPlusOne);
+  expect(typeof p.then).toBe("function");
+  expect(await p).toEqual([]);
+  expect(
+    await promiseAllBatched(5, [1, 2, 3, 4, 5, 6, 7, 8], promisifyIdPlusOne)
+  ).toEqual([2, 3, 4, 5, 6, 7, 8, 9]);
+  expect(
+    await promiseAllBatched(1, [1, 2, 3, 4, 5, 6, 7, 8], promisifyIdPlusOne)
+  ).toEqual([2, 3, 4, 5, 6, 7, 8, 9]);
+  expect(
+    await promiseAllBatched(10, [1, 2, 3, 4, 5, 6, 7, 8], promisifyIdPlusOne)
+  ).toEqual([2, 3, 4, 5, 6, 7, 8, 9]);
+  expect(
+    await promiseAllBatched(2, Array(6).fill(0), (_, i) => Promise.resolve(i))
+  ).toEqual([0, 1, 2, 3, 4, 5]);
+});

package/src/promise.ts

@@ -0,0 +1,101 @@
+import { log } from "@ledgerhq/logs";
+export const delay = (ms: number): Promise<void> =>
+  new Promise((f) => setTimeout(f, ms));
+const defaults = {
+  maxRetry: 4,
+  interval: 300,
+  intervalMultiplicator: 1.5,
+  context: "",
+};
+export function retry<A>(
+  f: () => Promise<A>,
+  options?: Partial<typeof defaults>
+): Promise<A> {
+  const { maxRetry, interval, intervalMultiplicator, context } = {
+    ...defaults,
+    ...options,
+  };
+
+  function rec(remainingTry: number, i: number): Promise<A> {
+    const result = f();
+
+    if (remainingTry <= 0) {
+      return result;
+    }
+
+    // In case of failure, wait the interval, retry the action
+    return result.catch((e) => {
+      log(
+        "promise-retry",
+        context + " failed. " + remainingTry + " retry remain. " + String(e)
+      );
+      return delay(i).then(() =>
+        rec(remainingTry - 1, i * intervalMultiplicator)
+      );
+    });
+  }
+
+  return rec(maxRetry, interval);
+}
+type Job<R, A extends Array<any>> = (...args: A) => Promise<R>;
+export const atomicQueue = <R, A extends Array<any>>(
+  job: Job<R, A>,
+  queueIdentifier: (...args: A) => string = () => ""
+): Job<R, A> => {
+  const queues: Record<string, any> = {};
+  return (...args) => {
+    const id = queueIdentifier(...args);
+    const queue = queues[id] || Promise.resolve();
+    const p = queue.then(() => job(...args));
+    queues[id] = p.catch(() => {});
+    return p;
+  };
+};
+export function execAndWaitAtLeast<A>(
+  ms: number,
+  cb: () => Promise<A>
+): Promise<A> {
+  const startTime = Date.now();
+  return cb().then((r) => {
+    const remaining = ms - (Date.now() - startTime);
+    if (remaining <= 0) return r;
+    return delay(remaining).then(() => r);
+  });
+}
+
+/**
+ * promiseAllBatched(n, items, i => f(i))
+ * is essentially like
+ * Promise.all(items.map(i => f(i)))
+ * but with a guarantee that it will not create more than n concurrent call to f
+ * where f is a function that returns a promise
+ */
+export async function promiseAllBatched<A, B>(
+  batch: number,
+  items: Array<A>,
+  fn: (arg0: A, arg1: number) => Promise<B>
+): Promise<B[]> {
+  const data = Array(items.length);
+  const queue = items.map((item, index) => ({
+    item,
+    index,
+  }));
+
+  async function step() {
+    if (queue.length === 0) return;
+    const first = queue.shift();
+    if (first) {
+      const { item, index } = first;
+      data[index] = await fn(item, index);
+    }
+    await step(); // each time an item redeem, we schedule another one
+  }
+
+  // initially, we schedule <batch> items in parallel
+  await Promise.all(
+    Array(Math.min(batch, items.length))
+      .fill(() => undefined)
+      .map(step)
+  );
+  return data;
+}

package/src/rangeDates.test.ts

@@ -0,0 +1,66 @@
+import {
+  startOfHour,
+  startOfMonth,
+  startOfDay,
+  startOfWeek,
+  getPortfolioRangeConfig,
+  getDates,
+  getRanges,
+} from "./rangeDates";
+
+describe("startOfHour", () => {
+  test("basic test", () => {
+    expect(startOfHour(new Date(1655827384305)).toISOString()).toBe(
+      "2022-06-21T16:00:00.000Z"
+    );
+  });
+});
+describe("startOfDay", () => {
+  test("basic test", () => {
+    expect(startOfDay(new Date(1655827384305)).toISOString()).toBe(
+      "2022-06-21T04:00:00.000Z"
+    );
+  });
+});
+describe("startOfMonth", () => {
+  test("basic test", () => {
+    expect(startOfMonth(new Date(1655827384305)).toISOString()).toBe(
+      "2022-06-01T04:00:00.000Z"
+    );
+  });
+});
+describe("startOfWeek", () => {
+  test("basic test", () => {
+    expect(startOfWeek(new Date(1655827384305)).toISOString()).toBe(
+      "2022-06-19T04:00:00.000Z"
+    );
+  });
+});
+describe("getPortfolioRangeConfig", () => {
+  test("returns a value for day", () => {
+    expect(getPortfolioRangeConfig("day")).toBeDefined();
+  });
+  test("returns a value for week", () => {
+    expect(getPortfolioRangeConfig("week")).toBeDefined();
+  });
+  test("returns a value for month", () => {
+    expect(getPortfolioRangeConfig("month")).toBeDefined();
+  });
+});
+describe("getDates", () => {
+  test("day returns an array of asked size", () => {
+    expect(getDates("day", 100).length).toEqual(100);
+  });
+  test("week returns an array of asked size", () => {
+    expect(getDates("week", 100).length).toEqual(100);
+  });
+  test("month returns an array of asked size", () => {
+    expect(getDates("month", 100).length).toEqual(100);
+  });
+});
+
+describe("getRanges", () => {
+  test("returns a non empty array", () => {
+    expect(getRanges().length).toBeGreaterThan(0);
+  });
+});

package/src/rangeDates.ts

@@ -0,0 +1,96 @@
+import type {
+  PortfolioRangeConfig,
+  PortfolioRange,
+} from "@ledgerhq/types-live";
+
+export const hourIncrement = 60 * 60 * 1000;
+export const dayIncrement = 24 * hourIncrement;
+export const weekIncrement = 7 * dayIncrement;
+
+export function startOfHour(t: Date): Date {
+  return new Date(t.getFullYear(), t.getMonth(), t.getDate(), t.getHours());
+}
+
+export function startOfMonth(t: Date): Date {
+  return new Date(t.getFullYear(), t.getMonth(), 1);
+}
+
+export function startOfDay(t: Date): Date {
+  return new Date(t.getFullYear(), t.getMonth(), t.getDate());
+}
+
+export function startOfWeek(t: Date): Date {
+  const d = startOfDay(t);
+  return new Date(d.getTime() - d.getDay() * dayIncrement);
+}
+
+export function getPortfolioRangeConfig(
+  r: PortfolioRange
+): PortfolioRangeConfig {
+  return ranges[r];
+}
+export const granularities = {
+  WEEK: {
+    increment: weekIncrement,
+    startOf: startOfWeek,
+    maxDatapoints: 1000, // (essentially no limit)
+  },
+  DAY: {
+    increment: dayIncrement,
+    startOf: startOfDay,
+    maxDatapoints: 400, // we only need a year
+  },
+  HOUR: {
+    increment: hourIncrement,
+    startOf: startOfHour,
+    maxDatapoints: 8 * 24, // we only need a week
+  },
+};
+// TODO Protfolio: this would require to introduce Account#olderOperationDate
+const ranges: Record<PortfolioRange, PortfolioRangeConfig> = {
+  all: {
+    increment: weekIncrement,
+    startOf: startOfWeek,
+    granularityId: "WEEK",
+  },
+  year: {
+    count: 52,
+    increment: weekIncrement,
+    startOf: startOfWeek,
+    granularityId: "WEEK",
+  },
+  month: {
+    count: 30,
+    increment: dayIncrement,
+    startOf: startOfDay,
+    granularityId: "DAY",
+  },
+  week: {
+    count: 7 * 24,
+    increment: hourIncrement,
+    startOf: startOfHour,
+    granularityId: "HOUR",
+  },
+  day: {
+    count: 24,
+    increment: hourIncrement,
+    startOf: startOfHour,
+    granularityId: "HOUR",
+  },
+};
+export function getDates(r: PortfolioRange, count: number): Date[] {
+  const now = new Date(Date.now());
+  if (count === 1) return [now];
+  const conf = getPortfolioRangeConfig(r);
+  const last = new Date((conf.startOf(now) as any) - 1);
+  const dates = [now];
+
+  for (let i = 0; i < count - 1; i++) {
+    dates.unshift(new Date((last as any) - conf.increment * i));
+  }
+
+  return dates;
+}
+export function getRanges(): string[] {
+  return Object.keys(ranges);
+}

package/src/test-helpers/staticTime.ts

@@ -0,0 +1,4 @@
+import timemachine from "timemachine";
+timemachine.config({
+  dateString: "March 14, 2018 13:34:42",
+});

package/src/transaction/common.ts

@@ -0,0 +1,157 @@
+import { deserializeError, serializeError } from "@ledgerhq/errors";
+import type {
+  Account,
+  TransactionCommon,
+  TransactionCommonRaw,
+  TransactionStatusCommon,
+  TransactionStatusCommonRaw,
+} from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+import { mapValues } from "lodash";
+
+import { getAccountUnit } from "../account";
+import { formatCurrencyUnit } from "../currencies";
+
+type tooltipArgs = Record<string, string>;
+export type CommonDeviceTransactionField =
+  | {
+      type: "amount";
+      label: string;
+    }
+  | {
+      type: "address";
+      label: string;
+      address: string;
+    }
+  | {
+      type: "fees";
+      label: string;
+    }
+  | {
+      type: "text";
+      label: string;
+      value: string;
+      tooltipI18nKey?: string;
+      tooltipI18nArgs?: tooltipArgs;
+    };
+
+export const fromTransactionCommonRaw = (
+  raw: TransactionCommonRaw
+): TransactionCommon => {
+  const common: TransactionCommon = {
+    amount: new BigNumber(raw.amount),
+    recipient: raw.recipient,
+  };
+
+  if ("useAllAmount" in raw) {
+    common.useAllAmount = raw.useAllAmount;
+  }
+
+  if ("subAccountId" in raw) {
+    common.subAccountId = raw.subAccountId;
+  }
+
+  return common;
+};
+
+export const toTransactionCommonRaw = (
+  raw: TransactionCommon
+): TransactionCommonRaw => {
+  const common: TransactionCommonRaw = {
+    amount: raw.amount.toString(),
+    recipient: raw.recipient,
+  };
+
+  if ("useAllAmount" in raw) {
+    common.useAllAmount = raw.useAllAmount;
+  }
+
+  if ("subAccountId" in raw) {
+    common.subAccountId = raw.subAccountId;
+  }
+
+  return common;
+};
+
+const fromErrorRaw = (raw: string): Error => {
+  return deserializeError(JSON.parse(raw)) || new Error("unknown reason");
+};
+
+const toErrorRaw = (raw: Error): string =>
+  JSON.stringify(serializeError(raw)) || "{}";
+
+export const fromTransactionStatusRawCommon = (
+  ts: TransactionStatusCommonRaw
+): TransactionStatusCommon => ({
+  errors: mapValues(ts.errors, fromErrorRaw),
+  warnings: mapValues(ts.warnings, fromErrorRaw),
+  estimatedFees: new BigNumber(ts.estimatedFees),
+  amount: new BigNumber(ts.amount),
+  totalSpent: new BigNumber(ts.totalSpent),
+  recipientIsReadOnly: ts.recipientIsReadOnly,
+});
+
+export const toTransactionStatusRawCommon = (
+  ts: TransactionStatusCommon
+): TransactionStatusCommonRaw => ({
+  errors: mapValues<Record<string, Error>, string>(ts.errors, toErrorRaw),
+  warnings: mapValues<Record<string, Error>, string>(ts.warnings, toErrorRaw),
+  estimatedFees: ts.estimatedFees.toString(),
+  amount: ts.amount.toString(),
+  totalSpent: ts.totalSpent.toString(),
+  recipientIsReadOnly: ts.recipientIsReadOnly,
+});
+
+const formatErrorSmall = (e: Error): string =>
+  e.name === "Error" ? e.message : e.name;
+
+export const formatTransactionStatusCommon = (
+  t: TransactionCommon,
+  {
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  }: TransactionStatusCommon,
+  mainAccount: Account
+): string => {
+  let str = "";
+  const account =
+    (t.subAccountId &&
+      (mainAccount.subAccounts || []).find((a) => a.id === t.subAccountId)) ||
+    mainAccount;
+
+  str +=
+    "\n  amount: " +
+    formatCurrencyUnit(getAccountUnit(account), amount, {
+      showCode: true,
+      disableRounding: true,
+    });
+  str +=
+    "\n  estimated fees: " +
+    formatCurrencyUnit(getAccountUnit(mainAccount), estimatedFees, {
+      showCode: true,
+      disableRounding: true,
+    });
+  str +=
+    "\n  total spent: " +
+    formatCurrencyUnit(getAccountUnit(account), totalSpent, {
+      showCode: true,
+      disableRounding: true,
+    });
+
+  str +=
+    "\n" +
+    `errors: ${Object.entries(errors)
+      .map(([key, error]) => `${key} ${formatErrorSmall(error)}`)
+      .join(", ")}`;
+
+  str +=
+    "\n" +
+    `errors: ${Object.entries(warnings)
+      .map(([key, warning]) => `${key} ${formatErrorSmall(warning)}`)
+      .join(", ")}`;
+
+  return str;
+};