@ledgerhq/live-common 34.49.0-nightly.3 → 34.49.0-nightly.5

package/src/bridge/syncSessionManager/index.test.ts

@@ -0,0 +1,151 @@
+import { createSyncSessionManager } from ".";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import { setSupportedCurrencies } from "../../currencies";
+import { genAccount } from "../../mock/account";
+
+jest.mock("@ledgerhq/logs", () => ({
+  log: jest.fn(),
+}));
+
+setSupportedCurrencies(["bitcoin", "ethereum"]);
+
+describe("syncSessionManager", () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+    jest.useRealTimers();
+  });
+
+  test("tracks SyncSuccessAllAccounts with correct aggregates when all accounts complete", () => {
+    const trackAnalytics = jest.fn();
+    const session = createSyncSessionManager(trackAnalytics);
+
+    const BTC = getCryptoCurrencyById("bitcoin");
+    const ETH = getCryptoCurrencyById("ethereum");
+    const a1 = genAccount("a1", { currency: BTC, operationsSize: 3 });
+    const a2 = genAccount("a2", { currency: BTC, operationsSize: 5 });
+    const a3 = genAccount("a3", { currency: ETH, operationsSize: 7 });
+    const accounts = [a1, a2, a3];
+
+    const nowSpy = jest
+      .spyOn(Date, "now")
+      // start time
+      .mockReturnValueOnce(1_000)
+      // end time (when last account completes)
+      .mockReturnValueOnce(5_000);
+
+    session.start(["a1", "a2", "a3"], "initial");
+
+    // Completing accounts one by one should only trigger analytics on last one
+    session.onAccountSyncDone("a1", accounts);
+    expect(trackAnalytics).not.toHaveBeenCalled();
+
+    session.onAccountSyncDone("a2", accounts);
+    expect(trackAnalytics).not.toHaveBeenCalled();
+
+    session.onAccountSyncDone("a3", accounts);
+
+    expect(trackAnalytics).toHaveBeenCalledTimes(1);
+    expect(trackAnalytics).toHaveBeenCalledWith(
+      "SyncSuccessAllAccounts",
+      expect.objectContaining({
+        duration: 4, // (5000 - 1000) / 1000
+        accountsCount: accounts.length,
+        operationsCount: a1.operationsCount + a2.operationsCount + a3.operationsCount,
+        chains: ["Bitcoin", "Ethereum"],
+        reason: "initial",
+      }),
+    );
+
+    nowSpy.mockRestore();
+  });
+
+  test("ignores subsequent 'initial' sessions after the first completion", () => {
+    const trackAnalytics = jest.fn();
+    const session = createSyncSessionManager(trackAnalytics);
+
+    const BTC = getCryptoCurrencyById("bitcoin");
+    const ETH = getCryptoCurrencyById("ethereum");
+    const a1 = genAccount("a1", { currency: BTC });
+    const a2 = genAccount("a2", { currency: ETH });
+    a1.operationsCount = 2;
+    a2.operationsCount = 1;
+    const accounts = [a1, a2];
+
+    const nowSpy = jest
+      .spyOn(Date, "now")
+      .mockReturnValueOnce(10_000) // first start
+      .mockReturnValueOnce(14_000); // first completion
+
+    // First initial session completes => tracked once
+    session.start(["a1", "a2"], "initial");
+    session.onAccountSyncDone("a1", accounts);
+    session.onAccountSyncDone("a2", accounts);
+
+    expect(trackAnalytics).toHaveBeenCalledTimes(1);
+    expect(trackAnalytics.mock.calls[0][0]).toBe("SyncSuccessAllAccounts");
+
+    // Next initial session should be ignored entirely
+    session.start(["a1"], "initial");
+    session.onAccountSyncDone("a1", accounts);
+
+    expect(trackAnalytics).toHaveBeenCalledTimes(1);
+
+    nowSpy.mockRestore();
+  });
+
+  test("does nothing if onAccountSyncDone is called without a started session", () => {
+    const trackAnalytics = jest.fn();
+    const session = createSyncSessionManager(trackAnalytics);
+    const BTC = getCryptoCurrencyById("bitcoin");
+    const acc = genAccount("x1", { currency: BTC });
+    acc.operationsCount = 1;
+    const accounts = [acc];
+
+    session.onAccountSyncDone("x1", accounts);
+    expect(trackAnalytics).not.toHaveBeenCalled();
+  });
+  test("tracks SyncSuccessAllAccounts with correct aggregates when all accounts complete and errors", () => {
+    const trackAnalytics = jest.fn();
+    const session = createSyncSessionManager(trackAnalytics);
+
+    const BTC = getCryptoCurrencyById("bitcoin");
+    const ETH = getCryptoCurrencyById("ethereum");
+    const a1 = genAccount("a1", { currency: BTC, operationsSize: 3 });
+    const a2 = genAccount("a2", { currency: BTC, operationsSize: 5 });
+    const a3 = genAccount("a3", { currency: ETH, operationsSize: 7 });
+    const accounts = [a1, a2, a3];
+
+    const nowSpy = jest
+      .spyOn(Date, "now")
+      // start time
+      .mockReturnValueOnce(1_000)
+      // end time (when last account completes)
+      .mockReturnValueOnce(5_000);
+
+    session.start(["a1", "a2", "a3"], "initial");
+
+    // Completing accounts one by one should only trigger analytics on last one
+    session.onAccountSyncDone("a1", accounts);
+    expect(trackAnalytics).not.toHaveBeenCalled();
+
+    session.onAccountSyncDone("a2", accounts, true);
+    expect(trackAnalytics).not.toHaveBeenCalled();
+
+    session.onAccountSyncDone("a3", accounts, true);
+
+    expect(trackAnalytics).toHaveBeenCalledTimes(1);
+    expect(trackAnalytics).toHaveBeenCalledWith(
+      "SyncSuccessAllAccounts",
+      expect.objectContaining({
+        duration: 4, // (5000 - 1000) / 1000
+        accountsCount: accounts.length,
+        operationsCount: a1.operationsCount + a2.operationsCount + a3.operationsCount,
+        chains: ["Bitcoin", "Ethereum"],
+        reason: "initial",
+        syncWithErrors: 2,
+      }),
+    );
+
+    nowSpy.mockRestore();
+  });
+});

