@ledgerhq/live-common 27.0.0 → 27.0.1-next.0

package/src/bot/formatters.ts

@@ -8,30 +8,54 @@ import {
 import { formatCurrencyUnit } from "../currencies";
 import type { MutationReport, AppCandidate } from "./types";
 import type { Transaction } from "../generated/types";
-export const formatTime = (t: number) =>
-  t > 3000
-    ? `${Math.round(t / 100) / 10}s`
+import { getContext } from "./bot-test-context";
+
+const formatTimeMinSec = (t: number) => {
+  const totalsecs = Math.round(t / 1000);
+  const min = Math.floor(totalsecs / 60);
+  const sec = totalsecs - min * 60;
+  if (!sec) return `${min}min`;
+  return `${min}min ${sec}s`;
+};
+
+export const formatTime = (t: number): string =>
+  !t
+    ? "N/A"
+    : t > 3000
+    ? t > 100000
+      ? formatTimeMinSec(t)
+      : `${Math.round(t / 100) / 10}s`
     : `${t < 5 ? t.toFixed(2) : t.toFixed(0)}ms`;
 
 const formatDt = (from, to) => (from && to ? formatTime(to - from) : "?");
 
-export function formatAppCandidate(appCandidate: AppCandidate) {
+export function formatAppCandidate(appCandidate: AppCandidate): string {
   return `${appCandidate.appName} ${appCandidate.appVersion} on ${appCandidate.model} ${appCandidate.firmware}`;
 }
 
-export function formatError(e: any) {
-  if (!e || typeof e !== "object" || e instanceof Error) return String(e);
-  let out;
-  try {
-    out = "raw object: " + JSON.stringify(e);
-  } catch (_e) {
+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(/\n/g, " ").slice(0, 400);
+  return out.replace(/[`]/g, "").replace(/\n/g, " ").slice(0, 200);
 }
 
 export function formatReportForConsole<T extends Transaction>({
-  syncAllAccountsTime,
+  resyncAccountsDuration,
   appCandidate,
   account,
   maxSpendable,
@@ -54,7 +78,9 @@ export function formatReportForConsole<T extends Transaction>({
   error,
 }: MutationReport<T>): string {
   let str = "";
-  str += `all accounts sync in ${formatTime(syncAllAccountsTime)}\n`;
+  str += `necessary accounts resynced in ${formatTime(
+    resyncAccountsDuration
+  )}\n`;
   str += `▬ ${formatAppCandidate(appCandidate)}\n`;
 
   if (account) {
@@ -149,7 +175,7 @@ export function formatReportForConsole<T extends Transaction>({
   }
 
   if (error) {
-    str += `⚠️ ${formatError(error)}\n`;
+    str += `⚠️ ${formatError(error, true)}\n`;
   }
 
   return str;

package/src/bot/index.ts

@@ -2,6 +2,7 @@
 import fs from "fs";
 import path from "path";
 import { BigNumber } from "bignumber.js";
+import uniq from "lodash/uniq";
 import groupBy from "lodash/groupBy";
 import { log } from "@ledgerhq/logs";
 import invariant from "invariant";
@@ -18,7 +19,7 @@ import {
 } from "../currencies";
 import { isAccountEmpty, toAccountRaw } from "../account";
 import { runWithAppSpec } from "./engine";
-import { formatReportForConsole, formatError } from "./formatters";
+import { formatReportForConsole, formatError, formatTime } from "./formatters";
 import {
   initialState,
   loadCountervalues,
@@ -26,6 +27,7 @@ import {
 } from "../countervalues/logic";
 import { getPortfolio } from "../portfolio/v2";
 import { Account } from "@ledgerhq/types-live";
+import { getContext } from "./bot-test-context";
 type Arg = Partial<{
   currency: string;
   family: string;
@@ -48,7 +50,11 @@ function makeAppJSON(accounts: Account[]) {
   return JSON.stringify(jsondata);
 }
 
-export async function bot({ currency, family, mutation }: Arg = {}) {
+export async function bot({
+  currency,
+  family,
+  mutation,
+}: Arg = {}): Promise<void> {
   const SEED = getEnv("SEED");
   invariant(SEED, "SEED required");
   const specs: any[] = [];
@@ -86,6 +92,7 @@ export async function bot({ currency, family, mutation }: Arg = {}) {
     }
   }
 
+  const timeBefore = Date.now();
   const results: Array<SpecReport<any>> = await promiseAllBatched(
     getEnv("BOT_MAX_CONCURRENT"),
     specs,
@@ -94,7 +101,7 @@ export async function bot({ currency, family, mutation }: Arg = {}) {
       specsLogs.push(logs);
       return runWithAppSpec(spec, (message) => {
         log("bot", message);
-        console.log(message);
+        if (process.env.CI) console.log(message);
         logs.push(message);
       }).catch((fatalError) => ({
         spec,
@@ -105,14 +112,15 @@ export async function bot({ currency, family, mutation }: Arg = {}) {
       }));
     }
   );
-  const allAccountsBefore = flatMap(results, (r) => r.accountsBefore || []);
+  const totalDuration = Date.now() - timeBefore;
+  const allAppPaths = uniq(results.map((r) => r.appPath || "").sort());
   const allAccountsAfter = flatMap(results, (r) => r.accountsAfter || []);
   let countervaluesError;
   const countervaluesState = await loadCountervalues(initialState, {
     trackingPairs: inferTrackingPairForAccounts(allAccountsAfter, usd),
     autofillGaps: true,
   }).catch((e) => {
-    console.error(e);
+    if (process.env.CI) console.error(e);
     countervaluesError = e;
     return null;
   });
@@ -174,7 +182,7 @@ export async function bot({ currency, family, mutation }: Arg = {}) {
     (s) => s.unavailableMutations
   );
 
-  if (specFatals.length) {
+  if (specFatals.length && process.env.CI) {
     console.error(`================== SPEC ERRORS =====================\n`);
     specFatals.forEach((c) => {
       console.error(c.fatalError);
@@ -182,7 +190,7 @@ export async function bot({ currency, family, mutation }: Arg = {}) {
     });
   }
 
-  if (errorCases.length) {
+  if (errorCases.length && process.env.CI) {
     console.error(`================== MUTATION ERRORS =====================\n`);
     errorCases.forEach((c) => {
       console.error(formatReportForConsole(c));
@@ -247,6 +255,8 @@ export async function bot({ currency, family, mutation }: Arg = {}) {
   )}`;
   const success = mutationReports.length - errorCases.length;
 
+  title += `⏲ ${formatTime(totalDuration)} `;
+
   if (success > 0) {
     title += `✅ ${success} txs `;
   }
@@ -326,22 +336,35 @@ export async function bot({ currency, family, mutation }: Arg = {}) {
     body += `<summary>${specFatals.length} critical spec errors</summary>\n\n`;
     specFatals.forEach(({ spec, fatalError }) => {
       body += `**Spec ${spec.name} failed!**\n`;
-      body += "```\n" + formatError(fatalError) + "\n```\n\n";
+      body += "```\n" + formatError(fatalError, true) + "\n```\n\n";
       slackBody += `❌ *Spec ${spec.name}*: \`${formatError(fatalError)}\`\n`;
     });
     body += "</details>\n\n";
   }
 
+  // summarize the error causes
+  const dedupedErrorCauses: string[] = [];
+  errorCases.forEach((m) => {
+    if (!m.error) return;
+    const ctx = getContext(m.error);
+    if (!ctx) return;
+    const cause = m.spec.name + " > " + ctx;
+    if (!dedupedErrorCauses.includes(cause)) {
+      dedupedErrorCauses.push(cause);
+    }
+  });
+  if (dedupedErrorCauses.length > 0) {
+    slackBody += "*Hints:*\n";
+    dedupedErrorCauses.forEach((cause) => {
+      slackBody += `- ${cause}\n`;
+    });
+  }
+
   if (errorCases.length) {
     body += "<details>\n";
     body += `<summary>${errorCases.length} mutation errors</summary>\n\n`;
     errorCases.forEach((c) => {
-      body +=
-        "```\n" +
-        formatReportForConsole(c) +
-        "\n" +
-        formatError(c.error) +
-        "\n```\n\n";
+      body += "```\n" + formatReportForConsole(c) + "\n```\n\n";
     });
     body += "</details>\n\n";
   }
@@ -475,6 +498,89 @@ export async function bot({ currency, family, mutation }: Arg = {}) {
   });
   body += "\n</details>\n\n";
 
+  // Add performance details
+  body += "<details>\n";
+  body += `<summary>Performance ⏲ ${formatTime(totalDuration)}</summary>\n\n`;
+  body += "**Time spent for each spec:** (total across mutations)\n";
+
+  function sumMutation(mutations, f) {
+    return mutations?.reduce((sum, m) => sum + (f(m) || 0), 0) || 0;
+  }
+  function sumResults(f) {
+    return results.reduce((sum, r) => sum + (f(r) || 0), 0);
+  }
+  function sumResultsMutation(f) {
+    return sumResults((r) => sumMutation(r.mutations, f));
+  }
+
+  body +=
+    "| Spec (accounts) | preload | scan | re-sync | tx status | sign op | broadcast | mutation confirm |\n";
+  body += "|---|---|---|---|---|---|---|---|\n";
+
+  body += "| **TOTAL** |";
+  body += `**${formatTime(sumResults((r) => r.preloadDuration))}** |`;
+  body += `**${formatTime(sumResults((r) => r.scanDuration))}** |`;
+  body += `**${formatTime(
+    sumResultsMutation((m) => m.resyncAccountsDuration || 0)
+  )}** |`;
+  body += `**${formatTime(
+    sumResultsMutation((m) =>
+      m.mutationTime && m.statusTime ? m.statusTime - m.mutationTime : 0
+    )
+  )}** |`;
+  body += `**${formatTime(
+    sumResultsMutation((m) =>
+      m.statusTime && m.signedTime ? m.signedTime - m.statusTime : 0
+    )
+  )}** |`;
+  body += `**${formatTime(
+    sumResultsMutation((m) =>
+      m.signedTime && m.broadcastedTime ? m.broadcastedTime - m.signedTime : 0
+    )
+  )}** |`;
+  body += `**${formatTime(
+    sumResultsMutation((m) =>
+      m.broadcastedTime && m.confirmedTime
+        ? m.confirmedTime - m.broadcastedTime
+        : 0
+    )
+  )}** |\n`;
+
+  results.forEach((r) => {
+    body += `| ${r.spec.name} (${
+      (r.accountsBefore || []).filter((a) => a.used).length
+    }) |`;
+    body += `${formatTime(r.preloadDuration || 0)} |`;
+    body += `${formatTime(r.scanDuration || 0)} |`;
+    body += `${formatTime(
+      sumMutation(r.mutations, (m) => m.resyncAccountsDuration || 0)
+    )} |`;
+    body += `${formatTime(
+      sumMutation(r.mutations, (m) =>
+        m.mutationTime && m.statusTime ? m.statusTime - m.mutationTime : 0
+      )
+    )} |`;
+    body += `${formatTime(
+      sumMutation(r.mutations, (m) =>
+        m.statusTime && m.signedTime ? m.signedTime - m.statusTime : 0
+      )
+    )} |`;
+    body += `${formatTime(
+      sumMutation(r.mutations, (m) =>
+        m.signedTime && m.broadcastedTime ? m.broadcastedTime - m.signedTime : 0
+      )
+    )} |`;
+    body += `${formatTime(
+      sumMutation(r.mutations, (m) =>
+        m.broadcastedTime && m.confirmedTime
+          ? m.confirmedTime - m.broadcastedTime
+          : 0
+      )
+    )} |\n`;
+  });
+
+  body += "\n</details>\n\n";
+
   const { BOT_REPORT_FOLDER } = process.env;
 
   const slackCommentTemplate = `${String(
@@ -494,13 +600,13 @@ export async function bot({ currency, family, mutation }: Arg = {}) {
         "utf-8"
       ),
       fs.promises.writeFile(
-        path.join(BOT_REPORT_FOLDER, "before-app.json"),
-        makeAppJSON(allAccountsBefore),
+        path.join(BOT_REPORT_FOLDER, "app.json"),
+        makeAppJSON(allAccountsAfter),
         "utf-8"
       ),
       fs.promises.writeFile(
-        path.join(BOT_REPORT_FOLDER, "after-app.json"),
-        makeAppJSON(allAccountsAfter),
+        path.join(BOT_REPORT_FOLDER, "coin-apps.json"),
+        JSON.stringify(allAppPaths),
         "utf-8"
       ),
     ]);

package/src/bot/specs.ts

@@ -7,6 +7,9 @@ import { isAccountEmpty } from "../account";
 import type { DeviceAction, DeviceActionArg } from "./types";
 import { Account } from "@ledgerhq/types-live";
 import type { Transaction } from "../generated/types";
+import { botTest } from "./bot-test-context";
+
+export { botTest };
 
 const stepValueTransformDefault = (s) => s.trim();
 
@@ -89,11 +92,13 @@ export function deviceActionFlow<T extends Transaction>(
             currentStep.stepValueTransform || stepValueTransformDefault;
 
           if (!ignoreAssertionFailure) {
-            expect({
-              [stepTitle]: stepValueTransform(stepValue),
-            }).toMatchObject({
-              [stepTitle]: expectedValue(arg, acc).trim(),
-            });
+            botTest("deviceAction confirm step '" + stepTitle + "'", () =>
+              expect({
+                [stepTitle]: stepValueTransform(stepValue),
+              }).toMatchObject({
+                [stepTitle]: expectedValue(arg, acc).trim(),
+              })
+            );
           }
         }
 

package/src/bot/types.ts

@@ -66,7 +66,7 @@ export type MutationSpec<T extends Transaction> = {
     account: Account;
     bridge: AccountBridge<T>;
   }) => T | null | undefined;
-  // Express the device actions to do (buttons,..) and validate the device screen
+  // Express the device actions to do (buttons,..) and validate the device screen. overrides genericDeviceAction
   deviceAction?: DeviceAction<T, any>;
   // how much time to wait in maximum to reach the final state
   testTimeout?: number;
@@ -102,17 +102,21 @@ export type AppSpec<T extends Transaction> = {
   transactionCheck?: (arg: TransactionArg<T>) => void;
   // Implement a test that also runs on each mutation after the operation is applied to the account
   test?: (arg0: TransactionTestInput<T>) => void;
+  // Express the device actions to do (buttons,..) and validate the device screen
+  genericDeviceAction: DeviceAction<T, any>;
 };
 export type SpecReport<T extends Transaction> = {
   spec: AppSpec<T>;
-  scanTime?: number;
+  appPath?: string;
+  scanDuration?: number;
+  preloadDuration?: number;
   accountsBefore?: Account[];
   accountsAfter?: Account[];
   mutations?: MutationReport<T>[];
   fatalError?: Error;
 };
 export type MutationReport<T extends Transaction> = {
-  syncAllAccountsTime: number;
+  resyncAccountsDuration: number;
   spec: AppSpec<T>;
   appCandidate: AppCandidate;
   account?: Account;

package/src/countervalues/logic.integration.test.ts

@@ -3,11 +3,13 @@ import { initialState, loadCountervalues, calculate } from "./logic";
 import {
   getFiatCurrencyByTicker,
   getCryptoCurrencyById,
+  getTokenById,
   findCurrencyByTicker,
 } from "../currencies";
 import { getBTCValues } from "../countervalues/mock";
 import { Currency } from "@ledgerhq/types-cryptoassets";
 
+const ethereum = getCryptoCurrencyById("ethereum");
 const bitcoin = getCryptoCurrencyById("bitcoin");
 const usd = getFiatCurrencyByTicker("USD");
 const now = Date.now();
@@ -130,3 +132,51 @@ describe("extreme cases", () => {
     expect(currenciesWithCVs.length).toBeGreaterThan(0);
   });
 });
+
+describe("WETH rules", () => {
+  test("ethereum WETH have countervalues", async () => {
+    const weth = getTokenById("ethereum/erc20/weth");
+    const state = await loadCountervalues(initialState, {
+      // NB: inferTrackingPairForAccounts would infer eth->usd with the WETH module
+      // we set this explicitly just to confirm that asking weth->usd will make it work
+      trackingPairs: [
+        {
+          from: ethereum,
+          to: usd,
+          startDate: new Date(now - 10 * 24 * 60 * 60 * 1000),
+        },
+      ],
+      autofillGaps: true,
+      disableAutoRecoverErrors: true,
+    });
+    const value = calculate(state, {
+      disableRounding: true,
+      from: weth,
+      to: usd,
+      value: 1000000,
+    });
+    expect(value).toBeGreaterThan(0);
+  });
+
+  test("ethereum goerli WETH doesn't countervalues", async () => {
+    const weth = getTokenById("ethereum_goerli/erc20/wrapped_ether");
+    const state = await loadCountervalues(initialState, {
+      trackingPairs: [
+        {
+          from: ethereum,
+          to: usd,
+          startDate: new Date(now - 1 * 24 * 60 * 60 * 1000),
+        },
+      ],
+      autofillGaps: true,
+      disableAutoRecoverErrors: true,
+    });
+    const value = calculate(state, {
+      disableRounding: true,
+      from: weth,
+      to: usd,
+      value: 1000000,
+    });
+    expect(value).toBe(undefined);
+  });
+});

package/src/countervalues/modules/weth.ts

@@ -1,18 +1,15 @@
-import type { Module } from "./types";
+import type { Module, Pair } from "./types";
 import { getCryptoCurrencyById } from "../../currencies";
+
 const ETH = getCryptoCurrencyById("ethereum");
 
-const remap = (pair) => {
-  if (pair.from.ticker === "WETH")
-    return {
-      from: ETH,
-      to: pair.to,
-    };
-  if (pair.to.ticker === "WETH")
-    return {
-      from: pair.from,
-      to: ETH,
-    };
+const wethId = "ethereum/erc20/weth";
+
+const remap = (pair: Pair): Pair => {
+  if (pair.from.type === "TokenCurrency" && pair.from.id === wethId)
+    return { from: ETH, to: pair.to };
+  if (pair.to.type === "TokenCurrency" && pair.to.id === wethId)
+    return { from: pair.from, to: ETH };
   return pair;
 };