@ledgerhq/live-common 34.37.0-nightly.4 → 34.37.0

package/src/bridge/generic-alpaca/tests/prepareTransaction.test.ts

@@ -1,66 +0,0 @@
-import { genericPrepareTransaction } from "../prepareTransaction";
-import { getAlpacaApi } from "../alpaca";
-import { transactionToIntent } from "../utils";
-import BigNumber from "bignumber.js";
-import type { TransactionCommon } from "@ledgerhq/types-live";
-
-jest.mock("../alpaca", () => ({
-  getAlpacaApi: jest.fn(),
-}));
-
-jest.mock("../utils", () => ({
-  transactionToIntent: jest.fn(),
-}));
-
-describe("genericPrepareTransaction", () => {
-  const network = "testnet";
-  const kind = "local";
-
-  const account = {
-    id: "test-account",
-    address: "0xabc",
-  } as any;
-
-  const baseTransaction: TransactionCommon & { fees: BigNumber } = {
-    amount: new BigNumber(100_000),
-    fees: new BigNumber(500),
-    recipient: "0xrecipient",
-  };
-
-  const txIntent = { mock: "intent" };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    (transactionToIntent as jest.Mock).mockReturnValue(txIntent);
-  });
-
-  it("updates fees if they differ", async () => {
-    const newFee = new BigNumber(700);
-
-    (getAlpacaApi as jest.Mock).mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: newFee }),
-    });
-
-    const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(account, { ...baseTransaction });
-
-    expect((result as any).fees.toString()).toBe(newFee.toString());
-    expect(transactionToIntent).toHaveBeenCalledWith(
-      account,
-      expect.objectContaining(baseTransaction),
-    );
-  });
-
-  it("returns original transaction if fees are the same", async () => {
-    const sameFee = baseTransaction.fees;
-
-    (getAlpacaApi as jest.Mock).mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: sameFee }),
-    });
-
-    const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(account, { ...baseTransaction });
-
-    expect(result).toStrictEqual(baseTransaction);
-  });
-});

package/src/bridge/generic-alpaca/tests/signOperation.test.ts

@@ -1,96 +0,0 @@
-import { lastValueFrom } from "rxjs";
-import { toArray } from "rxjs/operators";
-import { genericSignOperation } from "../signOperation";
-import { FeeNotLoaded } from "@ledgerhq/errors";
-import { getAlpacaApi } from "../alpaca";
-import { buildOptimisticOperation, transactionToIntent } from "../utils";
-
-jest.mock("../alpaca", () => ({
-  getAlpacaApi: jest.fn(),
-}));
-
-jest.mock("../utils", () => ({
-  buildOptimisticOperation: jest.fn(),
-  transactionToIntent: jest.fn(),
-}));
-
-describe("genericSignOperation", () => {
-  const network = "xrp";
-  const kind = "local";
-
-  const mockSignerContext = jest.fn();
-  const mockSigner = {
-    getAddress: jest.fn(),
-    signTransaction: jest.fn(),
-  };
-
-  const account = {
-    freshAddressPath: "44'/144'/0'/0/0",
-    address: "rTestAddress",
-  } as any;
-
-  const transaction = {
-    amount: 100_000n,
-    fees: 500n,
-    tag: 1234,
-  } as any;
-
-  const deviceId = "mockDevice";
-
-  const txIntent = {
-    memo: {
-      type: "map",
-      memos: new Map(),
-    },
-  };
-
-  const unsignedTx = "unsignedTx";
-  const signedTx = "signedTx";
-  const pubKey = "pubKey";
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-
-    (getAlpacaApi as jest.Mock).mockReturnValue({
-      craftTransaction: jest.fn().mockResolvedValue(unsignedTx),
-      combine: jest.fn().mockResolvedValue(signedTx),
-    });
-
-    (transactionToIntent as jest.Mock).mockReturnValue(txIntent);
-    (buildOptimisticOperation as jest.Mock).mockReturnValue({ id: "mock-op" });
-
-    mockSigner.getAddress.mockResolvedValue({ publicKey: pubKey });
-    mockSigner.signTransaction.mockResolvedValue("sig");
-    mockSignerContext.mockImplementation(async (_deviceId, cb) => cb(mockSigner));
-  });
-
-  it("emits full sign operation flow", async () => {
-    const signOperation = genericSignOperation(network, kind)(mockSignerContext);
-    const observable = signOperation({ account, transaction, deviceId });
-
-    const events = await lastValueFrom(observable.pipe(toArray()));
-
-    expect(events[0]).toEqual({ type: "device-signature-requested" });
-    expect(events[1]).toEqual({ type: "device-signature-granted" });
-    expect(events[2]).toEqual({
-      type: "signed",
-      signedOperation: {
-        operation: { id: "mock-op" },
-        signature: signedTx,
-      },
-    });
-
-    expect(transactionToIntent).toHaveBeenCalledWith(account, transaction);
-    expect(txIntent.memo.memos.get("destinationTag")).toBe("1234");
-  });
-
-  it("throws FeeNotLoaded if fees are missing", async () => {
-    const txWithoutFees = { ...transaction };
-    delete txWithoutFees.fees;
-
-    const signOperation = genericSignOperation(network, kind)(mockSignerContext);
-    const observable = signOperation({ account, transaction: txWithoutFees, deviceId });
-
-    await expect(observable.toPromise()).rejects.toThrow(FeeNotLoaded);
-  });
-});