package/src/bridge/syncSessionManager/index.ts

@@ -0,0 +1,93 @@
+import { log } from "@ledgerhq/logs";
+import { Account } from "@ledgerhq/types-live";
+import { Props } from "../react/BridgeSync";
+
+type Session = {
+  reason: string;
+  startTime: number;
+  accountIds: string[];
+  remaining: Set<string>;
+  errorsCount: number;
+};
+
+// Session manager factory to track global sync sessions (Accounts)
+export function createSyncSessionManager(trackAnalytics: Props["trackAnalytics"]) {
+  let current: Session | null = null;
+
+  let hasTrackedInitial = false;
+
+  const start = (ids: string[], reason: string) => {
+    if (reason === "initial" && hasTrackedInitial) return;
+    current = {
+      reason,
+      startTime: Date.now(),
+      accountIds: ids,
+      remaining: new Set(ids),
+      errorsCount: 0,
+    };
+    logSyncSession("started", { reason, accounts: ids.length });
+  };
+
+  /**
+   *
+   * @param accountId - the account id that has completed sync
+   * @param accounts - the accounts that will be synced
+   * @param hadError - whether the account sync had an error
+   *
+   */
+  const onAccountSyncDone = (accountId: string, accounts: Account[], hadError = false) => {
+    if (!current) return;
+
+    current.remaining.delete(accountId);
+    if (hadError) {
+      current.errorsCount += 1;
+    }
+
+    if (current.remaining.size === 0) {
+      trackSessionAnalytics(trackAnalytics, current, accounts);
+
+      if (current.reason === "initial") {
+        hasTrackedInitial = true;
+      }
+      current = null;
+    }
+  };
+
+  return { start, onAccountSyncDone } as const;
+}
+
+export function getTotalOperations(accounts: Account[]): number {
+  return accounts.reduce((sum, acc) => sum + acc.operationsCount, 0);
+}
+
+export function getUniqueChains(accounts: Account[]): string[] {
+  return [...new Set(accounts.map(acc => acc.currency.name))];
+}
+
+export function trackSessionAnalytics(
+  trackAnalytics: Props["trackAnalytics"],
+  session: Session,
+  accounts: Account[],
+) {
+  const duration = (Date.now() - session.startTime) / 1000;
+  const totalOps = getTotalOperations(accounts);
+  const chains = getUniqueChains(accounts);
+
+  trackAnalytics("SyncSuccessAllAccounts", {
+    duration,
+    accountsCount: accounts.length,
+    operationsCount: totalOps,
+    chains,
+    reason: session.reason,
+    syncWithErrors: session.errorsCount,
+  });
+
+  logSyncSession("finished", { reason: session.reason, duration: `${duration}s` });
+}
+
+function logSyncSession(event: "started" | "finished", data: Record<string, string | number>) {
+  const serialized = Object.entries(data)
+    .map(([key, value]) => `${key}=${value}`)
+    .join(", ");
+  log("bridge", `SyncSession ${event} ${serialized}`);
+}

