@ledgerhq/live-common 25.1.0 → 25.2.0-next.0

package/src/platform/tracking.test.ts

@@ -0,0 +1,157 @@
+import trackingWrapper from "./tracking";
+import { AppManifest } from "./types";
+
+describe("trackingWrapper", () => {
+  const methodToMessage = [
+    {
+      method: "platformLoad",
+      message: "Platform Load",
+    },
+    {
+      method: "platformReload",
+      message: "Platform Reload",
+    },
+    {
+      method: "platformLoadFail",
+      message: "Platform Load Fail",
+    },
+    {
+      method: "platformLoadSuccess",
+      message: "Platform Load Success",
+    },
+    {
+      method: "platformSignTransactionRequested",
+      message: "Platform SignTransaction",
+    },
+    {
+      method: "platformSignTransactionFail",
+      message: "Platform SignTransaction Fail",
+    },
+    {
+      method: "platformSignTransactionSuccess",
+      message: "Platform SignTransaction Success",
+    },
+    {
+      method: "platformRequestAccountRequested",
+      message: "Platform RequestAccount",
+    },
+    {
+      method: "platformRequestAccountFail",
+      message: "Platform RequestAccount Fail",
+    },
+    {
+      method: "platformRequestAccountSuccess",
+      message: "Platform RequestAccount Success",
+    },
+    {
+      method: "platformReceiveRequested",
+      message: "Platform Receive",
+    },
+    {
+      method: "platformReceiveFail",
+      message: "Platform Receive Fail",
+    },
+    {
+      method: "platformReceiveSuccess",
+      message: "Platform Receive Success",
+    },
+    {
+      method: "platformBroadcastFail",
+      message: "Platform Broadcast Fail",
+    },
+    {
+      method: "platformBroadcastSuccess",
+      message: "Platform Broadcast Success",
+    },
+    {
+      method: "platformBroadcastOperationDetailsClick",
+      message: "Platform Broadcast OpD Clicked",
+    },
+    {
+      method: "platformStartExchangeRequested",
+      message: "Platform start Exchange Nonce request",
+    },
+    {
+      method: "platformStartExchangeSuccess",
+      message: "Platform start Exchange Nonce success",
+    },
+    {
+      method: "platformStartExchangeFail",
+      message: "Platform start Exchange Nonce fail",
+    },
+    {
+      method: "platformCompleteExchangeRequested",
+      message: "Platform complete Exchange requested",
+    },
+    {
+      method: "platformCompleteExchangeSuccess",
+      message: "Platform complete Exchange success",
+    },
+    {
+      method: "platformCompleteExchangeFail",
+      message: "Platform complete Exchange Nonce fail",
+    },
+    {
+      method: "platformSignMessageRequested",
+      message: "Platform sign message requested",
+    },
+    {
+      method: "platformSignMessageSuccess",
+      message: "Platform sign message success",
+    },
+    {
+      method: "platformSignMessageFail",
+      message: "Platform sign message fail",
+    },
+    {
+      method: "platformSignMessageUserRefused",
+      message: "Platform sign message user refused",
+    },
+  ];
+
+  for (const { method, message } of methodToMessage) {
+    it(`calls once inner trackPlatform function ${method} with event named: ${message}`, () => {
+      // Given
+      const appManifest = appManifestFixture();
+      const mockedTrack = jest.fn();
+
+      // When
+      trackingWrapper(mockedTrack)[method](appManifest);
+
+      // Then
+      expect(mockedTrack).toHaveBeenCalledTimes(1);
+      expect(mockedTrack).toHaveBeenCalledWith(
+        message,
+        {
+          platform: appManifest.name,
+        },
+        null
+      );
+    });
+  }
+});
+
+function appManifestFixture(name = "live-app"): AppManifest {
+  return {
+    id: "12",
+    name,
+    url: "https://www.ledger.fr",
+    homepageUrl: "https://www.ledger.fr",
+    platform: "all",
+    apiVersion: "1.0.0",
+    manifestVersion: "1.0.0",
+    branch: "debug",
+    categories: ["test"],
+    currencies: "*",
+    content: {
+      shortDescription: {
+        en: "test",
+      },
+      description: {
+        en: "test",
+      },
+    },
+    permissions: [],
+    domains: [],
+  };
+}

package/src/platform/tracking.ts