package/src/bridge/generic-alpaca/utils.ts

@@ -1,63 +0,0 @@
-import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
-import { Account, Operation, OperationType, TransactionCommon } from "@ledgerhq/types-live";
-import {
-  Operation as CoreOperation,
-  Asset,
-  TransactionIntent,
-} from "@ledgerhq/coin-framework/api/types";
-import BigNumber from "bignumber.js";
-import { fromBigNumberToBigInt } from "@ledgerhq/coin-framework/utils";
-
-export function adaptCoreOperationToLiveOperation(
-  accountId: string,
-  op: CoreOperation<Asset>,
-): Operation {
-  return {
-    id: encodeOperationId(accountId, op.tx.hash, op.type),
-    hash: op.tx.hash,
-    accountId,
-    type: op.type as OperationType,
-    value: new BigNumber(op.value.toString()),
-    fee: new BigNumber(op.tx.fees.toString()),
-    blockHash: op.tx.block.hash,
-    blockHeight: op.tx.block.height,
-    senders: op.senders,
-    recipients: op.recipients,
-    date: op.tx.date,
-    transactionSequenceNumber: op.details?.sequence as number,
-    extra: {},
-  };
-}
-
-export function transactionToIntent(
-  _account: Account,
-  transaction: TransactionCommon,
-): TransactionIntent<any> {
-  return {
-    type: "Payment",
-    sender: _account.freshAddress,
-    recipient: transaction.recipient,
-    amount: fromBigNumberToBigInt(transaction.amount, BigInt(0)),
-    asset: null,
-  };
-}
-
-export const buildOptimisticOperation = (
-  account: Account,
-  transaction: TransactionCommon,
-): Operation => {
-  return {
-    id: encodeOperationId(account.id, "", "OUT"),
-    hash: "",
-    type: "OUT",
-    value: transaction.amount,
-    fee: transaction["fees"] ?? BigNumber(0),
-    blockHash: null,
-    blockHeight: null,
-    senders: [account.freshAddress.toString()],
-    recipients: [transaction.recipient],
-    accountId: account.id,
-    date: new Date(),
-    extra: {},
-  };
-};

package/src/hooks/useShowProviderLoadingTransition.test.ts