package/src/deposit/deposit.integration.test.ts

@@ -4,10 +4,49 @@
 import "../__tests__/test-helpers/setup";
 import { renderHook, waitFor } from "@testing-library/react";
 import { useGroupedCurrenciesByProvider } from ".";
-import { GroupedCurrencies, LoadingBasedGroupedCurrencies } from "./type";
-// Explicitly mock the featureFlags module
+import { GroupedCurrencies, LoadingBasedGroupedCurrencies, MappedAsset } from "./type";
+import * as api from "./api";
+
+// Mock the API module
+jest.mock("./api");
+const mockGetMappedAssets = api.getMappedAssets as jest.MockedFunction<typeof api.getMappedAssets>;
+
+// Create mock data for testing
+const mockMappedAssets: MappedAsset[] = [
+  {
+    $type: "Coin",
+    ledgerId: "bitcoin",
+    providerId: "coingecko",
+    name: "Bitcoin",
+    ticker: "BTC",
+    status: "active",
+    reason: null,
+    data: {
+      img: "https://crypto-icons.example.com/bitcoin.png",
+      marketCapRank: 1,
+    },
+  },
+  {
+    $type: "Coin",
+    ledgerId: "ethereum",
+    providerId: "coingecko",
+    name: "Ethereum",
+    ticker: "ETH",
+    status: "active",
+    reason: null,
+    data: {
+      img: "https://crypto-icons.example.com/ethereum.png",
+      marketCapRank: 2,
+    },
+  },
+];
 
 describe("useGroupedCurrenciesByProvider", () => {
+  beforeEach(() => {
+    // Mock the API call to return our test data
+    mockGetMappedAssets.mockResolvedValue(mockMappedAssets);
+  });
+
   afterEach(() => {
     jest.clearAllMocks();
   });

package/src/e2e/data/deviceLabelsData.ts

@@ -54,7 +54,7 @@ export const DEVICE_LABELS_CONFIG: DeviceLabelsConfig = {
       [AppInfos.MULTIVERS_X.name]: DeviceLabels.SIGN,
       [AppInfos.NEAR.name]: DeviceLabels.CONTINUE_TO_ACTION,
       [AppInfos.SOLANA.name]: DeviceLabels.APPROVE,
-      [AppInfos.TEZOS.name]: DeviceLabels.ACCEPT_AND_SEND,
+      [AppInfos.TEZOS.name]: DeviceLabels.ACCEPT_RISK,
       default: DeviceLabels.CAPS_APPROVE,
     },
   },
@@ -87,12 +87,12 @@ export const DEVICE_LABELS_CONFIG: DeviceLabelsConfig = {
     },
     delegateConfirm: {
       [AppInfos.CELO.name]: DeviceLabels.ACCEPT,
+      [AppInfos.TEZOS.name]: DeviceLabels.ACCEPT_AND_SEND,
       [AppInfos.COSMOS.name]: DeviceLabels.CAPS_APPROVE,
       [AppInfos.INJECTIVE.name]: DeviceLabels.CAPS_APPROVE,
       [AppInfos.MULTIVERS_X.name]: DeviceLabels.SIGN,
       [AppInfos.NEAR.name]: DeviceLabels.CONTINUE_TO_ACTION,
       [AppInfos.SOLANA.name]: DeviceLabels.SIGN_TRANSACTION,
-      [AppInfos.TEZOS.name]: DeviceLabels.ACCEPT_RISK,
       [AppInfos.OSMOSIS.name]: DeviceLabels.CAPS_APPROVE,
       default: DeviceLabels.APPROVE,
     },

package/src/e2e/enum/Account.ts

@@ -248,6 +248,13 @@ export class Account {
     "0xa1baa625c5E6A9304cB7AcD86d2fee6B710eC3eB",
     1,
     undefined,
+  );
+  static readonly ETH_2_WITH_ENS = new Account(
+    Currency.ETH,
+    "Ethereum 2",
+    "0xa1baa625c5E6A9304cB7AcD86d2fee6B710eC3eB",
+    1,
+    undefined,
     "speculos.eth",
   );
   static readonly ETH_2_LOWER_CASE = new Account(

package/src/e2e/enum/DeviceLabels.ts

@@ -6,9 +6,8 @@ export enum DeviceLabels {
   ADDRESS = "Address",
   AMOUNT = "Amount",
   APPROVE = "Approve",
-  CANCEL = "Cancel",
+  BITCOIN_IS_READY = "Bitcoin is ready",
   CAPS_APPROVE = "APPROVE",
-  CAPS_REJECT = "REJECT",
   CHAIN_ID = "Chain ID",
   CONFIRM = "Confirm",
   CONNECT = "Connect",
@@ -19,19 +18,14 @@ export enum DeviceLabels {
   DELEGATE_FROM = "Delegate from",
   DELEGATE_STAKE = "Delegate stake",
   DEPOSIT = "Deposit",
-  DEST = "Dest",
-  DESTINATION = "Destination",
   EXPERT_MODE = "Expert mode",
   FEES = "Fees",
-  FINALIZE = "Finalize",
   GET = "Get",
   I_UNDERSTAND = "I understand",
   LEDGER_LIVE_WILL_BE = "Ledger Live will be",
-  METHOD_NAME = "Method name",
   NEW_ORDINARY = "New ordinary",
   PLEASE_REVIEW = "Please",
   PUBKEY = "Pubkey",
-  PUBLICKEY = "Public Key Hash",
   READY = "Ready",
   RECEIVE_ADDRESS_DOES_NOT_BELONG = "Receive address does",
   RECEIVER = "Receiver",
@@ -51,6 +45,7 @@ export enum DeviceLabels {
   STAKE_KEY = "Stake key",
   TO = "To",
   TRANSACTION_FEE = "Transaction fee",
+  TRANSACTION_SIGNED = "Transaction Signed",
   TRANSFER = "Transfer",
   TURN_ON_SYNC = "Turn on sync",
   TURN_ON_SYNC2 = "Turn On sync",
@@ -63,5 +58,4 @@ export enum DeviceLabels {
   VERIFY_SOLANA_ADDRESS = "Verify Solana address",
   VIEW_ACTION = "View action",
   VIEW_HEADER = "View Header",
-  WALLET_ID = "Wallet ID",
 }

package/src/e2e/families/bitcoin.ts

@@ -1,7 +1,15 @@
 import expect from "expect";
 import { Transaction } from "../models/Transaction";
-import { pressBoth, pressUntilTextFound, waitFor, containsSubstringInEvent } from "../speculos";
+import {
+  pressBoth,
+  pressUntilTextFound,
+  waitFor,
+  containsSubstringInEvent,
+  getSpeculosModel,
+} from "../speculos";
 import { DeviceLabels } from "../enum/DeviceLabels";
+import { Device } from "../enum/Device";
+import invariant from "invariant";
 
 export async function sendBTCBasedCoin(tx: Transaction) {
   const events = await pressUntilTextFound(DeviceLabels.ACCEPT);
@@ -14,3 +22,27 @@ export async function sendBTCBasedCoin(tx: Transaction) {
   await pressUntilTextFound(DeviceLabels.ACCEPT);
   await pressBoth();
 }
+
+export async function sendBTC(tx: Transaction) {
+  const speculosDevice = getSpeculosModel();
+  try {
+    const events =
+      speculosDevice === Device.LNS
+        ? await pressUntilTextFound(DeviceLabels.CONTINUE)
+        : await pressUntilTextFound(DeviceLabels.SIGN_TRANSACTION);
+    const isAmountCorrect = containsSubstringInEvent(tx.amount, events);
+    expect(isAmountCorrect).toBeTruthy();
+    const isAddressCorrect = containsSubstringInEvent(tx.accountToCredit.address, events);
+    expect(isAddressCorrect).toBeTruthy();
+    await pressBoth();
+    if (speculosDevice === Device.LNS) {
+      await pressUntilTextFound(DeviceLabels.SIGN);
+      await pressBoth();
+      await waitFor(DeviceLabels.BITCOIN_IS_READY);
+    } else {
+      await waitFor(DeviceLabels.TRANSACTION_SIGNED);
+    }
+  } catch (e) {
+    invariant(false, `Error while sending BTC transaction: ${e}`);
+  }
+}

package/src/e2e/families/tezos.ts

@@ -1,14 +1,23 @@
-import { getDelegateEvents, getSpeculosModel, pressBoth, pressUntilTextFound } from "../speculos";
-import { DeviceLabels } from "../enum/DeviceLabels";
+import {
+  getDelegateEvents,
+  getDeviceLabels,
+  getSpeculosModel,
+  pressBoth,
+  pressUntilTextFound,
+} from "../speculos";
 import { Delegate } from "../models/Delegate";
 import { DeviceModelId } from "@ledgerhq/types-devices";
+import { DeviceLabels } from "../enum/DeviceLabels";
 
 export async function delegateTezos(delegatingAccount: Delegate) {
+  const { delegateConfirmLabel } = getDeviceLabels(delegatingAccount.account.currency.speculosApp);
+
   await getDelegateEvents(delegatingAccount);
+  await pressUntilTextFound(delegateConfirmLabel);
   await pressBoth();
 
-  if (getSpeculosModel() !== DeviceModelId.nanoS) {
-    await pressUntilTextFound(DeviceLabels.ACCEPT);
+  if (getSpeculosModel() == DeviceModelId.nanoS) {
+    await pressUntilTextFound(DeviceLabels.ACCEPT_AND_SEND);
     await pressBoth();
   }
 }

package/src/e2e/models/Swap.ts

@@ -27,4 +27,12 @@ export class Swap extends Transaction {
   public get getAmount(): string {
     return this.amount;
   }
+
+  public get getAccountToDebit(): Account {
+    return this.accountToDebit;
+  }
+
+  public get getAccountToCredit(): Account {
+    return this.accountToCredit;
+  }
 }

package/src/e2e/speculos.ts

@@ -19,7 +19,7 @@ import { Account } from "./enum/Account";
 import { Device as CryptoWallet } from "./enum/Device";
 import { Currency } from "./enum/Currency";
 import expect from "expect";
-import { sendBTCBasedCoin } from "./families/bitcoin";
+import { sendBTC, sendBTCBasedCoin } from "./families/bitcoin";
 import { sendEVM, sendEvmNFT } from "./families/evm";
 import { sendPolkadot } from "./families/polkadot";
 import { sendAlgorand } from "./families/algorand";
@@ -630,7 +630,7 @@ type DeviceLabelsReturn = {
   receiveVerifyLabel: string;
 };
 
-function getDeviceLabels(appInfo: AppInfos): DeviceLabelsReturn {
+export function getDeviceLabels(appInfo: AppInfos): DeviceLabelsReturn {
   const deviceModel = getSpeculosModel();
   const deviceConfig = DEVICE_LABELS_CONFIG[deviceModel] ?? DEVICE_LABELS_CONFIG.default;
 
@@ -668,6 +668,12 @@ export async function signSendTransaction(tx: Transaction) {
     case Currency.ETH:
       await sendEVM(tx);
       break;
+    case Currency.BTC:
+      await sendBTC(tx);
+      break;
+    case Currency.ETH_USDT:
+      await sendEVM(tx);
+      break;
     case Currency.DOGE:
     case Currency.BCH:
       await sendBTCBasedCoin(tx);
@@ -759,6 +765,7 @@ export async function getDelegateEvents(delegatingAccount: Delegate): Promise<st
   );
 
   await waitFor(delegateVerifyLabel);
+
   return await pressUntilTextFound(delegateConfirmLabel);
 }
 
@@ -768,54 +775,38 @@ export async function verifyAmountsAndAcceptSwap(swap: Swap, amount: string) {
     getSpeculosModel() === DeviceModelId.nanoS
       ? await pressUntilTextFound(DeviceLabels.ACCEPT_AND_SEND)
       : await pressUntilTextFound(DeviceLabels.SIGN_TRANSACTION);
-  await verifySwapData(swap, events, amount);
+  verifySwapData(swap, events, amount);
   await pressBoth();
 }
 
 export async function verifyAmountsAndAcceptSwapForDifferentSeed(swap: Swap, amount: string) {
-  await waitFor(DeviceLabels.RECEIVE_ADDRESS_DOES_NOT_BELONG);
-  await pressUntilTextFound(DeviceLabels.I_UNDERSTAND);
-  await pressBoth();
+  await waitFor(DeviceLabels.REVIEW_TRANSACTION);
   const events = await pressUntilTextFound(DeviceLabels.SIGN_TRANSACTION);
-  await verifySwapData(swap, events, amount);
+  verifySwapData(swap, events, amount);
   await pressBoth();
 }
 
 export async function verifyAmountsAndRejectSwap(swap: Swap, amount: string) {
   await waitFor(DeviceLabels.REVIEW_TRANSACTION);
   const events = await pressUntilTextFound(DeviceLabels.REJECT);
-  await verifySwapData(swap, events, amount);
+  verifySwapData(swap, events, amount);
   await pressBoth();
 }
 
-async function verifySwapData(swap: Swap, events: string[], amount: string) {
-  const sendAmountScreen = containsSubstringInEvent(amount, events);
-  expect(sendAmountScreen).toBeTruthy();
-  verifySwapGetAmountScreen(swap, events);
-  verifySwapFeesAmountScreen(swap, events);
-}
-
-function verifySwapGetAmountScreen(swap: Swap, events: string[]) {
-  const parsedAmountToReceive = extractNumberFromString(swap.amountToReceive);
-  swap.amountToReceive =
-    parsedAmountToReceive.length < 19
-      ? parsedAmountToReceive
-      : parsedAmountToReceive.substring(0, 18);
+function verifySwapData(swap: Swap, events: string[], amount: string) {
+  const swapPair = `swap ${swap.getAccountToDebit.currency.ticker} to ${swap.getAccountToCredit.currency.ticker}`;
 
-  const receivedGetAmount = containsSubstringInEvent(`${swap.amountToReceive}`, events);
-  expect(receivedGetAmount).toBeTruthy();
+  if (getSpeculosModel() !== DeviceModelId.nanoS) {
+    expectDeviceScreenContains(swapPair, events, "Swap pair not found on the device screen");
+  }
+  expectDeviceScreenContains(amount, events, `Amount ${amount} not found on the device screen`);
 }
 
-function verifySwapFeesAmountScreen(swap: Swap, events: string[]) {
-  const parsedFeesAmount = extractNumberFromString(swap.feesAmount);
-  swap.feesAmount =
-    parsedFeesAmount.length < 19 ? parsedFeesAmount : parsedFeesAmount.substring(0, 18);
-
-  const receivedFeesAmount = containsSubstringInEvent(swap.feesAmount, events);
-  expect(receivedFeesAmount).toBeTruthy();
+function expectDeviceScreenContains(substring: string, events: string[], message: string) {
+  const found = containsSubstringInEvent(substring, events);
+  if (!found) {
+    throw new Error(
+      `${message}. Expected events to contain "${substring}". Got: ${JSON.stringify(events)}`,
+    );
+  }
 }
-
-const extractNumberFromString = (input: string | undefined): string => {
-  const match = input?.match(/[\d.]+/);
-  return match ? match[0] : "";
-};

package/src/exchange/providers/swap.ts

@@ -177,9 +177,9 @@ const DEFAULT_SWAP_PROVIDERS: Record<string, ProviderConfig & Partial<Additional
     type: "CEX",
     name: "NEAR Intents",
     needsBearerToken: false,
-    termsOfUseUrl: "https://docs.thorswap.finance/thorswap/resources/terms-of-service",
+    termsOfUseUrl: "https://swapkit.dev/terms-of-service/",
     supportUrl: "https://ledgerhelp.swapkit.dev/",
-    mainUrl: "https://www.thorswap.finance/",
+    mainUrl: "https://www.near.org/intents",
     needsKYC: false,
     version: 2,
     publicKey: {

package/src/families/celo/bridge.integration.test.ts

@@ -2,4 +2,7 @@ import "../../__tests__/test-helpers/setup";
 import { testBridge } from "../../__tests__/test-helpers/bridge";
 import { dataset } from "@ledgerhq/coin-celo/test/bridgeDatasetTest";
 
-testBridge(dataset);
+// FIXME: Disabled due to obsolete APDU data and gas estimation issues
+describe.skip("celo integration", () => {
+  testBridge(dataset);
+});

package/src/families/cosmos/datasets/__snapshots__/babylon.integration.test.ts.snap

@@ -3,7 +3,7 @@
 exports[`babylon currency bridge scanAccounts babylon seed 1 1`] = `
 [
   {
-    "balance": "1000000",
+    "balance": "1000003",
     "currencyId": "babylon",
     "derivationMode": "",
     "freshAddress": "bbn1uwpws077a0a9pclapv3f2fyj5u0mlh6ewmds8n",
@@ -12,7 +12,7 @@ exports[`babylon currency bridge scanAccounts babylon seed 1 1`] = `
     "index": 0,
     "pendingOperations": [],
     "seedIdentifier": "03cd9e27aa78eddce3fda5f8050db35196b188d80d10bd04aab15e5669defee8b0",
-    "spendableBalance": "1000000",
+    "spendableBalance": "1000003",
     "swapHistory": [],
     "syncHash": undefined,
     "used": true,