@ledgerhq/live-common 34.54.0-nightly.20251205111238 → 34.54.0-nightly.20251209023841

package/src/domain/getTotalStakeableAssets.test.ts

@@ -0,0 +1,267 @@
+import { genAccount } from "@ledgerhq/coin-framework/lib/mocks/account";
+import { getCryptoCurrencyById } from "../currencies/index";
+import { Account } from "@ledgerhq/types-live";
+import type { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import BigNumber from "bignumber.js";
+import { getTotalStakeableAssets } from "./getTotalStakeableAssets";
+import { setupMockCryptoAssetsStore } from "@ledgerhq/cryptoassets/cal-client/test-helpers";
+
+// Setup mock store for unit tests
+setupMockCryptoAssetsStore();
+
+const ETH = getCryptoCurrencyById("ethereum");
+const BTC = getCryptoCurrencyById("bitcoin");
+
+// Create mock tokens for tests
+const ZRX_TOKEN: TokenCurrency = {
+  type: "TokenCurrency",
+  id: "ethereum/erc20/0x_project",
+  contractAddress: "0xE41d2489571d322189246DaFA5ebDe1F4699F498",
+  parentCurrency: ETH,
+  tokenType: "erc20",
+  name: "0x Project",
+  ticker: "ZRX",
+  delisted: false,
+  disableCountervalue: false,
+  units: [{ name: "ZRX", code: "ZRX", magnitude: 18 }],
+};
+
+const REP_TOKEN: TokenCurrency = {
+  type: "TokenCurrency",
+  id: "ethereum/erc20/augur",
+  contractAddress: "0x1985365e9f78359a9B6AD760e32412f4a445E862",
+  parentCurrency: ETH,
+  tokenType: "erc20",
+  name: "Augur",
+  ticker: "REP",
+  delisted: false,
+  disableCountervalue: false,
+  units: [{ name: "REP", code: "REP", magnitude: 18 }],
+};
+
+const mockedAccounts: Account[] = [
+  genAccount("mocked-account-1", {
+    currency: ETH,
+    tokensData: [ZRX_TOKEN, REP_TOKEN],
+  }),
+];
+
+describe("getTotalStakeableAssets", () => {
+  it("should return empty Set if no accounts", () => {
+    const result = getTotalStakeableAssets([], [], []);
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(0);
+    expect(result.stakeableAssets).toEqual([]);
+  });
+
+  it("should return empty Set if accounts is null", () => {
+    const result = getTotalStakeableAssets(null, [], []);
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(0);
+    expect(result.stakeableAssets).toEqual([]);
+  });
+
+  it("should return empty Set if accounts is undefined", () => {
+    const result = getTotalStakeableAssets(undefined, [], []);
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(0);
+    expect(result.stakeableAssets).toEqual([]);
+  });
+
+  it("should return empty Set if no staking currencies enabled", () => {
+    const result = getTotalStakeableAssets(mockedAccounts, [], []);
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(0);
+    expect(result.stakeableAssets).toEqual([]);
+  });
+
+  it("should return Set with matching currency ID when staking currency is enabled", () => {
+    const account = mockedAccounts[0];
+    const stakingCurrenciesEnabled = [ETH.id]; // "ethereum"
+
+    expect(account.balance).toBeTruthy();
+    expect(account.balance instanceof BigNumber).toBe(true);
+    expect(account.balance.gt(0)).toBe(true);
+
+    const result = getTotalStakeableAssets([account], stakingCurrenciesEnabled, []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(1);
+    expect(result.combinedIds.has(ETH.id)).toBe(true);
+    expect(result.stakeableAssets.length).toBe(1);
+    expect(result.stakeableAssets[0]).toEqual({
+      ticker: ETH.ticker,
+      networkName: ETH.name,
+      id: ETH.id,
+    });
+  });
+
+  it("should return Set with matching token IDs when staking tokens are enabled", () => {
+    const account = mockedAccounts[0];
+    const stakingCurrenciesEnabled = [ZRX_TOKEN.id, REP_TOKEN.id];
+
+    expect(account.subAccounts).toBeDefined();
+    expect(account.subAccounts?.length).toBe(2);
+
+    const result = getTotalStakeableAssets([account], stakingCurrenciesEnabled, []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(2);
+    expect(result.combinedIds.has(ZRX_TOKEN.id)).toBe(true);
+    expect(result.combinedIds.has(REP_TOKEN.id)).toBe(true);
+    expect(result.stakeableAssets.length).toBe(2);
+    expect(result.stakeableAssets).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: ZRX_TOKEN.id, ticker: ZRX_TOKEN.ticker }),
+        expect.objectContaining({ id: REP_TOKEN.id, ticker: REP_TOKEN.ticker }),
+      ]),
+    );
+  });
+
+  it("should return Set with both currency and token IDs when both are enabled", () => {
+    const account = mockedAccounts[0];
+    const stakingCurrenciesEnabled = [ETH.id, ZRX_TOKEN.id, REP_TOKEN.id];
+
+    const result = getTotalStakeableAssets([account], stakingCurrenciesEnabled, []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(3);
+    expect(result.combinedIds.has(ETH.id)).toBe(true);
+    expect(result.combinedIds.has(ZRX_TOKEN.id)).toBe(true);
+    expect(result.combinedIds.has(REP_TOKEN.id)).toBe(true);
+    expect(result.stakeableAssets.length).toBe(3);
+    expect(result.stakeableAssets).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: ETH.id, ticker: ETH.ticker }),
+        expect.objectContaining({ id: ZRX_TOKEN.id, ticker: ZRX_TOKEN.ticker }),
+        expect.objectContaining({ id: REP_TOKEN.id, ticker: REP_TOKEN.ticker }),
+      ]),
+    );
+  });
+
+  it("should filter out currencies without funds", () => {
+    const account = mockedAccounts[0];
+    const accountWithZeroBalance = { ...account, balance: new BigNumber(0) };
+    const stakingCurrenciesEnabled = [ETH.id];
+
+    const result = getTotalStakeableAssets([accountWithZeroBalance], stakingCurrenciesEnabled, []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(0);
+    expect(result.stakeableAssets).toEqual([]);
+  });
+
+  it("should filter out tokens without funds", () => {
+    const account = mockedAccounts[0];
+    const [zrxAccount, repAccount] = account.subAccounts || [];
+    const emptyRepAccount = { ...repAccount, balance: new BigNumber(0) };
+    const accountWithEmptyToken = { ...account, subAccounts: [zrxAccount, emptyRepAccount] };
+    const stakingCurrenciesEnabled = [ZRX_TOKEN.id, REP_TOKEN.id];
+
+    const result = getTotalStakeableAssets([accountWithEmptyToken], stakingCurrenciesEnabled, []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(1);
+    expect(result.combinedIds.has(ZRX_TOKEN.id)).toBe(true);
+    expect(result.combinedIds.has(REP_TOKEN.id)).toBe(false);
+    expect(result.stakeableAssets.length).toBe(1);
+    expect(result.stakeableAssets[0]).toEqual(
+      expect.objectContaining({ id: ZRX_TOKEN.id, ticker: ZRX_TOKEN.ticker }),
+    );
+  });
+
+  it("should include partner staking currencies enabled", () => {
+    const account = mockedAccounts[0];
+    const stakingCurrenciesEnabled = [ETH.id];
+    const partnerStakingCurrenciesEnabled = [ZRX_TOKEN.id];
+
+    const result = getTotalStakeableAssets(
+      [account],
+      stakingCurrenciesEnabled,
+      partnerStakingCurrenciesEnabled,
+    );
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(2);
+    expect(result.combinedIds.has(ETH.id)).toBe(true);
+    expect(result.combinedIds.has(ZRX_TOKEN.id)).toBe(true);
+    expect(result.stakeableAssets.length).toBe(2);
+    expect(result.stakeableAssets).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: ETH.id, ticker: ETH.ticker }),
+        expect.objectContaining({ id: ZRX_TOKEN.id, ticker: ZRX_TOKEN.ticker }),
+      ]),
+    );
+  });
+
+  it("should deduplicate IDs when same currency appears in both lists", () => {
+    const account = mockedAccounts[0];
+    const stakingCurrenciesEnabled = [ETH.id];
+    const partnerStakingCurrenciesEnabled = [ETH.id]; // Same currency
+
+    const result = getTotalStakeableAssets(
+      [account],
+      stakingCurrenciesEnabled,
+      partnerStakingCurrenciesEnabled,
+    );
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(1);
+    expect(result.combinedIds.has(ETH.id)).toBe(true);
+    expect(result.stakeableAssets.length).toBe(1);
+    expect(result.stakeableAssets[0]).toEqual({
+      ticker: ETH.ticker,
+      networkName: ETH.name,
+      id: ETH.id,
+    });
+  });
+
+  it("should handle multiple accounts with different currencies", () => {
+    const ethAccount = mockedAccounts[0];
+    const btcAccount = genAccount("mocked-account-2", {
+      currency: BTC,
+    });
+    const accounts = [ethAccount, btcAccount];
+    const stakingCurrenciesEnabled = [ETH.id, BTC.id];
+
+    const result = getTotalStakeableAssets(accounts, stakingCurrenciesEnabled, []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(2);
+    expect(result.combinedIds.has(ETH.id)).toBe(true);
+    expect(result.combinedIds.has(BTC.id)).toBe(true);
+    expect(result.stakeableAssets.length).toBe(2);
+    expect(result.stakeableAssets).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: ETH.id, ticker: ETH.ticker }),
+        expect.objectContaining({ id: BTC.id, ticker: BTC.ticker }),
+      ]),
+    );
+  });
+
+  it("should only include IDs that match staking currencies enabled", () => {
+    const account = mockedAccounts[0];
+    const stakingCurrenciesEnabled = [ZRX_TOKEN.id]; // Only ZRX enabled, not ETH or REP
+
+    const result = getTotalStakeableAssets([account], stakingCurrenciesEnabled, []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(1);
+    expect(result.combinedIds.has(ZRX_TOKEN.id)).toBe(true);
+    expect(result.combinedIds.has(ETH.id)).toBe(false);
+    expect(result.combinedIds.has(REP_TOKEN.id)).toBe(false);
+    expect(result.stakeableAssets.length).toBe(1);
+    expect(result.stakeableAssets[0]).toEqual(
+      expect.objectContaining({ id: ZRX_TOKEN.id, ticker: ZRX_TOKEN.ticker }),
+    );
+  });
+
+  it("should handle empty arrays for staking currencies", () => {
+    const account = mockedAccounts[0];
+    const result = getTotalStakeableAssets([account], [], []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(0);
+    expect(result.stakeableAssets).toEqual([]);
+  });
+});

