@ledgerhq/live-common 25.0.0-next.2 → 25.0.0-next.3

package/src/platform/PlatformAppProvider/helpers.ts

@@ -1,54 +1,6 @@
 import type { AppManifest } from "../types";
-import semver from "semver";
-export type FilterParams = {
-  branches?: string[];
-  platform?: string;
-  private?: boolean;
-  version?: string;
-};
 import { getEnv } from "../../env";
 
-function matchVersion(filterParams: FilterParams, manifest: AppManifest) {
-  return (
-    !filterParams.version ||
-    semver.satisfies(
-      semver.coerce(filterParams.version) || "",
-      manifest.apiVersion
-    )
-  );
-}
-
-function matchBranches(filterParams: FilterParams, manifest: AppManifest) {
-  return (
-    !filterParams.branches || filterParams.branches.includes(manifest.branch)
-  );
-}
-
-function matchPlatform(filterParams: FilterParams, manifest: AppManifest) {
-  return (
-    !filterParams.platform ||
-    manifest.platform === "all" ||
-    filterParams.platform === manifest.platform
-  );
-}
-
-function matchPrivate(filterParams: FilterParams, manifest: AppManifest) {
-  return filterParams.private === true || !(manifest.private === true);
-}
-
-export function filterPlatformApps(
-  appManifests: AppManifest[],
-  filterParams: FilterParams
-): AppManifest[] {
-  return appManifests.filter((appManifest: AppManifest) => {
-    return (
-      matchBranches(filterParams, appManifest) &&
-      matchPlatform(filterParams, appManifest) &&
-      matchPrivate(filterParams, appManifest) &&
-      matchVersion(filterParams, appManifest)
-    );
-  });
-}
 export function mergeManifestLists(
   list1: AppManifest[],
   list2: AppManifest[]

package/src/platform/converters.ts

@@ -1,13 +1,44 @@
 import byFamily from "../generated/platformAdapter";
-
-import type { Account, CryptoCurrency, Transaction } from "../types";
-import type {
+import { isTokenAccount, isSubAccount } from "../account";
+import { Account, AccountLike, Transaction } from "../types";
+import {
   PlatformAccount,
   PlatformCurrency,
   PlatformTransaction,
+  PlatformCurrencyType,
+  PlatformTokenStandard,
+  PlatformSupportedCurrency,
 } from "./types";
 
-export function accountToPlatformAccount(account: Account): PlatformAccount {
+export function accountToPlatformAccount(
+  account: AccountLike,
+  parentAccount?: Account
+): PlatformAccount {
+  if (isSubAccount(account)) {
+    if (!parentAccount) {
+      throw new Error("No 'parentAccount' account provided for token account");
+    }
+
+    return {
+      id: account.id,
+      balance: account.balance,
+      address: parentAccount.freshAddress,
+      blockHeight: parentAccount.blockHeight,
+      lastSyncDate: parentAccount.lastSyncDate,
+      ...(isTokenAccount(account)
+        ? {
+            name: `${parentAccount.name} (${account.token.ticker})`,
+            currency: account.token.id,
+            spendableBalance: account.spendableBalance,
+          }
+        : {
+            name: account.name,
+            currency: account.currency.id,
+            spendableBalance: parentAccount.spendableBalance,
+          }),
+    };
+  }
+
   return {
     id: account.id,
     name: account.name,
@@ -19,11 +50,34 @@ export function accountToPlatformAccount(account: Account): PlatformAccount {
     lastSyncDate: account.lastSyncDate,
   };
 }
+
 export function currencyToPlatformCurrency(
-  currency: CryptoCurrency
+  currency: PlatformSupportedCurrency
 ): PlatformCurrency {
+  if (currency.type === "TokenCurrency") {
+    if (currency.parentCurrency.family !== "ethereum") {
+      throw new Error("Only ERC20 tokens are supported");
+    }
+
+    return {
+      type: PlatformCurrencyType.TokenCurrency,
+      standard: PlatformTokenStandard.ERC20,
+      id: currency.id,
+      ticker: currency.ticker,
+      contract: currency.contractAddress,
+      name: currency.name,
+      parent: currency.parentCurrency.id,
+      color: currency.parentCurrency.color,
+      units: currency.units.map((unit) => ({
+        name: unit.name,
+        code: unit.code,
+        magnitude: unit.magnitude,
+      })),
+    };
+  }
+
   return {
-    type: currency.type,
+    type: PlatformCurrencyType.CryptoCurrency,
     id: currency.id,
     ticker: currency.ticker,
     name: currency.name,

package/src/platform/filters.ts

@@ -0,0 +1,102 @@
+import { makeRe } from "minimatch";
+import { PlatformAccount, PlatformCurrency, AppManifest } from "./types";
+import { isPlatformTokenCurrency } from "./helpers";
+import semver from "semver";
+
+export type FilterParams = {
+  branches?: string[];
+  platform?: string;
+  private?: boolean;
+  version?: string;
+};
+
+export type AccountFilters = {
+  currencies?: string[];
+};
+
+export function filterPlatformAccounts(
+  accounts: PlatformAccount[],
+  filters: AccountFilters
+): PlatformAccount[] {
+  const filterCurrencyRegexes = filters.currencies
+    ? filters.currencies.map((filter) => makeRe(filter))
+    : null;
+
+  return accounts.filter((account) => {
+    if (
+      filterCurrencyRegexes &&
+      !filterCurrencyRegexes.some((regex) => account.currency.match(regex))
+    ) {
+      return false;
+    }
+    return true;
+  });
+}
+
+export type CurrencyFilters = {
+  includeTokens?: boolean;
+  currencies?: string[];
+};
+
+export function filterPlatformCurrencies(
+  currencies: PlatformCurrency[],
+  filters: CurrencyFilters
+): PlatformCurrency[] {
+  const filterCurrencyRegexes = filters.currencies
+    ? filters.currencies.map((filter) => makeRe(filter))
+    : null;
+
+  return currencies.filter((currency) => {
+    if (!filters.includeTokens && isPlatformTokenCurrency(currency)) {
+      return false;
+    }
+
+    if (
+      filterCurrencyRegexes &&
+      !filterCurrencyRegexes.some((regex) => currency.id.match(regex))
+    ) {
+      return false;
+    }
+
+    return true;
+  });
+}
+
+function matchVersion(filterParams: FilterParams, manifest: AppManifest) {
+  return (
+    !filterParams.version ||
+    semver.satisfies(filterParams.version, manifest.apiVersion)
+  );
+}
+
+function matchBranches(filterParams: FilterParams, manifest: AppManifest) {
+  return (
+    !filterParams.branches || filterParams.branches.includes(manifest.branch)
+  );
+}
+
+function matchPlatform(filterParams: FilterParams, manifest: AppManifest) {
+  return (
+    !filterParams.platform ||
+    manifest.platform === "all" ||
+    filterParams.platform === manifest.platform
+  );
+}
+
+function matchPrivate(filterParams: FilterParams, manifest: AppManifest) {
+  return filterParams.private === true || !(manifest.private === true);
+}
+
+export function filterPlatformApps(
+  appManifests: AppManifest[],
+  filterParams: FilterParams
+): AppManifest[] {
+  return appManifests.filter((appManifest: AppManifest) => {
+    return (
+      matchBranches(filterParams, appManifest) &&
+      matchPlatform(filterParams, appManifest) &&
+      matchPrivate(filterParams, appManifest) &&
+      matchVersion(filterParams, appManifest)
+    );
+  });
+}

package/src/platform/helpers.ts

@@ -0,0 +1,33 @@
+import { isCryptoCurrency, isTokenCurrency } from "../currencies";
+import { Currency } from "../types";
+import {
+  PlatformCurrency,
+  PlatformSupportedCurrency,
+  PlatformERC20TokenCurrency,
+  PlatformCryptoCurrency,
+  PlatformCurrencyType,
+} from "./types";
+
+export function isPlatformSupportedCurrency(
+  currency: Currency
+): currency is PlatformSupportedCurrency {
+  return isCryptoCurrency(currency) || isTokenCurrency(currency);
+}
+
+export function isPlatformCryptoCurrency(
+  currency: PlatformCurrency
+): currency is PlatformCryptoCurrency {
+  return currency.type === PlatformCurrencyType.CryptoCurrency;
+}
+
+export function isPlatformTokenCurrency(
+  currency: PlatformCurrency
+): currency is PlatformERC20TokenCurrency {
+  return currency.type === PlatformCurrencyType.TokenCurrency;
+}
+
+export function isPlatformERC20TokenCurrency(
+  currency: PlatformCurrency
+): currency is PlatformERC20TokenCurrency {
+  return (currency as PlatformERC20TokenCurrency).standard === "ERC20";
+}

package/src/platform/logic.ts

@@ -1,23 +1,4 @@
-import semver from "semver";
-import type { AppManifest, AppPlatform, AppBranch } from "./types";
-import { getPlatformVersion } from "./version";
-
-export function translateContent(content: any, locale = "en") {
+export function translateContent(content: any, locale = "en"): string {
   if (!content || typeof content !== "object") return content;
   return content[locale] || content.en;
 }
-
-export function isSupported(manifest: AppManifest) {
-  return semver.satisfies(
-    semver.coerce(getPlatformVersion()) || "",
-    manifest.apiVersion
-  );
-}
-
-export function matchBranches(manifest: AppManifest, branches: AppBranch[]) {
-  return branches.indexOf(manifest.branch) > -1;
-}
-
-export function matchPlatform(manifest: AppManifest, platform: AppPlatform) {
-  return manifest.platform === "all" || manifest.platform === platform;
-}