@@ -0,0 +1,164 @@
+import type { AppManifest } from "./types";
+
+/**
+ * This signature is to be compatible with track method of `segment.js` file in LLM and LLD
+ * `track(event: string, properties: ?Object, mandatory: ?boolean)` in jsflow
+ * {@link @ledger-desktop/renderer/analytics/segment#track}
+ */
+type TrackPlatform = (
+  event: string,
+  properties: Record<string, any> | null,
+  mandatory: boolean | null
+) => void;
+
+type TrackFunction = (manifest: AppManifest) => void;
+
+/**
+ * Obtain Event data from Platform App manifest
+ *
+ * @param {AppManifest} manifest
+ * @returns Object - event data
+ */
+function getEventData(manifest: AppManifest) {
+  return { platform: manifest.name };
+}
+
+/**
+ * Wrap call to underlying trackCall function.
+ * @param trackCall
+ * @returns a dictionary of event to trigger.
+ */
+export default function trackingWrapper(
+  trackCall: TrackPlatform
+): Record<string, TrackFunction> {
+  const track = (event: string, properties: Record<string, any> | null) =>
+    trackCall(event, properties, null);
+
+  return {
+    // Failed to load the iframe
+    platformLoad: (manifest: AppManifest) => {
+      track("Platform Load", getEventData(manifest));
+    },
+
+    // Failed to load the iframe
+    platformReload: (manifest: AppManifest) => {
+      track("Platform Reload", getEventData(manifest));
+    },
+
+    // Failed to load the iframe
+    platformLoadFail: (manifest: AppManifest) => {
+      // TODO: handle iframe failed
+      track("Platform Load Fail", getEventData(manifest));
+    },
+
+    // Successfully loaded the iframe
+    platformLoadSuccess: (manifest: AppManifest) => {
+      track("Platform Load Success", getEventData(manifest));
+    },
+
+    // Sign transaction modal open
+    platformSignTransactionRequested: (manifest: AppManifest) => {
+      track("Platform SignTransaction", getEventData(manifest));
+    },
+
+    // Failed to sign transaction (cancel or error)
+    platformSignTransactionFail: (manifest: AppManifest) => {
+      track("Platform SignTransaction Fail", getEventData(manifest));
+    },
+
+    // Successfully signed transaction
+    platformSignTransactionSuccess: (manifest: AppManifest) => {
+      track("Platform SignTransaction Success", getEventData(manifest));
+    },
+
+    // Select account modal open
+    platformRequestAccountRequested: (manifest: AppManifest) => {
+      track("Platform RequestAccount", getEventData(manifest));
+    },
+
+    // Failed to select account (cancel or error)
+    platformRequestAccountFail: (manifest: AppManifest) => {
+      track("Platform RequestAccount Fail", getEventData(manifest));
+    },
+
+    // The user successfully selected an account
+    platformRequestAccountSuccess: (manifest: AppManifest) => {
+      track("Platform RequestAccount Success", getEventData(manifest));
+    },
+
+    // Select account modal open
+    platformReceiveRequested: (manifest: AppManifest) => {
+      track("Platform Receive", getEventData(manifest));
+    },
+
+    // Failed to select account (cancel or error)
+    platformReceiveFail: (manifest: AppManifest) => {
+      track("Platform Receive Fail", getEventData(manifest));
+    },
+
+    // The user successfully selected an account
+    platformReceiveSuccess: (manifest: AppManifest) => {
+      track("Platform Receive Success", getEventData(manifest));
+    },
+
+    // Failed to broadcast a signed transaction
+    platformBroadcastFail: (manifest: AppManifest) => {
+      track("Platform Broadcast Fail", getEventData(manifest));
+    },
+
+    // Successfully broadcast a signed transaction
+    platformBroadcastSuccess: (manifest: AppManifest) => {
+      track("Platform Broadcast Success", getEventData(manifest));
+    },
+
+    // Successfully broadcast a signed transaction
+    platformBroadcastOperationDetailsClick: (manifest: AppManifest) => {
+      track("Platform Broadcast OpD Clicked", getEventData(manifest));
+    },
+
+    // Generate Exchange nonce modal open
+    platformStartExchangeRequested: (manifest: AppManifest) => {
+      track("Platform start Exchange Nonce request", getEventData(manifest));
+    },
+
+    // Successfully generated an Exchange app nonce
+    platformStartExchangeSuccess: (manifest: AppManifest) => {
+      track("Platform start Exchange Nonce success", getEventData(manifest));
+    },
+
+    // Failed to generate an Exchange app nonce
+    platformStartExchangeFail: (manifest: AppManifest) => {
+      track("Platform start Exchange Nonce fail", getEventData(manifest));
+    },
+
+    platformCompleteExchangeRequested: (manifest: AppManifest) => {
+      track("Platform complete Exchange requested", getEventData(manifest));
+    },
+
+    // Successfully completed an Exchange
+    platformCompleteExchangeSuccess: (manifest: AppManifest) => {
+      track("Platform complete Exchange success", getEventData(manifest));
+    },
+
+    // Failed to complete an Exchange
+    platformCompleteExchangeFail: (manifest: AppManifest) => {
+      track("Platform complete Exchange Nonce fail", getEventData(manifest));
+    },
+
+    platformSignMessageRequested: (manifest: AppManifest) => {
+      track("Platform sign message requested", getEventData(manifest));
+    },
+
+    platformSignMessageSuccess: (manifest: AppManifest) => {
+      track("Platform sign message success", getEventData(manifest));
+    },
+
+    platformSignMessageFail: (manifest: AppManifest) => {
+      track("Platform sign message fail", getEventData(manifest));
+    },
+
+    platformSignMessageUserRefused: (manifest: AppManifest) => {
+      track("Platform sign message user refused", getEventData(manifest));
+    },
+  };
+}