package/src/domain/getTotalStakeableAssets.ts

@@ -0,0 +1,47 @@
+import { getTokensWithFundsMap } from "./getTokensWithFunds";
+import { Account } from "@ledgerhq/types-live";
+
+export function getTotalStakeableAssets(
+  accounts: Account[] | null | undefined,
+  stakingCurrenciesEnabled: string[],
+  partnerStakingCurrenciesEnabled: string[],
+): {
+  combinedIds: Set<string>;
+  stakeableAssets: { ticker: string; networkName: string; id: string }[];
+} {
+  if (!accounts) return { combinedIds: new Set<string>(), stakeableAssets: [] };
+
+  const accountsWithFundsCurrencies = accounts
+    .filter(account => account?.balance.isGreaterThan(0))
+    .map(account => account?.currency);
+
+  const allStakingCurrenciesEnabled = new Set([
+    ...stakingCurrenciesEnabled,
+    ...partnerStakingCurrenciesEnabled,
+  ]);
+
+  const tokenWithFundsMap = getTokensWithFundsMap(accounts);
+  const filteredAccountCurrencyIds = [...accountsWithFundsCurrencies].filter(currency =>
+    allStakingCurrenciesEnabled.has(currency.id),
+  );
+  const filteredTokenWithFunds = [...tokenWithFundsMap.values()].filter(token =>
+    allStakingCurrenciesEnabled.has(token.id),
+  );
+
+  const combined = new Map<string, { ticker: string; networkName: string; id: string }>();
+  for (const currency of filteredAccountCurrencyIds) {
+    combined.set(currency.id, {
+      ticker: currency.ticker,
+      networkName: currency.name,
+      id: currency.id,
+    });
+  }
+  for (const token of filteredTokenWithFunds) {
+    combined.set(token.id, token);
+  }
+
+  return {
+    combinedIds: new Set(Array.from(combined.values(), details => details.id)),
+    stakeableAssets: Array.from(combined.values()),
+  };
+}

