@ledgerhq/live-common 27.0.0 → 27.1.0-next.1

package/src/__tests__/test-helpers/setup.ts

@@ -1,9 +1,6 @@
-import winston from "winston";
-import { listen } from "@ledgerhq/logs";
+import "./environment";
+
 import BigNumber from "bignumber.js";
-import { setSupportedCurrencies } from "../../currencies";
-import { setPlatformVersion } from "../../platform/version";
-import { EnvName, setEnvUnsafe } from "../../env";
 
 jest.setTimeout(360000);
 
@@ -17,89 +14,3 @@ expect.extend({
     return { message, pass };
   },
 });
-
-setPlatformVersion("1.1.0");
-
-setSupportedCurrencies([
-  "bitcoin",
-  "ethereum",
-  "bsc",
-  "polygon",
-  "elrond",
-  "ripple",
-  "bitcoin_cash",
-  "litecoin",
-  "dash",
-  "ethereum_classic",
-  "tezos",
-  "qtum",
-  "zcash",
-  "bitcoin_gold",
-  "stratis",
-  "dogecoin",
-  "digibyte",
-  "komodo",
-  "pivx",
-  "zencash",
-  "vertcoin",
-  "peercoin",
-  "viacoin",
-  "stakenet",
-  "stealthcoin",
-  "decred",
-  "tron",
-  "stellar",
-  "cosmos",
-  "algorand",
-  "polkadot",
-  "bitcoin_testnet",
-  "ethereum_ropsten",
-  "ethereum_goerli",
-  "cosmos_testnet",
-  "crypto_org_croeseid",
-  "crypto_org",
-  "filecoin",
-  "solana",
-  "celo",
-  "hedera",
-  "cardano",
-  "cardano_testnet",
-  "osmosis",
-  "filecoin",
-]);
-
-for (const k in process.env) setEnvUnsafe(k as EnvName, process.env[k]);
-
-const { VERBOSE, VERBOSE_FILE } = process.env;
-const logger = winston.createLogger({
-  level: "debug",
-  transports: [],
-});
-const { format } = winston;
-const { combine, timestamp, json } = format;
-const winstonFormat = combine(timestamp(), json());
-
-if (VERBOSE_FILE) {
-  logger.add(
-    new winston.transports.File({
-      format: winstonFormat,
-      filename: VERBOSE_FILE,
-      level: "debug",
-    })
-  );
-}
-
-logger.add(
-  new winston.transports.Console({
-    format: winstonFormat,
-    silent: !VERBOSE,
-  })
-);
-// eslint-disable-next-line no-unused-vars
-listen(({ type, message, ...rest }) => {
-  logger.log("debug", {
-    message: type + (message ? ": " + message : ""),
-    // $FlowFixMe
-    ...rest,
-  });
-});

package/src/account/serialization.ts

@@ -39,6 +39,10 @@ import {
   fromSolanaResourcesRaw,
 } from "../families/solana/serialization";
 
