@ledgerhq/live-common 34.55.0-nightly.20251217023943 → 34.55.0-nightly.20251219024040

package/src/families/sui/config.ts

@@ -7,6 +7,7 @@ export const suiConfig: Record<string, ConfigInfo> = {
     default: {
       status: {
         type: "active",
+        features: [{ id: "blockchain_txs", status: "active" }],
       },
       node: {
         url: getEnv("API_SUI_NODE_PROXY"),

package/src/families/sui/descriptor.ts

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

package/src/families/tezos/config.ts

@@ -7,6 +7,10 @@ export const tezosConfig: Record<string, ConfigInfo> = {
     default: {
       status: {
         type: "active",
+        features: [
+          { id: "blockchain_txs", status: "active" },
+          { id: "staking_txs", status: "active" },
+        ],
       },
       baker: {
         url: getEnv("API_TEZOS_BAKER"),

package/src/families/tezos/descriptor.ts

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

package/src/families/ton/config.ts

@@ -5,7 +5,10 @@ const tonConfig: CurrencyLiveConfigDefinition = {
   config_currency_ton: {
     type: "object",
     default: {
-      status: { type: "active" },
+      status: {
+        type: "active",
+        features: [{ id: "blockchain_txs", status: "active" }],
+      },
       infra: {
         API_TON_ENDPOINT: "https://ton.coin.ledger.com/api/v3",
         KNOWN_JETTONS,

package/src/families/ton/descriptor.ts

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

package/src/families/tron/config.ts

@@ -7,6 +7,10 @@ export const tronConfig: Record<string, ConfigInfo> = {
     default: {
       status: {
         type: "active",
+        features: [
+          { id: "blockchain_txs", status: "active" },
+          { id: "staking_txs", status: "active" },
+        ],
       },
       explorer: {
         url: getEnv("API_TRONGRID_PROXY"),

package/src/families/tron/descriptor.ts

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

package/src/families/vechain/config.ts

@@ -4,7 +4,10 @@ const vechainConfig: CurrencyLiveConfigDefinition = {
   config_currency_vechain: {
     type: "object",
     default: {
-      status: { type: "active" },
+      status: {
+        type: "active",
+        features: [{ id: "blockchain_txs", status: "active" }],
+      },
       infra: {
         API_VECHAIN_THOREST: "https://vechain.coin.ledger.com",
       },

package/src/families/vechain/descriptor.ts

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

package/src/families/xrp/config.ts

@@ -7,6 +7,7 @@ export const xrpConfig: CurrencyLiveConfigDefinition = {
     default: {
       status: {
         type: "active",
+        features: [{ id: "blockchain_txs", status: "active" }],
       },
       node: "https://xrp.coin.ledger.com",
     } as XrpCoinConfig,

package/src/families/xrp/descriptor.ts

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

package/src/featureFlags/defaultFeatures.ts

@@ -740,6 +740,14 @@ export const DEFAULT_FEATURES: Features = {
   lldRebornABtest: DEFAULT_FEATURE,
   llmRebornABtest: DEFAULT_FEATURE,
   lifiSolana: DEFAULT_FEATURE,
+
+  llmAnimatedSplashScreen: {
+    enabled: true,
+    params: {
+      ios: true,
+      android: true,
+    },
+  },
 };
 
 // Firebase SDK treat JSON values as strings

package/src/hw/connectApp.ts

@@ -555,7 +555,7 @@ export default function connectAppFactory(
       const deviceAction = new ConnectAppDeviceAction({
         input: {
           application: appNameToDependency(appName),
-          dependencies: dependencies ? dependencies.map(name => ({ name })) : [],
+          dependencies: dependencies ? dependencies.map(name => appNameToDependency(name)) : [],
           requireLatestFirmware,
           allowMissingApplication: allowPartialDependencies,
           unlockTimeout: 0, // Expect to fail immediately when device is locked

package/src/modularDrawer/hooks/useCurrenciesUnderFeatureFlag.ts

@@ -117,7 +117,7 @@ export function useCurrenciesUnderFeatureFlag() {
       syscoin,
       internet_computer: internetComputer,
       telos_evm: telosEvm,
-      sei_network_evm: seiNetworkEvm,
+      sei_evm: seiNetworkEvm,
       berachain: berachain,
       hyperevm: hyperevm,
       coreum,

package/src/wallet-api/logic.ts

@@ -89,24 +89,25 @@ export async function signTransactionLogic(
   ) => Promise<SignedOperation>,
   tokenCurrency?: string,
   isEmbeddedSwap?: boolean,
+  partner?: string,
 ): Promise<SignedOperation> {
-  tracking.signTransactionRequested(manifest, isEmbeddedSwap);
+  tracking.signTransactionRequested(manifest, isEmbeddedSwap, partner);
 
   if (!transaction) {
-    tracking.signTransactionFail(manifest, isEmbeddedSwap);
+    tracking.signTransactionFail(manifest, isEmbeddedSwap, partner);
     throw new Error("Transaction required");
   }
 
   const accountId = getAccountIdFromWalletAccountId(walletAccountId);
   if (!accountId) {
-    tracking.signTransactionFail(manifest, isEmbeddedSwap);
+    tracking.signTransactionFail(manifest, isEmbeddedSwap, partner);
     throw new Error(`accountId ${walletAccountId} unknown`);
   }
 
   const account = accounts.find(account => account.id === accountId);
 
   if (!account) {
-    tracking.signTransactionFail(manifest, isEmbeddedSwap);
+    tracking.signTransactionFail(manifest, isEmbeddedSwap, partner);
     throw new Error("Account required");
   }
 

package/src/wallet-api/react.ts

@@ -808,10 +808,11 @@ export function useWalletAPIServer({
       "transaction.signAndBroadcast",
       async ({ accountId, tokenCurrency, transaction, options, meta }) => {
         const sponsored = transaction.family === "ethereum" && transaction.sponsored;
-        // isEmbedded is passed via meta (not transaction) as it's a tracking param, not a tx property
+        // isEmbedded and partner are passed via meta (not transaction) as they're tracking params, not tx properties
         const isEmbeddedSwap =
           transaction.family === "ethereum" &&
           (meta as { isEmbedded?: boolean } | undefined)?.isEmbedded;
+        const partner = (meta as { partner?: string } | undefined)?.partner;
 
         const signedTransaction = await signTransactionLogic(
           { manifest, accounts, tracking },
@@ -828,19 +829,20 @@ export function useWalletAPIServer({
                 onSuccess: signedOperation => {
                   if (done) return;
                   done = true;
-                  tracking.signTransactionSuccess(manifest, isEmbeddedSwap);
+                  tracking.signTransactionSuccess(manifest, isEmbeddedSwap, partner);
                   resolve(signedOperation);
                 },
                 onError: error => {
                   if (done) return;
                   done = true;
-                  tracking.signTransactionFail(manifest, isEmbeddedSwap);
+                  tracking.signTransactionFail(manifest, isEmbeddedSwap, partner);
                   reject(error);
                 },
               });
             }),
           tokenCurrency,
           isEmbeddedSwap,
+          partner,
         );
 
         return broadcastTransactionLogic(
@@ -863,9 +865,9 @@ export function useWalletAPIServer({
                     sponsored,
                   },
                 });
-                tracking.broadcastSuccess(manifest, isEmbeddedSwap);
+                tracking.broadcastSuccess(manifest, isEmbeddedSwap, partner);
               } catch (error) {
-                tracking.broadcastFail(manifest, isEmbeddedSwap);
+                tracking.broadcastFail(manifest, isEmbeddedSwap, partner);
                 throw error;
               }
             }

package/src/wallet-api/tracking.test.ts

@@ -130,6 +130,35 @@ describe("trackingWrapper", () => {
   );
 });
 
+describe("trackingWrapper with optional tracking params", () => {
+  test.each([
+    { method: "signTransactionRequested", message: "WalletAPI SignTransaction" },
+    { method: "signTransactionFail", message: "WalletAPI SignTransaction Fail" },
+    { method: "signTransactionSuccess", message: "WalletAPI SignTransaction Success" },
+    { method: "broadcastFail", message: "WalletAPI Broadcast Fail" },
+    { method: "broadcastSuccess", message: "WalletAPI Broadcast Success" },
+  ])("$method includes isEmbeddedSwap and partner when provided", ({ method, message }) => {
+    // Given
+    const appManifest = appManifestFixture();
+    const mockedTrack = jest.fn();
+
+    // When
+    trackingWrapper(mockedTrack)[method](appManifest, true, "uniswap");
+
+    // Then
+    expect(mockedTrack).toHaveBeenCalledTimes(1);
+    expect(mockedTrack).toHaveBeenCalledWith(
+      message,
+      {
+        walletAPI: appManifest.name,
+        isEmbeddedSwap: "true",
+        partner: "uniswap",
+      },
+      null,
+    );
+  });
+});
+
 function appManifestFixture(name = "live-app"): AppManifest {
   return {
     id: "12",

package/src/wallet-api/tracking.ts

@@ -56,28 +56,35 @@ export default function trackingWrapper(trackCall: TrackWalletAPI) {
     },
 
     // Sign transaction modal open
-    signTransactionRequested: (manifest: AppManifest, isEmbeddedSwap?: boolean) => {
+    signTransactionRequested: (
+      manifest: AppManifest,
+      isEmbeddedSwap?: boolean,
+      partner?: string,
+    ) => {
       const properties = {
         ...getEventData(manifest),
         ...(isEmbeddedSwap !== undefined && { isEmbeddedSwap: String(isEmbeddedSwap) }),
+        ...(partner !== undefined && { partner }),
       };
       track("WalletAPI SignTransaction", properties);
     },
 
     // Failed to sign transaction (cancel or error)
-    signTransactionFail: (manifest: AppManifest, isEmbeddedSwap?: boolean) => {
+    signTransactionFail: (manifest: AppManifest, isEmbeddedSwap?: boolean, partner?: string) => {
       const properties = {
         ...getEventData(manifest),
         ...(isEmbeddedSwap !== undefined && { isEmbeddedSwap: String(isEmbeddedSwap) }),
+        ...(partner !== undefined && { partner }),
       };
       track("WalletAPI SignTransaction Fail", properties);
     },
 
     // Successfully signed transaction
-    signTransactionSuccess: (manifest: AppManifest, isEmbeddedSwap?: boolean) => {
+    signTransactionSuccess: (manifest: AppManifest, isEmbeddedSwap?: boolean, partner?: string) => {
       const properties = {
         ...getEventData(manifest),
         ...(isEmbeddedSwap !== undefined && { isEmbeddedSwap: String(isEmbeddedSwap) }),
+        ...(partner !== undefined && { partner }),
       };
       track("WalletAPI SignTransaction Success", properties);
     },
@@ -128,19 +135,21 @@ export default function trackingWrapper(trackCall: TrackWalletAPI) {
     },
 
     // Failed to broadcast a signed transaction
-    broadcastFail: (manifest: AppManifest, isEmbeddedSwap?: boolean) => {
+    broadcastFail: (manifest: AppManifest, isEmbeddedSwap?: boolean, partner?: string) => {
       const properties = {
         ...getEventData(manifest),
         ...(isEmbeddedSwap !== undefined && { isEmbeddedSwap: String(isEmbeddedSwap) }),
+        ...(partner !== undefined && { partner }),
       };
       track("WalletAPI Broadcast Fail", properties);
     },
 
     // Successfully broadcast a signed transaction
-    broadcastSuccess: (manifest: AppManifest, isEmbeddedSwap?: boolean) => {
+    broadcastSuccess: (manifest: AppManifest, isEmbeddedSwap?: boolean, partner?: string) => {
       const properties = {
         ...getEventData(manifest),
         ...(isEmbeddedSwap !== undefined && { isEmbeddedSwap: String(isEmbeddedSwap) }),
+        ...(partner !== undefined && { partner }),
       };
       track("WalletAPI Broadcast Success", properties);
     },