package/src/exchange/swap/api/v5/fetchCurrencyFrom.ts

@@ -45,7 +45,7 @@ export async function fetchCurrencyFrom({
       ...(headers !== undefined ? { headers } : {}),
     });
     return flattenV5CurrenciesToAndFrom(data);
-  } catch (e) {
+  } catch {
     throw Error("Something went wrong in fetchCurrencyFrom call");
   }
 }

package/src/featureFlags/defaultFeatures.ts

@@ -734,6 +734,8 @@ export const DEFAULT_FEATURES: Features = {
   },
   zcashShielded: DEFAULT_FEATURE,
   llmNanoOnboardingFundWallet: DEFAULT_FEATURE,
+  lldRebornABtest: DEFAULT_FEATURE,
+  llmRebornABtest: DEFAULT_FEATURE,
 };
 
 // Firebase SDK treat JSON values as strings

package/src/featureFlags/firebaseFeatureFlags.ts

@@ -59,7 +59,7 @@ export const isFeature = (key: string): boolean => {
       return false;
     }
     return true;
-  } catch (error) {
+  } catch {
     console.error(`Failed to check if feature "${key}" exists`);
     return false;
   }

package/src/featureFlags/useHasOverriddenFeatureFlags.ts

@@ -15,7 +15,7 @@ export function useHasLocallyOverriddenFeatureFlags(): boolean {
         try {
           const val = getFeature(featureId as FeatureId);
           return val?.overridesRemote || val?.overriddenByEnv;
-        } catch (e) {
+        } catch {
           return false;
         }
       }),

