@ledgerhq/cryptoassets 13.32.0-nightly.2 → 13.32.0-nightly.3

package/src/api-token-converter.ts

@@ -1,33 +1,5 @@
 import type { TokenCurrency } from "@ledgerhq/types-cryptoassets";
-import {
-  convertERC20,
-  convertSplTokens,
-  convertJettonToken,
-  convertAlgorandASATokens,
-  convertVechainToken,
-  convertTRONTokens,
-  convertMultiversXESDTTokens,
-  convertCardanoNativeTokens,
-  convertStellarTokens,
-  convertSuiTokens,
-  convertAptCoinTokens,
-  convertAptFaTokens,
-} from "./legacy/legacy-utils";
-import {
-  AlgorandASAToken,
-  CardanoNativeToken,
-  ERC20Token,
-  MultiversXESDTToken,
-  StellarToken,
-  TRC10Token,
-  TRC20Token,
-} from "./types";
-import type { AptosToken } from "./data/apt_coin";
-import type { AptosToken as AptosFAToken } from "./data/apt_fungible_asset";
-import type { SuiToken } from "./data/sui";
-import type { Vip180Token } from "./data/vip180";
-import type { TonJettonToken } from "./data/ton-jetton";
-import type { SPLToken } from "./data/spl";
+import { findCryptoCurrencyById } from "./currencies";
 
 export interface ApiTokenData {
   id: string;
@@ -39,121 +11,133 @@ export interface ApiTokenData {
   delisted?: boolean;
   disableCountervalue?: boolean;
   tokenIdentifier?: string;
+  ledgerSignature?: string;
 }
 
+/**
+ * Transforms Ledger Live token ID to backend API format for querying
+ *
+ * This handles cases where LL uses different ID conventions than backend APIs.
+ * Applied BEFORE querying the API to ensure the request uses the correct format:
+ *
+ * - MultiversX: multiversx/esdt/* → elrond/esdt/* (API uses old name) [LIVE-22557]
+ * - Stellar: UPPERCASE → lowercase (API uses lowercase) [LIVE-22558]
+ *
+ * @param legacyId - Token ID in Ledger Live format
+ * @returns Token ID in backend API format
+ */
+export function legacyIdToApiId(legacyId: string): string {
+  let apiId = legacyId;
+
+  // LIVE-22557: MultiversX - API uses old "elrond" name
+  if (apiId.startsWith("multiversx/esdt/")) {
+    apiId = apiId.replace("multiversx/esdt/", "elrond/esdt/");
+  }
+
+  // LIVE-22558: Stellar - API uses all lowercase (including the address part)
+  if (apiId.startsWith("stellar/asset/")) {
+    apiId = apiId.toLowerCase();
+  }
+
+  return apiId;
+}
+
+/**
+ * Converts API token data to Ledger Live TokenCurrency format
+ *
+ * This function applies client-side transformations to reconcile differences between
+ * backend APIs (CAL/DaDa) and Ledger Live's expected token format:
+ *
+ * - MultiversX: elrond/esdt/* → multiversx/esdt/* [LIVE-22557]
+ * - Stellar: Normalizes casing to stellar/asset/UPPERCASE_ADDRESS and tokenType asset → stellar [LIVE-22558]
+ * - Cardano: Reconstructs contractAddress from policyId + tokenIdentifier [LIVE-22559]
+ * - Sui: Transforms tokenType from "coin" to "sui" [LIVE-22560]
+ * - TON Jetton: Removes name prefix from ID (ton/jetton/name_address → ton/jetton/address) [LIVE-22561]
+ *
+ * @param apiToken - Token data from backend API
+ * @returns TokenCurrency object in Ledger Live format, or undefined if parent currency not found
+ */
 export function convertApiToken(apiToken: ApiTokenData): TokenCurrency | undefined {
-  const { standard, id, contractAddress, name, ticker, units, delisted = false } = apiToken;
-
-  const magnitude = units[0]?.magnitude || 0;
-
-  switch (standard) {
-    case "erc20":
-    case "bep20": {
-      const parentCurrencyId = id.split("/")[0];
-      const tokenIdentifier = id.split("/")[2] || contractAddress;
-      const erc20Data: ERC20Token = [
-        parentCurrencyId,
-        tokenIdentifier,
-        ticker,
-        magnitude,
-        name,
-        "",
-        contractAddress,
-        false,
-        delisted,
-      ];
-      return convertERC20(erc20Data);
-    }
-    case "spl": {
-      const parentCurrencyId = id.split("/")[0];
-      const splData: SPLToken = [id, parentCurrencyId, name, ticker, contractAddress, magnitude];
-      return convertSplTokens(splData);
-    }
-    case "jetton": {
-      const jettonData: TonJettonToken = [contractAddress, name, ticker, magnitude, delisted];
-      return convertJettonToken(jettonData);
-    }
-    case "asa": {
-      const tokenId = id.split("/")[2] || contractAddress;
-      const asaData: AlgorandASAToken = [tokenId, ticker, name, contractAddress, magnitude];
-      return convertAlgorandASATokens(asaData);
-    }
-    case "esdt": {
-      const tokenIdentifier = id.split("/")[2] || contractAddress;
-      const esdtData: MultiversXESDTToken = [ticker, tokenIdentifier, magnitude, "", name];
-      return convertMultiversXESDTTokens(esdtData);
-    }
-    case "trc10": {
-      const tokenId = parseInt(id.split("/")[2] || contractAddress);
-      const trc10Data: TRC10Token = [
-        tokenId,
-        ticker,
-        name,
-        contractAddress,
-        magnitude,
-        delisted,
-        "",
-      ];
-      return convertTRONTokens("trc10")(trc10Data);
-    }
-    case "trc20": {
-      const tokenId = id.split("/")[2] || contractAddress;
-      const trc20Data: TRC20Token = [
-        tokenId,
-        ticker,
-        name,
-        contractAddress,
-        magnitude,
-        delisted,
-        "",
-      ];
-      return convertTRONTokens("trc20")(trc20Data);
-    }
-    case "vip180": {
-      const tokenIdentifier = id.split("/")[2] || contractAddress;
-      const vip180Data: Vip180Token = [tokenIdentifier, ticker, name, contractAddress, magnitude];
-      return convertVechainToken(vip180Data);
-    }
-    case "native": {
-      const parentCurrencyId = id.split("/")[0];
-      if (parentCurrencyId !== "cardano") return undefined;
-
-      const tokenIdentifier = id.split("/")[2] || contractAddress;
-      const parts = tokenIdentifier.split(".");
-      const [policyId, assetName = ""] = parts;
-
-      const cardanoData: CardanoNativeToken = [
-        "cardano",
-        policyId,
-        assetName,
-        name,
-        ticker,
-        magnitude,
-        delisted,
-      ];
-      return convertCardanoNativeTokens(cardanoData);
-    }
-    case "stellar": {
-      const parts = contractAddress.split(":");
-      const assetCode = parts[0] || ticker;
-      const assetIssuer = parts[1] || contractAddress;
+  const {
+    standard,
+    id,
+    contractAddress,
+    name,
+    ticker,
+    units,
+    delisted = false,
+    tokenIdentifier,
+    ledgerSignature,
+  } = apiToken;
 
-      const stellarData: StellarToken = [assetCode, assetIssuer, "stellar", name, magnitude];
-      return convertStellarTokens(stellarData);
-    }
-    case "coin": {
-      const aptCoinData: AptosToken = [id, ticker, name, contractAddress, magnitude, delisted];
-      return convertAptCoinTokens(aptCoinData);
-    }
-    case "fungible_asset": {
-      const aptFaData: AptosFAToken = [id, ticker, name, contractAddress, magnitude, delisted];
-      return convertAptFaTokens(aptFaData);
-    }
-    case "sui": {
-      const suiData: SuiToken = [id, name, ticker, contractAddress, magnitude, ""];
-      return convertSuiTokens(suiData);
+  // Apply client-side patches to reconcile CAL format with LL format
+  let patchedId = id;
+  let patchedContractAddress = contractAddress;
+  let patchedStandard = standard;
+
+  // Get parent currency from the ORIGINAL ID (before transformation)
+  // This is important for currencies that changed names (elrond -> multiversx)
+  const parentCurrencyId = id.split("/")[0];
+  const parentCurrency = findCryptoCurrencyById(parentCurrencyId);
+
+  if (!parentCurrency) {
+    return undefined;
+  }
+
+  // LIVE-22557: MultiversX - Transform elrond/* to multiversx/*
+  if (patchedId.startsWith("elrond/esdt/")) {
+    patchedId = patchedId.replace("elrond/esdt/", "multiversx/esdt/");
+  }
+
+  // LIVE-22558: Stellar - Transform to LL mixed-case format: stellar/asset/ + UPPERCASE_REST
+  // Also fix tokenType: API returns "asset", LL expects "stellar"
+  const stellarPrefix = "stellar/asset/";
+  if (patchedId.toLowerCase().startsWith(stellarPrefix)) {
+    const rest = patchedId.substring(stellarPrefix.length);
+    patchedId = stellarPrefix + rest.toUpperCase();
+    patchedStandard = patchedStandard === "asset" ? "stellar" : patchedStandard;
+  }
+
+  // LIVE-22559: Cardano - Reconstruct full assetId (policyId + assetName)
+  if (standard === "native" && tokenIdentifier) {
+    patchedContractAddress = contractAddress + tokenIdentifier;
+  }
+
+  // LIVE-22560: Sui - Transform "coin" standard to "sui" tokenType (LL format)
+  if (standard === "coin" && patchedId.startsWith("sui/")) {
+    patchedStandard = "sui";
+  }
+
+  // LIVE-22561: TON Jetton - Remove name prefix from ID (API: ton/jetton/name_address -> LL: ton/jetton/address)
+  if (patchedId.startsWith("ton/jetton/") && patchedId.indexOf("_") > 0) {
+    const parts = patchedId.split("_");
+    if (parts.length === 2) {
+      patchedId = "ton/jetton/" + parts[1];
     }
-    default:
-      return undefined;
   }
+
+  // Construct TokenCurrency directly from API data
+  const tokenCurrency: TokenCurrency = {
+    type: "TokenCurrency",
+    id: patchedId,
+    contractAddress: patchedContractAddress,
+    parentCurrency,
+    tokenType: patchedStandard,
+    name,
+    ticker,
+    delisted,
+    disableCountervalue: !!parentCurrency.isTestnetFor || !!apiToken.disableCountervalue,
+    units: units.map(unit => ({
+      name: unit.name,
+      code: unit.code,
+      magnitude: unit.magnitude,
+    })),
+  };
+
+  // Add ledgerSignature if present
+  if (ledgerSignature) {
+    tokenCurrency.ledgerSignature = ledgerSignature;
+  }
+
+  return tokenCurrency;
 }

package/src/cal-client/entities/index.ts

@@ -45,7 +45,7 @@ export const ApiTokenResponseSchema = z.object({
   /** Chain ID */
   chain_id: z.string(),
   /** Token identifier */
-  token_identifier: z.string(),
+  token_identifier: z.string().optional(),
   /** Network type */
   network_type: z.string(),
   /** Meta currency ID */
@@ -53,7 +53,7 @@ export const ApiTokenResponseSchema = z.object({
   /** Blockchain name */
   blockchain_name: z.string(),
   /** Live signature */
-  live_signature: z.string(),
+  live_signature: z.string().optional(),
 });
 
 export type ApiTokenResponse = z.infer<typeof ApiTokenResponseSchema>;

package/src/cal-client/state-manager/api.ts

@@ -4,7 +4,7 @@ import { getEnv } from "@ledgerhq/live-env";
 import { GetTokensDataParams, PageParam, TokensDataTags, TokensDataWithPagination } from "./types";
 import { TOKEN_OUTPUT_FIELDS } from "./fields";
 import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { findCryptoCurrencyById } from "../../currencies";
+import { convertApiToken } from "../../api-token-converter";
 
 function transformTokensResponse(
   response: ApiTokenResponse[],
@@ -24,28 +24,28 @@ function transformTokensResponse(
 }
 
 function transformApiTokenToTokenCurrency(token: ApiTokenResponse): TokenCurrency | undefined {
-  const parentCurrency = findCryptoCurrencyById(token.network);
-  if (!parentCurrency) {
-    return undefined;
-  }
-
-  return {
-    type: "TokenCurrency",
+  // convertApiToken handles all format reconciliation internally
+  const result = convertApiToken({
     id: token.id,
-    ledgerSignature: token.live_signature,
     contractAddress: token.contract_address,
-    parentCurrency,
-    tokenType: token.standard,
     name: token.name,
     ticker: token.ticker,
-    units: token.units.map(unit => ({
-      code: unit.code,
-      name: unit.name,
-      magnitude: unit.magnitude,
-    })),
+    units: token.units,
+    standard: token.standard,
+    tokenIdentifier: token.token_identifier,
     delisted: token.delisted,
-    symbol: token.symbol,
-  };
+    ledgerSignature: token.live_signature,
+  });
+
+  // Add symbol if result exists
+  if (result && token.symbol) {
+    return {
+      ...result,
+      symbol: token.symbol,
+    };
+  }
+
+  return result;
 }
 
 export const cryptoAssetsApi = createApi({