@ledgerhq/live-common 34.55.0-nightly.20251216024112 → 34.55.0-nightly.20251218023953

package/src/bridge/descriptor.ts

@@ -0,0 +1,256 @@
+import type { CryptoOrTokenCurrency, CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import type { FeatureId, FeatureConfig } from "@ledgerhq/coin-framework/features/types";
+import { getCurrencyBridge } from "./impl";
+import { getCurrencyConfiguration } from "../config/index";
+import { descriptor as algorandDescriptor } from "../families/algorand/descriptor";
+import { descriptor as aptosDescriptor } from "../families/aptos/descriptor";
+import { descriptor as bitcoinDescriptor } from "../families/bitcoin/descriptor";
+import { descriptor as cantonDescriptor } from "../families/canton/descriptor";
+import { descriptor as cardanoDescriptor } from "../families/cardano/descriptor";
+import { descriptor as casperDescriptor } from "../families/casper/descriptor";
+import { descriptor as celoDescriptor } from "../families/celo/descriptor";
+import { descriptor as cosmosDescriptor } from "../families/cosmos/descriptor";
+import { descriptor as evmDescriptor } from "../families/evm/descriptor";
+import { descriptor as filecoinDescriptor } from "../families/filecoin/descriptor";
+import { descriptor as hederaDescriptor } from "../families/hedera/descriptor";
+import { descriptor as iconDescriptor } from "../families/icon/descriptor";
+import { descriptor as internetComputerDescriptor } from "../families/internet_computer/descriptor";
+import { descriptor as kaspaDescriptor } from "../families/kaspa/descriptor";
+import { descriptor as minaDescriptor } from "../families/mina/descriptor";
+import { descriptor as multiversxDescriptor } from "../families/multiversx/descriptor";
+import { descriptor as nearDescriptor } from "../families/near/descriptor";
+import { descriptor as polkadotDescriptor } from "../families/polkadot/descriptor";
+import { descriptor as solanaDescriptor } from "../families/solana/descriptor";
+import { descriptor as stacksDescriptor } from "../families/stacks/descriptor";
+import { descriptor as stellarDescriptor } from "../families/stellar/descriptor";
+import { descriptor as suiDescriptor } from "../families/sui/descriptor";
+import { descriptor as tezosDescriptor } from "../families/tezos/descriptor";
+import { descriptor as tonDescriptor } from "../families/ton/descriptor";
+import { descriptor as tronDescriptor } from "../families/tron/descriptor";
+import { descriptor as vechainDescriptor } from "../families/vechain/descriptor";
+import { descriptor as xrpDescriptor } from "../families/xrp/descriptor";
+
+/**
+ * Memo field type configuration
+ */
+export type MemoType =
+  | "text" // Simple text memo (cosmos, solana, algorand)
+  | "tag" // Numeric tag (xrp destination tag, casper transfer id)
+  | "typed"; // Typed memo with predefined options (stellar)
+
+/**
+ * Input field types for descriptors
+ */
+export type InputFieldType = "text" | "number" | "tag" | "typed";
+
+/**
+ * Input field descriptor for a transaction flow
+ */
+export type InputDescriptor = Readonly<{
+  type: InputFieldType;
+  maxLength?: number;
+  maxValue?: number;
+  options?: readonly string[];
+  supportsDomain?: boolean; // Whether the field supports domain names (ENS for EVM)
+}>;
+
+/**
+ * Fee input options
+ */
+export type FeeDescriptor = {
+  hasPresets: boolean;
+  hasCustom: boolean;
+  hasCoinControl?: boolean;
+};
+
+/**
+ * Send flow descriptor defining inputs for the send transaction
+ */
+export type SendDescriptor = {
+  inputs: {
+    recipientSupportsDomain?: boolean; // Whether recipient field supports domain names (ENS for EVM)
+    memo?: InputDescriptor;
+  };
+  fees: FeeDescriptor;
+};
+
+/**
+ * Complete flow descriptors for a coin
+ */
+export type CoinDescriptor = {
+  send: SendDescriptor;
+  // Future: stake, swap, etc.
+};
+
+export const newFlowsConfig: Record<
+  string,
+  { send?: boolean; staking?: boolean; receive?: boolean }
+> = {
+  algorand: { send: false },
+  aptos: { send: false },
+  bitcoin: { send: false },
+  canton: { send: false },
+  cardano: { send: false },
+  casper: { send: false },
+  celo: { send: false },
+  cosmos: { send: false },
+  evm: { send: false },
+  filecoin: { send: false },
+  hedera: { send: false },
+  icon: { send: false },
+  internet_computer: { send: false },
+  kaspa: { send: false },
+  mina: { send: false },
+  multiversx: { send: false },
+  near: { send: false },
+  polkadot: { send: false },
+  solana: { send: false },
+  stacks: { send: false },
+  stellar: { send: false },
+  sui: { send: false },
+  tezos: { send: false },
+  ton: { send: false },
+  tron: { send: false },
+  vechain: { send: false },
+  xrp: { send: false },
+};
+
+const descriptorRegistry: Record<string, CoinDescriptor> = {
+  algorand: algorandDescriptor,
+  aptos: aptosDescriptor,
+  bitcoin: bitcoinDescriptor,
+  canton: cantonDescriptor,
+  cardano: cardanoDescriptor,
+  casper: casperDescriptor,
+  celo: celoDescriptor,
+  cosmos: cosmosDescriptor,
+  evm: evmDescriptor,
+  filecoin: filecoinDescriptor,
+  hedera: hederaDescriptor,
+  icon: iconDescriptor,
+  internet_computer: internetComputerDescriptor,
+  kaspa: kaspaDescriptor,
+  mina: minaDescriptor,
+  multiversx: multiversxDescriptor,
+  near: nearDescriptor,
+  polkadot: polkadotDescriptor,
+  solana: solanaDescriptor,
+  stacks: stacksDescriptor,
+  stellar: stellarDescriptor,
+  sui: suiDescriptor,
+  tezos: tezosDescriptor,
+  ton: tonDescriptor,
+  tron: tronDescriptor,
+  vechain: vechainDescriptor,
+  xrp: xrpDescriptor,
+};
+
+function isFeatureActive(currency: CryptoCurrency, featureId: FeatureId): boolean {
+  try {
+    const currencyConfig = getCurrencyConfiguration(currency);
+
+    if (currencyConfig.status.type !== "active") {
+      return false;
+    }
+
+    // Type guard
+    const features = (currencyConfig.status as { type: "active"; features?: FeatureConfig[] })
+      .features;
+    return features?.find(f => f.id === featureId)?.status === "active";
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get the full descriptor for a given currency via the CurrencyBridge
+ */
+export function getDescriptor(currency: CryptoOrTokenCurrency | undefined): CoinDescriptor | null {
+  if (!currency) {
+    return null;
+  }
+
+  const cryptoCurrency = currency.type === "TokenCurrency" ? currency.parentCurrency : currency;
+  const bridge = getCurrencyBridge(cryptoCurrency);
+
+  // Check if bridge implements getDescriptor directly
+  if ("getDescriptor" in bridge && typeof bridge.getDescriptor === "function") {
+    return bridge.getDescriptor(cryptoCurrency) as CoinDescriptor;
+  }
+
+  // Fallback: use the descriptor registry and check feature flags
+  const fullDescriptor = descriptorRegistry[cryptoCurrency.family];
+
+  if (!fullDescriptor) {
+    return null;
+  }
+
+  if (fullDescriptor.send && isFeatureActive(cryptoCurrency, "blockchain_txs")) {
+    return fullDescriptor;
+  }
+
+  return null;
+}
+
+/**
+ * Get the send flow descriptor for a given currency
+ */
+export function getSendDescriptor(
+  currency: CryptoOrTokenCurrency | undefined,
+): SendDescriptor | null {
+  const descriptor = getDescriptor(currency);
+  return descriptor?.send ?? null;
+}
+
+/*
+ * Check if the currency supports the new flows
+ */
+export function supportsNewFlows(
+  currency: CryptoOrTokenCurrency,
+  flow: "send" | "staking" | "receive",
+): boolean {
+  const cryptoCurrency = currency.type === "TokenCurrency" ? currency.parentCurrency : currency;
+  return newFlowsConfig[cryptoCurrency.family]?.[flow] ?? false;
+}
+
+/**
+ * Helper functions to check send flow capabilities
+ */
+export const sendFeatures = {
+  hasMemo: (currency: CryptoOrTokenCurrency | undefined): boolean => {
+    const descriptor = getSendDescriptor(currency);
+    return descriptor?.inputs.memo !== undefined;
+  },
+  hasFeePresets: (currency: CryptoOrTokenCurrency | undefined): boolean => {
+    const descriptor = getSendDescriptor(currency);
+    return descriptor?.fees.hasPresets ?? false;
+  },
+  hasCustomFees: (currency: CryptoOrTokenCurrency | undefined): boolean => {
+    const descriptor = getSendDescriptor(currency);
+    return descriptor?.fees.hasCustom ?? false;
+  },
+  hasCoinControl: (currency: CryptoOrTokenCurrency | undefined): boolean => {
+    const descriptor = getSendDescriptor(currency);
+    return descriptor?.fees.hasCoinControl ?? false;
+  },
+  getMemoType: (currency: CryptoOrTokenCurrency | undefined) => {
+    const descriptor = getSendDescriptor(currency);
+    return descriptor?.inputs.memo?.type;
+  },
+  getMemoMaxLength: (currency: CryptoOrTokenCurrency | undefined) => {
+    const descriptor = getSendDescriptor(currency);
+    return descriptor?.inputs.memo?.maxLength;
+  },
+  getMemoMaxValue: (currency: CryptoOrTokenCurrency | undefined) => {
+    const descriptor = getSendDescriptor(currency);
+    return descriptor?.inputs.memo?.maxValue;
+  },
+  getMemoOptions: (currency: CryptoOrTokenCurrency | undefined) => {
+    const descriptor = getSendDescriptor(currency);
+    return descriptor?.inputs.memo?.options;
+  },
+  supportsDomain: (currency: CryptoOrTokenCurrency | undefined): boolean => {
+    const descriptor = getSendDescriptor(currency);
+    return descriptor?.inputs.recipientSupportsDomain ?? false;
+  },
+};

package/src/dada-client/hooks/useAssetsData.ts

@@ -1,6 +1,7 @@
 import { useMemo } from "react";
 import { useGetAssetsDataInfiniteQuery } from "../state-manager/api";
 import { AssetsDataWithPagination, GetAssetsDataParams } from "../state-manager/types";
+import { parseError } from "../utils/errorUtils";
 
 const emptyData = () => ({
   cryptoAssets: {},
@@ -77,11 +78,14 @@ export function useAssetsData({
 
   const isInitialLoading = isLoading || (isFetching && !isFetchingNextPage);
 
+  const errorInfo = useMemo(() => parseError(error), [error]);
+
   return {
     data: joinedPages,
     isLoading: isInitialLoading,
     isFetchingNextPage,
     error,
+    errorInfo,
     loadNext: hasMore ? fetchNextPage : undefined,
     isSuccess,
     isError,

package/src/dada-client/utils/__test__/errorUtils.test.ts

@@ -0,0 +1,222 @@
+import {
+  isFetchBaseQueryError,
+  isNetworkError,
+  isApiError,
+  getApiErrorStatus,
+  parseError,
+} from "../errorUtils";
+
+describe("errorUtils", () => {
+  describe("isFetchBaseQueryError", () => {
+    it("should return true for FetchBaseQueryError with FETCH_ERROR status", () => {
+      const error = { status: "FETCH_ERROR", error: "Failed to fetch" };
+      expect(isFetchBaseQueryError(error)).toBe(true);
+    });
+
+    it("should return true for FetchBaseQueryError with numeric status", () => {
+      const error = { status: 500, data: { message: "Internal Server Error" } };
+      expect(isFetchBaseQueryError(error)).toBe(true);
+    });
+
+    it("should return false for null", () => {
+      expect(isFetchBaseQueryError(null)).toBe(false);
+    });
+
+    it("should return false for undefined", () => {
+      expect(isFetchBaseQueryError(undefined)).toBe(false);
+    });
+
+    it("should return false for object without status", () => {
+      const error = { message: "Some error" };
+      expect(isFetchBaseQueryError(error)).toBe(false);
+    });
+
+    it("should return false for primitive values", () => {
+      expect(isFetchBaseQueryError("error")).toBe(false);
+      expect(isFetchBaseQueryError(123)).toBe(false);
+    });
+  });
+
+  describe("isNetworkError", () => {
+    it("should return true for FETCH_ERROR", () => {
+      const error = { status: "FETCH_ERROR", error: "Failed to fetch" };
+      expect(isNetworkError(error)).toBe(true);
+    });
+
+    it("should return true for TIMEOUT_ERROR", () => {
+      const error = { status: "TIMEOUT_ERROR", error: "Request timed out" };
+      expect(isNetworkError(error)).toBe(true);
+    });
+
+    it("should return false for PARSING_ERROR", () => {
+      const error = { status: "PARSING_ERROR", error: "Invalid JSON" };
+      expect(isNetworkError(error)).toBe(false);
+    });
+
+    it("should return false for numeric status (API error)", () => {
+      const error = { status: 500, data: { message: "Server error" } };
+      expect(isNetworkError(error)).toBe(false);
+    });
+
+    it("should return false for undefined", () => {
+      expect(isNetworkError(undefined)).toBe(false);
+    });
+
+    it("should return false for non-FetchBaseQueryError", () => {
+      const error = { message: "Some error" };
+      expect(isNetworkError(error)).toBe(false);
+    });
+  });
+
+  describe("isApiError", () => {
+    it("should return true for 4xx status codes", () => {
+      expect(isApiError({ status: 400, data: {} })).toBe(true);
+      expect(isApiError({ status: 401, data: {} })).toBe(true);
+      expect(isApiError({ status: 404, data: {} })).toBe(true);
+    });
+
+    it("should return true for 5xx status codes", () => {
+      expect(isApiError({ status: 500, data: {} })).toBe(true);
+      expect(isApiError({ status: 502, data: {} })).toBe(true);
+      expect(isApiError({ status: 503, data: {} })).toBe(true);
+    });
+
+    it("should return false for FETCH_ERROR", () => {
+      const error = { status: "FETCH_ERROR", error: "Failed to fetch" };
+      expect(isApiError(error)).toBe(false);
+    });
+
+    it("should return false for TIMEOUT_ERROR", () => {
+      const error = { status: "TIMEOUT_ERROR", error: "Request timed out" };
+      expect(isApiError(error)).toBe(false);
+    });
+
+    it("should return false for undefined", () => {
+      expect(isApiError(undefined)).toBe(false);
+    });
+
+    it("should return false for non-FetchBaseQueryError", () => {
+      expect(isApiError({ message: "error" })).toBe(false);
+    });
+  });
+
+  describe("getApiErrorStatus", () => {
+    it("should return status code for API errors", () => {
+      expect(getApiErrorStatus({ status: 400, data: {} })).toBe(400);
+      expect(getApiErrorStatus({ status: 500, data: {} })).toBe(500);
+    });
+
+    it("should return undefined for FETCH_ERROR", () => {
+      const error = { status: "FETCH_ERROR", error: "Failed to fetch" };
+      expect(getApiErrorStatus(error)).toBeUndefined();
+    });
+
+    it("should return undefined for TIMEOUT_ERROR", () => {
+      const error = { status: "TIMEOUT_ERROR", error: "Request timed out" };
+      expect(getApiErrorStatus(error)).toBeUndefined();
+    });
+
+    it("should return undefined for undefined error", () => {
+      expect(getApiErrorStatus(undefined)).toBeUndefined();
+    });
+
+    it("should return undefined for non-FetchBaseQueryError", () => {
+      expect(getApiErrorStatus({ message: "error" })).toBeUndefined();
+    });
+  });
+
+  describe("parseError", () => {
+    it("should return correct ErrorInfo for network error (FETCH_ERROR)", () => {
+      const error = { status: "FETCH_ERROR", error: "Failed to fetch" };
+      const result = parseError(error);
+
+      expect(result).toEqual({
+        hasError: true,
+        isNetworkError: true,
+        isApiError: false,
+        apiStatus: undefined,
+      });
+    });
+
+    it("should return correct ErrorInfo for network error (TIMEOUT_ERROR)", () => {
+      const error = { status: "TIMEOUT_ERROR", error: "Request timed out" };
+      const result = parseError(error);
+
+      expect(result).toEqual({
+        hasError: true,
+        isNetworkError: true,
+        isApiError: false,
+        apiStatus: undefined,
+      });
+    });
+
+    it("should return correct ErrorInfo for API error", () => {
+      const error = { status: 500, data: { message: "Internal Server Error" } };
+      const result = parseError(error);
+
+      expect(result).toEqual({
+        hasError: true,
+        isNetworkError: false,
+        isApiError: true,
+        apiStatus: 500,
+      });
+    });
+
+    it("should return correct ErrorInfo for 404 error", () => {
+      const error = { status: 404, data: { message: "Not Found" } };
+      const result = parseError(error);
+
+      expect(result).toEqual({
+        hasError: true,
+        isNetworkError: false,
+        isApiError: true,
+        apiStatus: 404,
+      });
+    });
+
+    it("should return default ErrorInfo for undefined error", () => {
+      const result = parseError(undefined);
+
+      expect(result).toEqual({
+        hasError: false,
+        isNetworkError: false,
+        isApiError: false,
+        apiStatus: undefined,
+      });
+    });
+
+    it("should return default ErrorInfo for null error", () => {
+      const result = parseError(null);
+
+      expect(result).toEqual({
+        hasError: false,
+        isNetworkError: false,
+        isApiError: false,
+        apiStatus: undefined,
+      });
+    });
+
+    it("should return ErrorInfo with hasError true for non-FetchBaseQueryError", () => {
+      const result = parseError({ message: "Some generic error" });
+
+      expect(result).toEqual({
+        hasError: true,
+        isNetworkError: false,
+        isApiError: false,
+        apiStatus: undefined,
+      });
+    });
+
+    it("should return ErrorInfo with hasError true for PARSING_ERROR", () => {
+      const error = { status: "PARSING_ERROR", error: "Invalid JSON" };
+      const result = parseError(error);
+
+      expect(result).toEqual({
+        hasError: true,
+        isNetworkError: false,
+        isApiError: false,
+        apiStatus: undefined,
+      });
+    });
+  });
+});

package/src/dada-client/utils/errorUtils.ts

@@ -0,0 +1,57 @@
+import { FetchBaseQueryError } from "@reduxjs/toolkit/query";
+
+/**
+ * Type guard to check if error is a FetchBaseQueryError
+ */
+export function isFetchBaseQueryError(error: unknown): error is FetchBaseQueryError {
+  return typeof error === "object" && error !== null && "status" in error;
+}
+
+/**
+ * Check if the error is a network connectivity error (no internet, timeout, etc.)
+ */
+export function isNetworkError(error: unknown): boolean {
+  if (!isFetchBaseQueryError(error)) {
+    return false;
+  }
+  return error.status === "FETCH_ERROR" || error.status === "TIMEOUT_ERROR";
+}
+
+/**
+ * Check if the error is an API error with HTTP status code (4xx, 5xx)
+ */
+export function isApiError(error: unknown): boolean {
+  if (!isFetchBaseQueryError(error)) {
+    return false;
+  }
+  return typeof error.status === "number";
+}
+
+/**
+ * Get HTTP status code from API error, or undefined if not an API error
+ */
+export function getApiErrorStatus(error: unknown): number | undefined {
+  if (!isFetchBaseQueryError(error) || typeof error.status !== "number") {
+    return undefined;
+  }
+  return error.status;
+}
+
+export type ErrorInfo = {
+  hasError: boolean;
+  isNetworkError: boolean;
+  isApiError: boolean;
+  apiStatus: number | undefined;
+};
+
+/**
+ * Parse error into a structured ErrorInfo object
+ */
+export function parseError(error: unknown): ErrorInfo {
+  return {
+    hasError: !!error,
+    isNetworkError: isNetworkError(error),
+    isApiError: isApiError(error),
+    apiStatus: getApiErrorStatus(error),
+  };
+}

package/src/e2e/swap.ts

@@ -29,8 +29,8 @@ export async function getMinimumSwapAmount(AccountFrom: Account, AccountTo: Acco
 
     const minimumAmounts = data
       .filter((item: any) => item.parameter?.minAmount !== undefined)
-      .map((item: any) => parseFloat(item.parameter.minAmount))
-      .filter((amount: number) => !isNaN(amount));
+      .map((item: any) => Number.parseFloat(item.parameter.minAmount))
+      .filter((amount: number) => !Number.isNaN(amount));
 
     if (minimumAmounts.length === 0) {
       throw new Error("No valid minimum amounts returned from swap quote API.");

package/src/exchange/providers/swap.ts

@@ -115,6 +115,26 @@ const DEFAULT_SWAP_PROVIDERS: Record<string, ProviderConfig & Partial<Additional
     supportUrl: "https://criptointercambio.com/en/about",
     mainUrl: "https://criptointercambio.com/",
   },
+  cic_v2: {
+    name: "CIC",
+    publicKey: {
+      curve: "secp256k1",
+      data: Buffer.from(
+        "0444a71652995d15ef0d4d6fe8de21a0c8ad48bdbfea7f789319973669785ca96abca9fd0c504c3074d9b654f0e3a76dde642a03efe4ccdee3af3ca4ba4afa202d",
+        "hex",
+      ),
+    },
+    signature: Buffer.from(
+      "3044022078a73433ab6289027b7a169a260f180d16346f7ab55b06a22109f68a756d691d0220190edd6e1214c3309dc1b0afe90d217b728377491561383f2ee543e2c90188eb",
+      "hex",
+    ),
+    needsKYC: false,
+    needsBearerToken: false,
+    type: "CEX",
+    termsOfUseUrl: "https://criptointercambio.com/terms-of-use",
+    supportUrl: "https://criptointercambio.com/en/about",
+    mainUrl: "https://criptointercambio.com/",
+  },
   moonpay: {
     name: "moonpay",
     publicKey: {

package/src/families/algorand/config.ts

@@ -6,6 +6,7 @@ export const algorandConfig: Record<string, ConfigInfo> = {
     default: {
       status: {
         type: "active",
+        features: [{ id: "blockchain_txs", status: "active" }],
       },
     },
   },

package/src/families/algorand/descriptor.ts

@@ -0,0 +1,16 @@
+import type { CoinDescriptor } from "../../bridge/descriptor";
+
+export const descriptor: CoinDescriptor = {
+  send: {
+    inputs: {
+      memo: {
+        type: "text",
+        maxLength: 1000,
+      },
+    },
+    fees: {
+      hasPresets: false,
+      hasCustom: false,
+    },
+  },
+};

package/src/families/aptos/config.ts

@@ -4,7 +4,13 @@ const aptosConfig: CurrencyLiveConfigDefinition = {
   config_currency_aptos: {
     type: "object",
     default: {
-      status: { type: "active" },
+      status: {
+        type: "active",
+        features: [
+          { id: "blockchain_txs", status: "active" },
+          { id: "staking_txs", status: "active" },
+        ],
+      },
     },
   },
 };

package/src/families/aptos/descriptor.ts

@@ -0,0 +1,11 @@
+import type { CoinDescriptor } from "../../bridge/descriptor";
+
+export const descriptor: CoinDescriptor = {
+  send: {
+    inputs: {},
+    fees: {
+      hasPresets: false,
+      hasCustom: false,
+    },
+  },
+};