package/src/hw/getBitcoinLikeInfo.ts

@@ -26,7 +26,7 @@ const getBitcoinLikeInfo = (
         message,
         short,
       };
-    } catch (e) {
+    } catch {
       // in such case, we are in an old firmware we no longer support
       return null;
     }

package/src/mock/account.ts

@@ -199,7 +199,7 @@ export function genAccount(id: number | string, opts: GenAccountOptions = {}): A
             if (initAccount) {
               initAccount(account);
             }
-          } catch (e: any) {
+          } catch {
             // to fix /src/__tests__/cross.ts, skip bridge error if there is no bridge in such currency
           }
         }

package/src/wallet-api/Exchange/server.ts

@@ -390,11 +390,13 @@ export const handlers = ({
         customFeeConfig,
         swapAppVersion,
         sponsored,
+        isEmbedded,
       } = params;
 
       const trackingParams = {
         provider: params.provider,
         exchangeType: params.exchangeType,
+        isEmbeddedSwap: isEmbedded,
       };
 
       tracking.startExchangeRequested(trackingParams);
@@ -472,6 +474,7 @@ export const handlers = ({
       const trackingCompleteParams = {
         provider: params.provider,
         exchangeType: params.exchangeType,
+        isEmbeddedSwap: isEmbedded,
       };
       tracking.completeExchangeRequested(trackingCompleteParams);
 

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

@@ -14,8 +14,15 @@ type TrackExchange = (
 interface TrackEventPayload {
   exchangeType: "SELL" | "FUND" | "SWAP";
   provider: string;
+  isEmbeddedSwap?: boolean;
 }
 
+/**
+ * Converts isEmbeddedSwap boolean to string for analytics consistency
+ */
+const formatIsEmbeddedSwap = (isEmbeddedSwap?: boolean): string | undefined =>
+  isEmbeddedSwap !== undefined ? String(isEmbeddedSwap) : undefined;
+
 function getEventData(manifest: AppManifest) {
   return { walletAPI: manifest.name };
 }
@@ -29,24 +36,46 @@ function getEventData(manifest: AppManifest) {
 // in order to get the exact type matching the tracking wrapper API
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
 export default function trackingWrapper(trackCall: TrackExchange) {
-  const track = (event: string, properties: Record<string, string> | null) => {
-    return trackCall(event, properties, null);
+  const track = (event: string, properties: Record<string, string | undefined> | null) => {
+    // Filter out undefined values before passing to trackCall
+    if (!properties) {
+      return trackCall(event, null, null);
+    }
+    const filteredProperties: Record<string, string> = {};
+    for (const [key, value] of Object.entries(properties)) {
+      if (value !== undefined) {
+        filteredProperties[key] = value;
+      }
+    }
+    return trackCall(event, filteredProperties, null);
   };
 
   return {
     // Generate Exchange nonce modal open
-    startExchangeRequested: ({ provider, exchangeType }: TrackEventPayload) => {
-      track(`Starts Exchange ${exchangeType} Nonce request`, { provider, exchangeType });
+    startExchangeRequested: ({ provider, exchangeType, isEmbeddedSwap }: TrackEventPayload) => {
+      track(`Starts Exchange ${exchangeType} Nonce request`, {
+        provider,
+        exchangeType,
+        isEmbeddedSwap: formatIsEmbeddedSwap(isEmbeddedSwap),
+      });
     },
 
     // Successfully generated an Exchange app nonce
-    startExchangeSuccess: ({ provider, exchangeType }: TrackEventPayload) => {
-      track(`Starts Exchange ${exchangeType} Nonce success`, { provider, exchangeType });
+    startExchangeSuccess: ({ provider, exchangeType, isEmbeddedSwap }: TrackEventPayload) => {
+      track(`Starts Exchange ${exchangeType} Nonce success`, {
+        provider,
+        exchangeType,
+        isEmbeddedSwap: formatIsEmbeddedSwap(isEmbeddedSwap),
+      });
     },
 
     // Failed to generate an Exchange app nonce
-    startExchangeFail: ({ provider, exchangeType }: TrackEventPayload) => {
-      track(`Starts Exchange ${exchangeType} Nonce fail`, { provider, exchangeType });
+    startExchangeFail: ({ provider, exchangeType, isEmbeddedSwap }: TrackEventPayload) => {
+      track(`Starts Exchange ${exchangeType} Nonce fail`, {
+        provider,
+        exchangeType,
+        isEmbeddedSwap: formatIsEmbeddedSwap(isEmbeddedSwap),
+      });
     },
 
     // No Params to generate an Exchange app nonce
@@ -54,8 +83,12 @@ export default function trackingWrapper(trackCall: TrackExchange) {
       track("Starts Exchange no params", getEventData(manifest));
     },
 
-    completeExchangeRequested: ({ provider, exchangeType }: TrackEventPayload) => {
-      track(`Completes Exchange ${exchangeType} requested`, { provider, exchangeType });
+    completeExchangeRequested: ({ provider, exchangeType, isEmbeddedSwap }: TrackEventPayload) => {
+      track(`Completes Exchange ${exchangeType} requested`, {
+        provider,
+        exchangeType,
+        isEmbeddedSwap: formatIsEmbeddedSwap(isEmbeddedSwap),
+      });
     },
 
     // Successfully completed an Exchange
@@ -63,13 +96,23 @@ export default function trackingWrapper(trackCall: TrackExchange) {
       provider,
       exchangeType,
       currency,
+      isEmbeddedSwap,
     }: TrackEventPayload & { currency: string }) => {
-      track(`Completes Exchange ${exchangeType} success`, { provider, exchangeType, currency });
+      track(`Completes Exchange ${exchangeType} success`, {
+        provider,
+        exchangeType,
+        currency,
+        isEmbeddedSwap: formatIsEmbeddedSwap(isEmbeddedSwap),
+      });
     },
 
     // Failed to complete an Exchange
-    completeExchangeFail: ({ provider, exchangeType }: TrackEventPayload) => {
-      track(`Completes Exchange ${exchangeType} Nonce fail`, { provider, exchangeType });
+    completeExchangeFail: ({ provider, exchangeType, isEmbeddedSwap }: TrackEventPayload) => {
+      track(`Completes Exchange ${exchangeType} Nonce fail`, {
+        provider,
+        exchangeType,
+        isEmbeddedSwap: formatIsEmbeddedSwap(isEmbeddedSwap),
+      });
     },
 
     // No Params to complete an Exchange

package/src/wallet-api/logic.ts

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

package/src/wallet-api/react.ts

@@ -806,8 +806,12 @@ export function useWalletAPIServer({
 
     server.setHandler(
       "transaction.signAndBroadcast",
-      async ({ accountId, tokenCurrency, transaction, options }) => {
+      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
+        const isEmbeddedSwap =
+          transaction.family === "ethereum" &&
+          (meta as { isEmbedded?: boolean } | undefined)?.isEmbedded;
 
         const signedTransaction = await signTransactionLogic(
           { manifest, accounts, tracking },
@@ -824,18 +828,19 @@ export function useWalletAPIServer({
                 onSuccess: signedOperation => {
                   if (done) return;
                   done = true;
-                  tracking.signTransactionSuccess(manifest);
+                  tracking.signTransactionSuccess(manifest, isEmbeddedSwap);
                   resolve(signedOperation);
                 },
                 onError: error => {
                   if (done) return;
                   done = true;
-                  tracking.signTransactionFail(manifest);
+                  tracking.signTransactionFail(manifest, isEmbeddedSwap);
                   reject(error);
                 },
               });
             }),
           tokenCurrency,
+          isEmbeddedSwap,
         );
 
         return broadcastTransactionLogic(
@@ -858,9 +863,9 @@ export function useWalletAPIServer({
                     sponsored,
                   },
                 });
-                tracking.broadcastSuccess(manifest);
+                tracking.broadcastSuccess(manifest, isEmbeddedSwap);
               } catch (error) {
-                tracking.broadcastFail(manifest);
+                tracking.broadcastFail(manifest, isEmbeddedSwap);
                 throw error;
               }
             }

package/src/wallet-api/tracking.ts

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