package/src/platform/types.ts

@@ -1,4 +1,8 @@
-import { SignedOperation, CryptoCurrency, TokenCurrency } from "../types";
+import type { SignedOperation } from "@ledgerhq/types-live";
+import type {
+  CryptoCurrency,
+  TokenCurrency,
+} from "@ledgerhq/types-cryptoassets";
 import { AccountFilters, CurrencyFilters } from "./filters";
 import {
   Account as PlatformAccount,

package/src/platform/version.test.ts

@@ -1,5 +1,5 @@
 import "../__tests__/test-helpers/setup";
 import { getPlatformVersion } from "./version";
 test("version is defined by setup", () => {
-  expect(getPlatformVersion()).toBe("1.0.0");
+  expect(getPlatformVersion()).toBe("1.1.0");
 });

package/src/portfolio/v2/index.ts

@@ -1,10 +1,3 @@
-import type {
-  AccountLike,
-  Account,
-  Currency,
-  CryptoCurrency,
-  TokenCurrency,
-} from "../../types";
 import type { CounterValuesState } from "../../countervalues/types";
 import { calculate, calculateMany } from "../../countervalues/logic";
 import {
@@ -13,7 +6,17 @@ import {
   getAccountHistoryBalances,
 } from "../../account";
 import { getEnv } from "../../env";
+import { getPortfolioRangeConfig, getDates } from "./range";
+
+export const defaultAssetsDistribution = {
+  minShowFirst: 1,
+  maxShowFirst: 6,
+  showFirstThreshold: 0.95,
+};
+export type AssetsDistributionOpts = typeof defaultAssetsDistribution;
 import type {
+  Account,
+  AccountLike,
   BalanceHistory,
   PortfolioRange,
   BalanceHistoryWithCountervalue,
@@ -22,15 +25,12 @@ import type {
   CurrencyPortfolio,
   AssetsDistribution,
   ValueChange,
-} from "./types";
-import { getPortfolioRangeConfig, getDates } from "./range";
-
-export const defaultAssetsDistribution = {
-  minShowFirst: 1,
-  maxShowFirst: 6,
-  showFirstThreshold: 0.95,
-};
-export type AssetsDistributionOpts = typeof defaultAssetsDistribution;
+} from "@ledgerhq/types-live";
+import type {
+  CryptoCurrency,
+  Currency,
+  TokenCurrency,
+} from "@ledgerhq/types-cryptoassets";
 
 export function getPortfolioCount(
   accounts: AccountLike[],

package/src/portfolio/v2/range.ts

@@ -1,4 +1,7 @@
-import type { PortfolioRangeConfig, PortfolioRange } from "./types";
+import type {
+  PortfolioRangeConfig,
+  PortfolioRange,
+} from "@ledgerhq/types-live";
 
 export const hourIncrement = 60 * 60 * 1000;
 export const dayIncrement = 24 * hourIncrement;

package/src/portfolio/v2/react.ts

@@ -1,10 +1,13 @@
 import type {
-  Account,
-  AccountLike,
-  Currency,
   CryptoCurrency,
+  Currency,
   TokenCurrency,
-} from "../../types";
+} from "@ledgerhq/types-cryptoassets";
+import type {
+  Account,
+  AccountLike,
+  PortfolioRange,
+} from "@ledgerhq/types-live";
 import { getAccountCurrency, flattenAccounts } from "../../account";
 import { useCountervaluesState } from "../../countervalues/react";
 import {
@@ -14,7 +17,6 @@ import {
   getAssetsDistribution,
   getPortfolioCount,
 } from "./";
-import type { PortfolioRange } from "./types";
 export function useBalanceHistoryWithCountervalue({
   account,
   range,

package/src/react.ts

@@ -1,6 +1,9 @@
 import * as icons from "./data/icons/react";
 import * as flags from "./data/flags/react";
-import type { CryptoCurrency, TokenCurrency } from "./types";
+import type {
+  CryptoCurrency,
+  TokenCurrency,
+} from "@ledgerhq/types-cryptoassets";
 type Icon = React.ComponentType<{
   size: number;
   color?: string;

package/src/reactNative.ts

@@ -4,7 +4,10 @@ import "@polkadot/wasm-crypto/initOnlyAsm";
 
 import * as icons from "./data/icons/reactNative";
 import * as flags from "./data/flags/reactNative";
-import type { CryptoCurrency, TokenCurrency } from "./types";
+import type {
+  CryptoCurrency,
+  TokenCurrency,
+} from "@ledgerhq/types-cryptoassets";
 
 type Icon = React.ComponentType<{
   size: number;