@@ -1,112 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-
-import { renderHook } from "@testing-library/react";
-import { LiveAppManifest } from "../platform/types";
-import { INTERNAL_APP_IDS } from "../wallet-api/constants";
-import { useFeature } from "../featureFlags";
-import { useInternalAppIds } from "./useInternalAppIds";
-
-import { useShowProviderLoadingTransition } from "./useShowProviderLoadingTransition";
-
-jest.mock("../featureFlags", () => ({
-  useFeature: jest.fn(),
-}));
-jest.mock("../wallet-api/constants", () => ({
-  INTERNAL_APP_IDS: ["internal-app-id-1", "internal-app-id-2"],
-}));
-jest.mock("./useInternalAppIds", () => ({
-  useInternalAppIds: jest.fn(),
-}));
-
-describe("useShowProviderLoadingTransition", () => {
-  const mockUseFeature = useFeature as jest.Mock;
-  const mockUseInternalAppIds = useInternalAppIds as jest.Mock;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it("should return false when feature is disabled", () => {
-    mockUseFeature.mockReturnValue({ enabled: false, params: {} });
-    const { result } = renderHook(() =>
-      useShowProviderLoadingTransition({
-        manifest: { id: "test-app-id" } as LiveAppManifest,
-        isLoading: true,
-      }),
-    );
-    expect(result.current).toBe(false);
-  });
-
-  it("should return false for internal apps", () => {
-    mockUseFeature.mockReturnValue({ enabled: true, params: {} });
-    mockUseInternalAppIds.mockReturnValue(INTERNAL_APP_IDS);
-    const { result } = renderHook(() =>
-      useShowProviderLoadingTransition({
-        manifest: { id: "internal-app-id-1" } as LiveAppManifest,
-        isLoading: true,
-      }),
-    );
-    expect(result.current).toBe(false);
-  });
-
-  it("should return true when loading and feature is enabled", () => {
-    mockUseFeature.mockReturnValue({ enabled: true, params: {} });
-    mockUseInternalAppIds.mockReturnValue([]);
-    const { result } = renderHook(() =>
-      useShowProviderLoadingTransition({
-        manifest: { id: "test-app-id" } as LiveAppManifest,
-        isLoading: true,
-      }),
-    );
-    expect(result.current).toBe(true);
-  });
-
-  it("should handle extended loading state", () => {
-    jest.useFakeTimers();
-    mockUseFeature.mockReturnValue({ enabled: true, params: { durationMs: 1000 } });
-    mockUseInternalAppIds.mockReturnValue([]);
-
-    const { result, rerender } = renderHook(
-      ({ isLoading }) =>
-        useShowProviderLoadingTransition({
-          manifest: { id: "test-app-id" } as LiveAppManifest,
-          isLoading,
-        }),
-      {
-        initialProps: { isLoading: true },
-      },
-    );
-
-    expect(result.current).toBe(true);
-
-    // Simulate the timeout
-    jest.advanceTimersByTime(1000);
-
-    rerender({ isLoading: false });
-
-    expect(result.current).toBe(false);
-
-    jest.useRealTimers();
-  });
-  it("should clear timeout on unmount", () => {
-    jest.useFakeTimers();
-    mockUseFeature.mockReturnValue({ enabled: true, params: { durationMs: 1000 } });
-    mockUseInternalAppIds.mockReturnValue([]);
-
-    const { unmount } = renderHook(() =>
-      useShowProviderLoadingTransition({
-        manifest: { id: "test-app-id" } as LiveAppManifest,
-        isLoading: true,
-      }),
-    );
-
-    unmount();
-
-    // Advance timers to ensure no memory leaks
-    jest.advanceTimersByTime(1000);
-
-    jest.useRealTimers();
-  });
-});

package/src/hooks/useShowProviderLoadingTransition.ts