+import {
+  toCeloResourcesRaw,
+  fromCeloResourcesRaw,
+} from "../families/celo/serialization";
 import {
   getCryptoCurrencyById,
   getTokenById,
@@ -92,6 +96,7 @@ import {
 } from "../families/crypto_org/types";
 import { SolanaAccount, SolanaAccountRaw } from "../families/solana/types";
 import { TezosAccount, TezosAccountRaw } from "../families/tezos/types";
+import { CeloAccount, CeloAccountRaw } from "../families/celo/types";
 
 export { toCosmosResourcesRaw, fromCosmosResourcesRaw };
 export { toAlgorandResourcesRaw, fromAlgorandResourcesRaw };
@@ -102,6 +107,7 @@ export { toElrondResourcesRaw, fromElrondResourcesRaw };
 export { toCryptoOrgResourcesRaw, fromCryptoOrgResourcesRaw };
 export { toCardanoResourceRaw, fromCardanoResourceRaw };
 export { toSolanaResourcesRaw, fromSolanaResourcesRaw };
+export { toCeloResourcesRaw, fromCeloResourcesRaw };
 
 export function toBalanceHistoryRaw(b: BalanceHistory): BalanceHistoryRaw {
   return b.map(({ date, value }) => [date.toISOString(), value.toString()]);
@@ -779,10 +785,9 @@ export function fromAccountRaw(rawAccount: AccountRaw): Account {
   switch (res.currency.family) {
     case "tron": {
       const tronResourcesRaw = (rawAccount as TronAccountRaw).tronResources;
-      if (tronResourcesRaw) {
+      if (tronResourcesRaw)
         (res as TronAccount).tronResources =
           fromTronResourcesRaw(tronResourcesRaw);
-      }
       break;
     }
     case "osmosis":
@@ -794,20 +799,19 @@ export function fromAccountRaw(rawAccount: AccountRaw): Account {
           fromCosmosResourcesRaw(cosmosResourcesRaw);
       break;
     }
-    case "tezos":
-      {
-        const tezosResourcesRaw = (rawAccount as TezosAccountRaw)
-          .tezosResources;
-        if (tezosResourcesRaw)
-          (res as TezosAccount).tezosResources =
-            fromTezosResourcesRaw(tezosResourcesRaw);
-      }
+    case "tezos": {
+      const tezosResourcesRaw = (rawAccount as TezosAccountRaw).tezosResources;
+      if (tezosResourcesRaw)
+        (res as TezosAccount).tezosResources =
+          fromTezosResourcesRaw(tezosResourcesRaw);
       break;
+    }
     case "bitcoin": {
       const bitcoinResourcesRaw = (rawAccount as BitcoinAccountRaw)
         .bitcoinResources;
-      (res as BitcoinAccount).bitcoinResources =
-        fromBitcoinResourcesRaw(bitcoinResourcesRaw);
+      if (bitcoinResourcesRaw)
+        (res as BitcoinAccount).bitcoinResources =
+          fromBitcoinResourcesRaw(bitcoinResourcesRaw);
       break;
     }
     case "algorand": {
@@ -818,20 +822,17 @@ export function fromAccountRaw(rawAccount: AccountRaw): Account {
           fromAlgorandResourcesRaw(algoResourcesRaw);
       break;
     }
-    case "polkadot":
-      {
-        const polkadotResourcesRaw = (rawAccount as PolkadotAccountRaw)
-          .polkadotResources;
-
-        if (polkadotResourcesRaw)
-          (res as PolkadotAccount).polkadotResources =
-            fromPolkadotResourcesRaw(polkadotResourcesRaw);
-      }
+    case "polkadot": {
+      const polkadotResourcesRaw = (rawAccount as PolkadotAccountRaw)
+        .polkadotResources;
+      if (polkadotResourcesRaw)
+        (res as PolkadotAccount).polkadotResources =
+          fromPolkadotResourcesRaw(polkadotResourcesRaw);
       break;
+    }
     case "elrond": {
       const elrondResourcesRaw = (rawAccount as ElrondAccountRaw)
         .elrondResources;
-
       if (elrondResourcesRaw)
         (res as ElrondAccount).elrondResources =
           fromElrondResourcesRaw(elrondResourcesRaw);
@@ -861,6 +862,13 @@ export function fromAccountRaw(rawAccount: AccountRaw): Account {
           fromCryptoOrgResourcesRaw(cryptoOrgResourcesRaw);
       break;
     }
+    case "celo": {
+      const celoResourcesRaw = (rawAccount as CeloAccountRaw).celoResources;
+      if (celoResourcesRaw)
+        (res as CeloAccount).celoResources =
+          fromCeloResourcesRaw(celoResourcesRaw);
+      break;
+    }
   }
 
   if (swapHistory) {
@@ -942,61 +950,112 @@ export function toAccountRaw(account: Account): AccountRaw {
   }
 
   switch (account.currency.family) {
-    case "tron":
-      (res as TronAccountRaw).tronResources = toTronResourcesRaw(
-        (account as TronAccount).tronResources
-      );
+    case "tron": {
+      const tronAccount = account as TronAccount;
+      if (tronAccount.tronResources) {
+        (res as TronAccountRaw).tronResources = toTronResourcesRaw(
+          tronAccount.tronResources
+        );
+      }
       break;
-    case "cosmos":
-      (res as CosmosAccountRaw).cosmosResources = toCosmosResourcesRaw(
-        (account as CosmosAccount).cosmosResources
-      );
+    }
+    case "osmosis": {
+      const cosmosAccount = account as CosmosAccount;
+      if (cosmosAccount.cosmosResources) {
+        (res as CosmosAccountRaw).cosmosResources = toCosmosResourcesRaw(
+          cosmosAccount.cosmosResources
+        );
+      }
       break;
-    case "osmosis":
-      (res as CosmosAccountRaw).cosmosResources = toCosmosResourcesRaw(
-        (account as CosmosAccount).cosmosResources
-      );
+    }
+    case "cosmos": {
+      const cosmosAccount = account as CosmosAccount;
+      if (cosmosAccount.cosmosResources) {
+        (res as CosmosAccountRaw).cosmosResources = toCosmosResourcesRaw(
+          cosmosAccount.cosmosResources
+        );
+      }
       break;
-    case "tezos":
-      (res as TezosAccountRaw).tezosResources = toTezosResourcesRaw(
-        (account as TezosAccount).tezosResources
-      );
+    }
+    case "tezos": {
+      const tezosAccount = account as TezosAccount;
+      if (tezosAccount.tezosResources) {
+        (res as TezosAccountRaw).tezosResources = toTezosResourcesRaw(
+          tezosAccount.tezosResources
+        );
+      }
       break;
-    case "bitcoin":
-      (res as BitcoinAccountRaw).bitcoinResources = toBitcoinResourcesRaw(
-        (account as BitcoinAccount).bitcoinResources
-      );
+    }
+    case "bitcoin": {
+      const bitcoinAccount = account as BitcoinAccount;
+      if (bitcoinAccount.bitcoinResources) {
+        (res as BitcoinAccountRaw).bitcoinResources = toBitcoinResourcesRaw(
+          bitcoinAccount.bitcoinResources
+        );
+      }
       break;
-    case "algorand":
-      (res as AlgorandAccountRaw).algorandResources = toAlgorandResourcesRaw(
-        (account as AlgorandAccount).algorandResources
-      );
+    }
+    case "algorand": {
+      const algorandAccount = account as AlgorandAccount;
+      if (algorandAccount.algorandResources) {
+        (res as AlgorandAccountRaw).algorandResources = toAlgorandResourcesRaw(
+          algorandAccount.algorandResources
+        );
+      }
       break;
-    case "polkadot":
-      (res as PolkadotAccountRaw).polkadotResources = toPolkadotResourcesRaw(
-        (account as PolkadotAccount).polkadotResources
-      );
+    }
+    case "polkadot": {
+      const polkadotAccount = account as PolkadotAccount;
+      if (polkadotAccount.polkadotResources) {
+        (res as PolkadotAccountRaw).polkadotResources = toPolkadotResourcesRaw(
+          polkadotAccount.polkadotResources
+        );
+      }
       break;
-    case "elrond":
-      (res as ElrondAccountRaw).elrondResources = toElrondResourcesRaw(
-        (account as ElrondAccount).elrondResources
-      );
+    }
+    case "elrond": {
+      const elrondAccount = account as ElrondAccount;
+      if (elrondAccount.elrondResources) {
+        (res as ElrondAccountRaw).elrondResources = toElrondResourcesRaw(
+          elrondAccount.elrondResources
+        );
+      }
       break;
-    case "cardano":
-      (res as CardanoAccountRaw).cardanoResources = toCardanoResourceRaw(
-        (account as CardanoAccount).cardanoResources
-      );
+    }
+    case "cardano": {
+      const cardanoAccount = account as CardanoAccount;
+      if (cardanoAccount.cardanoResources) {
+        (res as CardanoAccountRaw).cardanoResources = toCardanoResourceRaw(
+          cardanoAccount.cardanoResources
+        );
+      }
       break;
-    case "solana":
-      (res as SolanaAccountRaw).solanaResources = toSolanaResourcesRaw(
-        (account as SolanaAccount).solanaResources
-      );
+    }
+    case "solana": {
+      const solanaAccount = account as SolanaAccount;
+      if (solanaAccount.solanaResources) {
+        (res as SolanaAccountRaw).solanaResources = toSolanaResourcesRaw(
+          solanaAccount.solanaResources
+        );
+      }
       break;
-    case "crypto_org":
-      (res as CryptoOrgAccountRaw).cryptoOrgResources = toCryptoOrgResourcesRaw(
-        (account as CryptoOrgAccount).cryptoOrgResources
-      );
+    }
+    case "crypto_org": {
+      const crytpoOrgAccount = account as CryptoOrgAccount;
+      if (crytpoOrgAccount.cryptoOrgResources) {
+        (res as CryptoOrgAccountRaw).cryptoOrgResources =
+          toCryptoOrgResourcesRaw(crytpoOrgAccount.cryptoOrgResources);
+      }
       break;
+    }
+    case "celo": {
+      const celoAccount = account as CeloAccount;
+      if (celoAccount.celoResources)
+        (res as CeloAccountRaw).celoResources = toCeloResourcesRaw(
+          celoAccount.celoResources
+        );
+      break;
+    }
   }
 
   if (swapHistory) {

package/src/apps/support.ts

@@ -35,6 +35,7 @@ const appVersionsRequired = {
   Elrond: ">= 1.0.11",
   Ethereum: ">= 1.9.17",
   Solana: ">= 1.2.0",
+  Celo: ">= 1.1.8",
   "Cardano ADA": ">= 4.1.0",
 };
 export function mustUpgrade(

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/cli.ts

@@ -0,0 +1,18 @@
+import "../__tests__/test-helpers/environment";
+import { bot } from ".";
+
+const { BOT_FILTER_CURRENCY, BOT_FILTER_FAMILY } = process.env;
+const arg: {
+  currency?: string;
+  family?: string;
+} = {};
+
+if (BOT_FILTER_CURRENCY) {
+  arg.currency = BOT_FILTER_CURRENCY;
+}
+
+if (BOT_FILTER_FAMILY) {
+  arg.family = BOT_FILTER_FAMILY;
+}
+
+bot(arg);