@ledgerhq/live-common 34.51.0-nightly.1 → 34.51.0-nightly.3

package/src/families/polkadot/config.ts

@@ -12,6 +12,9 @@ export const polkadotConfig: Record<string, ConfigInfo> = {
         url: getEnv("API_POLKADOT_SIDECAR"),
         credentials: getEnv("API_POLKADOT_SIDECAR_CREDENTIALS"),
       },
+      indexer: {
+        url: getEnv("API_POLKADOT_INDEXER"),
+      },
       node: {
         url: getEnv("API_POLKADOT_NODE"),
       },
@@ -20,9 +23,90 @@ export const polkadotConfig: Record<string, ConfigInfo> = {
       },
       metadataShortener: {
         url: "https://polkadot-metadata-shortener.api.live.ledger.com/transaction/metadata",
+        id: "dot",
       },
       metadataHash: {
         url: "https://polkadot-metadata-shortener.api.live.ledger.com/node/metadata/hash",
+        id: "dot",
+      },
+    },
+  },
+  config_currency_assethub_polkadot: {
+    type: "object",
+    default: {
+      status: {
+        type: "active",
+      },
+      sidecar: {
+        url: "https://polkadot-asset-hub-sidecar.coin.ledger.com",
+      },
+      node: {
+        url: "https://polkadot-asset-hub-fullnodes.api.live.ledger.com",
+      },
+      staking: {
+        electionStatusThreshold: getEnv("POLKADOT_ELECTION_STATUS_THRESHOLD"),
+      },
+      indexer: {
+        url: "https://explorers.api.live.ledger.com/blockchain/dot_asset_hub",
+      },
+      metadataShortener: {
+        url: "https://polkadot-metadata-shortener.api.live.ledger.com/transaction/metadata",
+        id: "dot-hub",
+      },
+      metadataHash: {
+        url: "https://polkadot-metadata-shortener.api.live.ledger.com/node/metadata/hash",
+        id: "dot-hub",
+      },
+      hasBeenMigrated: false,
+    },
+  },
+  config_currency_westend: {
+    type: "object",
+    default: {
+      status: {
+        type: "active",
+      },
+      sidecar: {
+        url: "https://polkadot-westend-sidecar.coin.ledger.com/rc",
+      },
+      node: {
+        url: "https://polkadot-westend-fullnodes.api.live.ledger.com",
+      },
+      indexer: {
+        url: "https://explorers.api.live.ledger.com/blockchain/dot_westend",
+      },
+      metadataShortener: {
+        url: "https://polkadot-westend-metadata-shortener.api.live.ledger.com/transaction/metadata",
+        id: "dot-hub",
+      },
+      metadataHash: {
+        url: "https://polkadot-westend-metadata-shortener.api.live.ledger.com/node/metadata/hash",
+        id: "dot-hub",
+      },
+    },
+  },
+  config_currency_assethub_westend: {
+    type: "object",
+    default: {
+      status: {
+        type: "active",
+      },
+      sidecar: {
+        url: "https://polkadot-westend-sidecar.coin.ledger.com",
+      },
+      node: {
+        url: "https://polkadot-westend-asset-hub-fullnodes.api.live.ledger.com",
+      },
+      indexer: {
+        url: "https://explorers.api.live.ledger.com/blockchain/dot_asset_hub_westend",
+      },
+      metadataShortener: {
+        url: "https://polkadot-westend-metadata-shortener.api.live.ledger.com/transaction/metadata",
+        id: "dot-hub",
+      },
+      metadataHash: {
+        url: "https://polkadot-westend-metadata-shortener.api.live.ledger.com/node/metadata/hash",
+        id: "dot-hub",
       },
     },
   },

package/src/families/polkadot/setup.ts

@@ -15,15 +15,17 @@ import makeCliTools, { type CliTools } from "@ledgerhq/coin-polkadot/test/cli";
 import { CreateSigner, createResolver, executeWithSigner } from "../../bridge/setup";
 import { Resolver } from "../../hw/getAddress/types";
 import { getCurrencyConfiguration } from "../../config";
-import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 const createSigner: CreateSigner<Polkadot> = (transport: Transport) => {
   return new Polkadot(transport);
 };
 