@@ -1,57 +0,0 @@
-import { useEffect, useRef, useState } from "react";
-
-import { useFeature } from "../featureFlags/index";
-import { INTERNAL_APP_IDS } from "../wallet-api/constants";
-import { useInternalAppIds } from "./useInternalAppIds";
-import { LiveAppManifest } from "../platform/types";
-
-export function useShowProviderLoadingTransition({
-  isLoading,
-  manifest,
-}: {
-  manifest: LiveAppManifest;
-  isLoading: boolean;
-}) {
-  const isEnabled = useProviderInterstitalEnabled({ manifest });
-  const [extendedInitialLoading, setExtendedInitialLoading] = useState(false);
-
-  const timeoutRef = useRef<NodeJS.Timeout | null>(null);
-  const buySellLoaderFF = useFeature("buySellLoader");
-  const durationMs = buySellLoaderFF?.params?.durationMs ?? 0;
-  const internalAppIds = useInternalAppIds() || INTERNAL_APP_IDS;
-  const isAppInternal = internalAppIds.includes(manifest.id);
-
-  useEffect(() => {
-    if (isEnabled && isLoading && !extendedInitialLoading) {
-      setExtendedInitialLoading(true);
-
-      if (timeoutRef.current) clearTimeout(timeoutRef.current);
-
-      timeoutRef.current = setTimeout(() => {
-        setExtendedInitialLoading(false);
-      }, durationMs);
-    }
-  }, [durationMs, extendedInitialLoading, isAppInternal, isEnabled, isLoading]);
-
-  useEffect(() => {
-    return () => {
-      if (timeoutRef.current) clearTimeout(timeoutRef.current);
-    };
-  }, []);
-
-  return isEnabled && (isLoading || extendedInitialLoading);
-}
-
-export function useProviderInterstitalEnabled({ manifest }: { manifest?: LiveAppManifest }) {
-  const buySellLoaderFF = useFeature("buySellLoader");
-  const internalAppIds = useInternalAppIds() || INTERNAL_APP_IDS;
-
-  if (!manifest) {
-    return false;
-  }
-
-  const isAppInternal = internalAppIds.includes(manifest.id);
-  const isEnabled = buySellLoaderFF?.enabled && !isAppInternal;
-
-  return isEnabled;
-}

package/src/sanction/errors.ts

@@ -1,31 +0,0 @@
-export class UserAddressSanctionedError extends Error {
-  constructor() {
-    super();
-    this.message = this.constructor.name;
-    this.name = this.constructor.name;
-  }
-}
-
-export class UserAddressSanctionedForSendError extends Error {
-  constructor() {
-    super();
-    this.message = this.constructor.name;
-    this.name = this.constructor.name;
-  }
-}
-
-export class UserAddressSanctionedForStakingError extends Error {
-  constructor() {
-    super();
-    this.message = this.constructor.name;
-    this.name = this.constructor.name;
-  }
-}
-
-export class RecipientAddressSanctionedError extends Error {
-  constructor() {
-    super();
-    this.message = this.constructor.name;
-    this.name = this.constructor.name;
-  }
-}

package/src/sanction/index.ts

@@ -1,59 +0,0 @@
-import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
-import axios from "axios";
-import { hours, makeLRUCache } from "@ledgerhq/live-network/cache";
-import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import { getCurrencyConfiguration, getSharedConfiguration } from "../config";
-import { CurrencyConfig } from "@ledgerhq/coin-framework/config";
-
-const cache = makeLRUCache(fetchSanctionedAddresses, () => "all_sanctioned_addresses", hours(12));
-
-async function fetchSanctionedAddresses(): Promise<Record<string, string[]>> {
-  const { data } = await axios.get(
-    "https://ofac-compliance.pages.dev/all_sanctioned_addresses.json",
-  );
-  return data;
-}
-
-export async function isAddressSanctioned(
-  currency: CryptoCurrency,
-  address: string,
-): Promise<boolean> {
-  if (!isCheckBlacklistAddressEnabled(currency)) {
-    return false;
-  }
-
-  // Only for testing, should be deleted after
-  const temporarySanctionedAddresses: string[] | undefined =
-    LiveConfig.getValueByKey(`tmp_sanctioned_addresses`);
-
-  const data: Record<string, string[]> = await cache();
-  const addresses = data[currency.ticker] || [];
-
-  if (temporarySanctionedAddresses) {
-    return addresses.concat(temporarySanctionedAddresses).includes(address);
-  }
-
-  return addresses.includes(address);
-}
-
-function isCheckBlacklistAddressEnabled(currency: CryptoCurrency): boolean {
-  const currencyConfig = tryGetCurrencyConfig(currency);
-  if (currencyConfig && "checkBlacklistAddress" in currencyConfig) {
-    return currencyConfig.checkBlacklistAddress === true;
-  } else {
-    const sharedConfiguration = getSharedConfiguration();
-    if ("checkBlacklistAddress" in sharedConfiguration) {
-      return sharedConfiguration.checkBlacklistAddress === true;
-    }
-  }
-
-  return false;
-}
-
-function tryGetCurrencyConfig(currency: CryptoCurrency): CurrencyConfig | undefined {
-  try {
-    return getCurrencyConfiguration(currency);
-  } catch (error) {
-    return undefined;
-  }
-}