-const polkadot = getCryptoCurrencyById("polkadot");
-const getCurrencyConfig = (): PolkadotCoinConfig => {
-  return getCurrencyConfiguration(polkadot);
+const getCurrencyConfig = (currency?: CryptoCurrency): PolkadotCoinConfig => {
+  if (!currency) {
+    throw new Error("No currency provided");
+  }
+  return getCurrencyConfiguration<PolkadotCoinConfig>(currency);
 };
 
 const bridge: Bridge<Transaction, PolkadotAccount, TransactionStatus> = createBridges(

package/src/families/stellar/bridge/mock.ts

@@ -19,6 +19,7 @@ import { formatCurrencyUnit } from "../../../currencies";
 import {
   scanAccounts,
   signOperation,
+  signRawOperation,
   broadcast,
   sync,
   isInvalidRecipient,
@@ -217,6 +218,7 @@ const accountBridge: AccountBridge<Transaction> = {
   sync,
   receive,
   signOperation,
+  signRawOperation,
   broadcast,
   estimateMaxSpendable,
   getSerializedAddressParameters,

package/src/families/tezos/bridge/mock.ts

@@ -18,6 +18,7 @@ import { getMainAccount } from "../../../account";
 import {
   scanAccounts,
   signOperation,
+  signRawOperation,
   broadcast,
   sync,
   isInvalidRecipient,
@@ -205,6 +206,7 @@ const accountBridge: AccountBridge<Transaction> = {
   sync,
   receive,
   signOperation,
+  signRawOperation,
   broadcast,
   getSerializedAddressParameters,
 };

package/src/families/tron/bridge/mock.ts

@@ -6,6 +6,7 @@ import { getSerializedAddressParameters } from "@ledgerhq/coin-framework/bridge/
 import {
   scanAccounts,
   signOperation,
+  signRawOperation,
   broadcast,
   sync,
   isInvalidRecipient,
@@ -114,6 +115,7 @@ const accountBridge: AccountBridge<Transaction> = {
   sync,
   receive,
   signOperation,
+  signRawOperation,
   broadcast,
   getSerializedAddressParameters,
 };

package/src/families/xrp/bridge/mock.ts

@@ -20,6 +20,7 @@ import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
 import {
   scanAccounts,
   signOperation,
+  signRawOperation,
   broadcast,
   sync,
   isInvalidRecipient,
@@ -143,6 +144,7 @@ const accountBridge: AccountBridge<Transaction> = {
   sync,
   receive,
   signOperation,
+  signRawOperation,
   broadcast,
   getSerializedAddressParameters,
 };

package/src/featureFlags/defaultFeatures.ts

@@ -99,6 +99,9 @@ export const CURRENCY_DEFAULT_FEATURES = {
   currencyKaspa: DEFAULT_FEATURE,
   currencyEthereumHoodi: DEFAULT_FEATURE,
   currencyCore: DEFAULT_FEATURE,
+  currencyWestend: DEFAULT_FEATURE,
+  currencyAssetHubPolkadot: DEFAULT_FEATURE,
+  currencyAssetHubWestend: DEFAULT_FEATURE,
 };
 
 /**
@@ -106,6 +109,7 @@ export const CURRENCY_DEFAULT_FEATURES = {
  */
 export const DEFAULT_FEATURES: Features = {
   ...CURRENCY_DEFAULT_FEATURES,
+  welcomeScreenVideoCarousel: DEFAULT_FEATURE,
   portfolioExchangeBanner: DEFAULT_FEATURE,
   postOnboardingAssetsTransfer: DEFAULT_FEATURE,
   counterValue: DEFAULT_FEATURE,
@@ -113,7 +117,6 @@ export const DEFAULT_FEATURES: Features = {
   ptxServiceCtaExchangeDrawer: DEFAULT_FEATURE,
   ptxServiceCtaScreens: DEFAULT_FEATURE,
   ptxSwapReceiveTRC20WithoutTrx: DEFAULT_FEATURE,
-  ptxSwapDetailedView: DEFAULT_FEATURE,
   disableNftLedgerMarket: DEFAULT_FEATURE,
   disableNftRaribleOpensea: DEFAULT_FEATURE,
   disableNftSend: DEFAULT_FEATURE,
@@ -127,6 +130,12 @@ export const DEFAULT_FEATURES: Features = {
   brazePushNotifications: initFeature(),
   stakeAccountBanner: initFeature(),
 
+  ptxSwapDetailedView: initFeature({
+    enabled: false,
+    params: {
+      variant: ABTestingVariants.variantA,
+    },
+  }),
   buyDeviceFromLive: {
     enabled: false,
     params: { debug: false, url: null },
@@ -430,6 +439,11 @@ export const DEFAULT_FEATURES: Features = {
     },
   },
 
+  ptxEarnDrawerApy: {
+    enabled: false,
+    params: {},
+  },
+
   ptxSwapLiveAppMobile: {
     enabled: false,
     params: {

package/src/hooks/useManifestWithSessionId.test.ts

@@ -0,0 +1,105 @@
+/**
+ * @jest-environment jsdom
+ */
+import { renderHook, waitFor } from "@testing-library/react";
+import { useManifestWithSessionId } from "./useManifestWithSessionId";
+import { LiveAppManifest } from "../platform/types";
+
+const mockFetch = jest.fn();
+// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+global.fetch = mockFetch as any;
+
+// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+const baseManifest = {
+  id: "test-app",
+  name: "Test App",
+  url: "https://example.com",
+} as LiveAppManifest;
+
+describe("useManifestWithSessionId", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns null manifest during loading", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ providerSessionId: "abc123" }),
+    });
+
+    const { result } = renderHook(() =>
+      useManifestWithSessionId({ manifest: baseManifest, shareAnalytics: true }),
+    );
+
+    expect(result.current.loading).toBe(true);
+    expect(result.current.manifest).toBeNull();
+  });
+
+  it("returns manifest with externalID after success", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ providerSessionId: "abc123" }),
+    });
+
+    const { result } = renderHook(() =>
+      useManifestWithSessionId({ manifest: baseManifest, shareAnalytics: true }),
+    );
+
+    await waitFor(() =>
+      expect(result.current.manifest).toEqual({
+        ...baseManifest,
+        url: "https://example.com/?externalID=abc123",
+      }),
+    );
+
+    expect(result.current.loading).toBe(false);
+  });
+
+  it("falls back to original manifest if fetch rejects", async () => {
+    mockFetch.mockRejectedValueOnce(new Error("network error"));
+
+    const { result } = renderHook(() =>
+      useManifestWithSessionId({ manifest: baseManifest, shareAnalytics: true }),
+    );
+
+    await waitFor(() => {
+      expect(result.current.manifest).toEqual(baseManifest);
+    });
+
+    expect(result.current.loading).toBe(false);
+  });
+
+  it("falls back to original manifest if response is not ok", async () => {
+    mockFetch.mockResolvedValueOnce({ ok: false });
+
+    const { result } = renderHook(() =>
+      useManifestWithSessionId({ manifest: baseManifest, shareAnalytics: true }),
+    );
+
+    await waitFor(() => {
+      expect(result.current.manifest).toEqual(baseManifest);
+    });
+
+    expect(result.current.loading).toBe(false);
+  });
+
+  it("returns null if manifest is not provided", async () => {
+    const { result } = renderHook(() =>
+      useManifestWithSessionId({ manifest: null, shareAnalytics: true }),
+    );
+
+    expect(mockFetch).not.toHaveBeenCalled();
+    expect(result.current.manifest).toBeNull();
+    expect(result.current.loading).toBe(false);
+  });
+
+  it("skips fetch if shareAnalytics is false and just returns manifest", () => {
+    const { result } = renderHook(() =>
+      useManifestWithSessionId({ manifest: baseManifest, shareAnalytics: false }),
+    );
+
+    expect(mockFetch).not.toHaveBeenCalled();
+    expect(result.current.manifest).toEqual(baseManifest);
+    expect(result.current.loading).toBe(false);
+  });
+});

package/src/hooks/useManifestWithSessionId.ts

@@ -0,0 +1,83 @@
+import React from "react";
+import { appendQueryParamsToManifestURL } from "../wallet-api/utils/appendQueryParamsToManifestURL";
+import { LiveAppManifest } from "../platform/types";
+import { getEnv } from "@ledgerhq/live-env";
+
+type Options = {
+  manifest: LiveAppManifest | null | undefined;
+  shareAnalytics: boolean;
+};
+
+type HookResult = {
+  manifest?: LiveAppManifest | null;
+  loading: boolean;
+};
+
+export function useManifestWithSessionId({ manifest, shareAnalytics }: Options): HookResult {
+  const [id, setId] = React.useState<string | null>(null);
+  const [loading, setLoading] = React.useState<boolean>(false);
+
+  React.useEffect(() => {
+    let cancelled = false;
+
+    async function fetchId() {
+      if (!shareAnalytics || !manifest) {
+        setId(null);
+        setLoading(false);
+        return;
+      }
+
+      setLoading(true);
+
+      try {
+        const response = await fetch(getEnv("PROVIDER_SESSION_ID_ENDPOINT"), {
+          method: "GET",
+          headers: {
+            Accept: "application/json",
+            "Content-Type": "application/json",
+          },
+        });
+
+        if (!response.ok) throw new Error("Failed to fetch session ID");
+
+        const { providerSessionId } = await response.json();
+
+        if (!cancelled) {
+          setId(providerSessionId);
+          setLoading(false);
+        }
+      } catch {
+        if (!cancelled) {
+          setId(null);
+          setLoading(false);
+        }
+      }
+    }
+
+    fetchId();
+
+    return () => {
+      cancelled = true; // avoid setting state after unmount
+    };
+  }, [shareAnalytics]);
+
+  const customizedManifest = React.useMemo(() => {
+    if (!manifest) return null;
+
+    if (loading) {
+      return null;
+    }
+
+    if (id) {
+      const url = appendQueryParamsToManifestURL(manifest, {
+        externalID: id,
+      });
+
+      return url ? { ...manifest, url: url.toString() } : manifest;
+    }
+
+    return manifest;
+  }, [manifest, id, loading]);
+
+  return { manifest: customizedManifest, loading };
+}

package/src/hw/actions/rawTransaction.ts

@@ -0,0 +1,190 @@
+import { of, Observable } from "rxjs";
+import { scan, catchError, tap } from "rxjs/operators";
+import { useEffect, useState } from "react";
+import { log } from "@ledgerhq/logs";
+import { TransportStatusError } from "@ledgerhq/errors";
+import { TransactionRefusedOnDevice } from "../../errors";
+import { getMainAccount } from "../../account";
+import { getAccountBridge } from "../../bridge";
+import type { ConnectAppEvent, Input as ConnectAppInput } from "../connectApp";
+import type { Action, Device } from "./types";
+import type { AppRequest, AppState } from "./app";
+import { createAction as createAppAction } from "./app";
+import type {
+  Account,
+  AccountLike,
+  SignedOperation,
+  SignOperationEvent,
+} from "@ledgerhq/types-live";
+
+type State = {
+  signedOperation: SignedOperation | null | undefined;
+  deviceSignatureRequested: boolean;
+  deviceStreamingProgress: number | null | undefined;
+  transactionSignError: Error | null | undefined;
+  transactionChecksOptInTriggered: boolean;
+  transactionChecksOptIn: boolean | null;
+  manifestId?: string;
+  manifestName?: string;
+};
+type RawTransactionState = AppState & State;
+type RawTransactionRequest = {
+  parentAccount: Account | null | undefined;
+  account: AccountLike;
+  transaction: string;
+  appName?: string;
+  dependencies?: AppRequest[];
+  requireLatestFirmware?: boolean;
+  manifestId?: string;
+  manifestName?: string;
+};
+export type RawTransactionResult =
+  | {
+      signedOperation: SignedOperation;
+      device: Device;
+      swapId?: string;
+    }
+  | {
+      transactionSignError: Error;
+    };
+type TransactionAction = Action<RawTransactionRequest, RawTransactionState, RawTransactionResult>;
+
+const mapResult = ({
+  device,
+  signedOperation,
+  transactionSignError,
+}: RawTransactionState): RawTransactionResult | null | undefined =>
+  signedOperation && device
+    ? {
+        signedOperation,
+        device,
+      }
+    : transactionSignError
+      ? {
+          transactionSignError,
+        }
+      : null;
+
+type Event =
+  | SignOperationEvent
+  | {
+      type: "error";
+      error: Error;
+    };
+const initialState = {
+  signedOperation: null,
+  deviceSignatureRequested: false,
+  deviceStreamingProgress: null,
+  transactionSignError: null,
+  transactionChecksOptInTriggered: false,
+  transactionChecksOptIn: null,
+};
+
+const reducer = (state: State, e: Event): State => {
+  switch (e.type) {
+    case "error": {
+      const { error } = e;
+      const transactionSignError =
+        error instanceof TransportStatusError && error.statusCode === 0x6985
+          ? new TransactionRefusedOnDevice()
+          : error;
+      return { ...initialState, transactionSignError };
+    }
+
+    case "signed":
+      return { ...state, signedOperation: e.signedOperation };
+
+    case "device-signature-requested":
+      return { ...state, deviceSignatureRequested: true };
+
+    case "device-signature-granted":
+      return { ...state, deviceSignatureRequested: false };
+
+    case "device-streaming":
+      return { ...state, deviceStreamingProgress: e.progress };
+
+    case "transaction-checks-opt-in-triggered":
+      return { ...state, transactionChecksOptInTriggered: true };
+
+    case "transaction-checks-opt-in":
+      return { ...state, transactionChecksOptIn: true };
+
+    case "transaction-checks-opt-out":
+      return { ...state, transactionChecksOptIn: false };
+
+    default:
+      return state;
+  }
+};
+
+export const createAction = (
+  connectAppExec: (arg0: ConnectAppInput) => Observable<ConnectAppEvent>,
+): TransactionAction => {
+  const useHook = (
+    reduxDevice: Device | null | undefined,
+    {
+      account,
+      parentAccount,
+      transaction,
+      appName,
+      dependencies,
+      requireLatestFirmware,
+      manifestId,
+      manifestName,
+    }: RawTransactionRequest,
+  ): RawTransactionState => {
+    const mainAccount = getMainAccount(account, parentAccount);
+    const appState = createAppAction(connectAppExec).useHook(reduxDevice, {
+      account: mainAccount,
+      appName,
+      dependencies,
+      requireLatestFirmware,
+    });
+    const { device, opened, inWrongDeviceForAccount, error } = appState;
+    const [state, setState] = useState(initialState);
+    useEffect(() => {
+      if (!device || !opened || inWrongDeviceForAccount || error) {
+        setState(initialState);
+        return;
+      }
+
+      const bridge = getAccountBridge(mainAccount);
+      const sub = bridge
+        .signRawOperation({
+          account: mainAccount,
+          transaction,
+          deviceId: device.deviceId,
+          deviceModelId: device.modelId,
+        })
+        .pipe(
+          catchError(error =>
+            of<{ type: "error"; error: Error }>({
+              type: "error",
+              error,
+            }),
+          ),
+          tap((e: Event) => log("actions-transaction-event", e.type, e)),
+          scan(reducer, initialState),
+        )
+        .subscribe((x: any) => setState(x));
+      return () => {
+        sub.unsubscribe();
+      };
+    }, [device, mainAccount, transaction, opened, inWrongDeviceForAccount, error]);
+    return {
+      ...appState,
+      ...state,
+      manifestId,
+      manifestName,
+      deviceStreamingProgress:
+        state.signedOperation || state.transactionSignError
+          ? null // when good app is opened, we start the progress so it doesn't "blink"
+          : state.deviceStreamingProgress || (appState.opened ? 0 : null),
+    };
+  };
+
+  return {
+    useHook,
+    mapResult,
+  };
+};

package/src/market/utils/index.ts

@@ -1,6 +1,9 @@
 import { PortfolioRange } from "@ledgerhq/types-live";
 import { Order } from "./types";
 
+// Export all types from types.ts
+export * from "./types";
+
 export function getRange(range: PortfolioRange | string) {
   switch (range) {
     case "day":