@ledgerhq/coin-canton 0.11.0-nightly.20251206023719 → 0.11.0

package/src/api/listOperations.integ.test.ts

@@ -8,7 +8,7 @@ describe.skip("devnet", () => {
     api = createApi({
       nodeUrl: "https://wallet-validator-devnet-canton.ledger-test.com/v2",
       networkType: "devnet",
-      gatewayUrl: "https://canton-gateway-devnet.api.live.ledger-test.com",
+      gatewayUrl: "https://canton-gateway.api.live.ledger-test.com",
       useGateway: true,
       nativeInstrumentId: "Amulet",
     });

package/src/bridge/acceptOffer.test.ts

@@ -1,24 +1,17 @@
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
-import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import type { Account } from "@ledgerhq/types-live";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { buildTransferInstruction } from "./acceptOffer";
+import * as gateway from "../network/gateway";
 import * as signTransactionModule from "../common-logic/transaction/sign";
+import type { CantonSigner, CantonSignature } from "../types/signer";
 import type { PrepareTransferResponse } from "../network/gateway";
-import * as gateway from "../network/gateway";
-import type { CantonAccount } from "../types";
-import { TopologyChangeError } from "../types/errors";
-import type { CantonSignature, CantonSigner } from "../types/signer";
-import { buildTransferInstruction } from "./acceptOffer";
-import * as getTransactionStatusModule from "./getTransactionStatus";
 
 jest.mock("../network/gateway");
 jest.mock("../common-logic/transaction/sign");
-jest.mock("./getTransactionStatus");
 
 const mockedGateway = gateway as jest.Mocked<typeof gateway>;
 const mockedSignTransaction = signTransactionModule as jest.Mocked<typeof signTransactionModule>;
-const mockedGetTransactionStatus = getTransactionStatusModule as jest.Mocked<
-  typeof getTransactionStatusModule
->;
 
 describe("acceptOffer", () => {
   const mockCurrency = {
@@ -102,7 +95,6 @@ describe("acceptOffer", () => {
     mockedGateway.prepareTransferInstruction.mockResolvedValue(mockPreparedTransaction);
     mockedSignTransaction.signTransaction.mockResolvedValue(mockSignature);
     mockedGateway.submitTransferInstruction.mockResolvedValue({ update_id: "test-update-id" });
-    mockedGetTransactionStatus.validateTopology.mockResolvedValue(null);
   });
 
   describe("buildTransferInstruction", () => {
@@ -304,36 +296,5 @@ describe("acceptOffer", () => {
       expect(mockedSignTransaction.signTransaction).toHaveBeenCalled();
       expect(mockedGateway.submitTransferInstruction).toHaveBeenCalled();
     });
-
-    it("should throw TopologyChangeError when validateTopology returns topology error", async () => {
-      // GIVEN
-      const topologyError = new TopologyChangeError("Topology change detected");
-      const cantonAccount = {
-        ...mockAccount,
-        cantonResources: {
-          publicKey: "test-public-key",
-          instrumentUtxoCounts: {},
-        },
-      } as unknown as CantonAccount;
-      mockedGetTransactionStatus.validateTopology.mockResolvedValue(topologyError);
-      const transferInstruction = buildTransferInstruction(mockSignerContext);
-
-      // WHEN & THEN
-      await expect(
-        transferInstruction(
-          mockCurrency,
-          mockDeviceId,
-          cantonAccount,
-          mockPartyId,
-          mockContractId,
-          "accept-transfer-instruction",
-        ),
-      ).rejects.toThrow(TopologyChangeError);
-
-      expect(mockedGetTransactionStatus.validateTopology).toHaveBeenCalledWith(cantonAccount);
-      expect(mockedGateway.prepareTransferInstruction).not.toHaveBeenCalled();
-      expect(mockedSignTransaction.signTransaction).not.toHaveBeenCalled();
-      expect(mockedGateway.submitTransferInstruction).not.toHaveBeenCalled();
-    });
   });
 });

package/src/bridge/acceptOffer.ts

@@ -1,10 +1,9 @@
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import type { Account } from "@ledgerhq/types-live";
 import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import { validateTopology } from "./getTransactionStatus";
+
 import { prepareTransferInstruction, submitTransferInstruction } from "../network/gateway";
 import { signTransaction } from "../common-logic/transaction/sign";
-import { isCantonAccount } from "./serialization";
 import type { CantonSigner } from "../types";
 
 type TransferInstructionType =
@@ -23,13 +22,6 @@ export const buildTransferInstruction =
     type: TransferInstructionType,
     reason?: string,
   ) => {
-    if (isCantonAccount(account)) {
-      const topologyError = await validateTopology(account);
-      if (topologyError) {
-        throw topologyError;
-      }
-    }
-
     const preparedTransaction = await prepareTransferInstruction(currency, partyId, {
       type,
       contract_id: contractId,

package/src/bridge/getTransactionStatus.test.ts

@@ -1,18 +1,18 @@
 import {
   AmountRequired,
   FeeNotLoaded,
+  FeeRequired,
   FeeTooHigh,
   InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
   NotEnoughBalanceBecauseDestinationNotCreated,
   NotEnoughSpendableBalance,
   RecipientRequired,
 } from "@ledgerhq/errors";
 import BigNumber from "bignumber.js";
 import coinConfig from "../config";
-import * as gateway from "../network/gateway";
 import { createMockAccount } from "../test/fixtures";
 import { CantonAccount, TooManyUtxosCritical, TooManyUtxosWarning, Transaction } from "../types";
-import { TopologyChangeError } from "../types/errors";
 import {
   getTransactionStatus,
   TO_MANY_UTXOS_CRITICAL_COUNT,
@@ -20,9 +20,7 @@ import {
 } from "./getTransactionStatus";
 
 jest.mock("../config", () => ({ getCoinConfig: jest.fn() }));
-jest.mock("../network/gateway");
 const mockCoinConfig = jest.mocked(coinConfig);
-const mockedGateway = gateway as jest.Mocked<typeof gateway>;
 
 describe("getTransactionStatus", () => {
   const mockAccount: CantonAccount = {
@@ -30,11 +28,8 @@ describe("getTransactionStatus", () => {
       balance: new BigNumber(1000),
       spendableBalance: new BigNumber(1000),
       freshAddress: "test::33333333333333333333333333333333333333333333333333333333333333333333",
-      xpub: "test-party-id",
     }),
     cantonResources: {
-      pendingTransferProposals: [],
-      publicKey: "test-public-key",
       instrumentUtxoCounts: {
         Amulet: 5,
       },
@@ -49,7 +44,6 @@ describe("getTransactionStatus", () => {
       status: { type: "active" },
       nativeInstrumentId: "Amulet",
     });
-    mockedGateway.isTopologyChangeRequiredCached.mockResolvedValue(false);
   });
 
   describe("fee validation", () => {
@@ -293,7 +287,6 @@ describe("getTransactionStatus", () => {
       const accountWithTooManyUtxos = {
         ...mockAccount,
         cantonResources: {
-          ...mockAccount.cantonResources,
           instrumentUtxoCounts: {
             Amulet: TO_MANY_UTXOS_CRITICAL_COUNT + 1,
           },
@@ -318,7 +311,7 @@ describe("getTransactionStatus", () => {
       const accountWithManyUtxos = {
         ...mockAccount,
         cantonResources: {
-          ...mockAccount.cantonResources,
+          pendingTransferProposals: [],
           instrumentUtxoCounts: {
             Amulet: TO_MANY_UTXOS_WARNING_COUNT + 1,
           },
@@ -346,7 +339,6 @@ describe("getTransactionStatus", () => {
       const accountWithFewUtxos = {
         ...mockAccount,
         cantonResources: {
-          ...mockAccount.cantonResources,
           instrumentUtxoCounts: {
             Amulet: TO_MANY_UTXOS_WARNING_COUNT - 1,
           },
@@ -370,7 +362,6 @@ describe("getTransactionStatus", () => {
       const accountWithManyUtxos = {
         ...mockAccount,
         cantonResources: {
-          ...mockAccount.cantonResources,
           instrumentUtxoCounts: {
             Amulet: 25,
           },
@@ -391,87 +382,4 @@ describe("getTransactionStatus", () => {
       expect(result.errors.utxoCount).toBeUndefined();
     });
   });
-
-  describe("topology validation", () => {
-    it("should return TopologyChangeError when isTopologyChangeRequiredCached returns true", async () => {
-      // GIVEN
-      const accountWithPartyId: CantonAccount = {
-        ...mockAccount,
-        xpub: "test-party-id",
-      };
-      mockedGateway.isTopologyChangeRequiredCached.mockResolvedValue(true);
-
-      const transaction: Transaction = {
-        family: "canton",
-        amount: new BigNumber(100),
-        recipient: "valid::11111111111111111111111111111111111111111111111111111111111111111111",
-        fee: new BigNumber(10),
-        tokenId: "",
-      };
-
-      // WHEN
-      const result = await getTransactionStatus(accountWithPartyId, transaction);
-
-      // THEN
-      expect(result.errors.topologyChange).toBeInstanceOf(TopologyChangeError);
-      expect(mockedGateway.isTopologyChangeRequiredCached).toHaveBeenCalledWith(
-        accountWithPartyId.currency,
-        "test-public-key",
-      );
-    });
-
-    it("should not return topology error when isTopologyChangeRequiredCached returns false", async () => {
-      // GIVEN
-      const accountWithPartyId: CantonAccount = {
-        ...mockAccount,
-        xpub: "test-party-id",
-      };
-      mockedGateway.isTopologyChangeRequiredCached.mockResolvedValue(false);
-
-      const transaction: Transaction = {
-        family: "canton",
-        amount: new BigNumber(100),
-        recipient: "valid::11111111111111111111111111111111111111111111111111111111111111111111",
-        fee: new BigNumber(10),
-        tokenId: "",
-      };
-
-      // WHEN
-      const result = await getTransactionStatus(accountWithPartyId, transaction);
-
-      // THEN
-      expect(result.errors.topologyChange).toBeUndefined();
-      expect(mockedGateway.isTopologyChangeRequiredCached).toHaveBeenCalledWith(
-        accountWithPartyId.currency,
-        "test-public-key",
-      );
-    });
-
-    it("should not return topology error when isTopologyChangeRequiredCached throws an error", async () => {
-      // GIVEN
-      const accountWithPartyId: CantonAccount = {
-        ...mockAccount,
-        xpub: "test-party-id",
-      };
-      mockedGateway.isTopologyChangeRequiredCached.mockRejectedValue(new Error("Network error"));
-
-      const transaction: Transaction = {
-        family: "canton",
-        amount: new BigNumber(100),
-        recipient: "valid::11111111111111111111111111111111111111111111111111111111111111111111",
-        fee: new BigNumber(10),
-        tokenId: "",
-      };
-
-      // WHEN
-      const result = await getTransactionStatus(accountWithPartyId, transaction);
-
-      // THEN
-      expect(result.errors.topologyChange).toBeUndefined();
-      expect(mockedGateway.isTopologyChangeRequiredCached).toHaveBeenCalledWith(
-        accountWithPartyId.currency,
-        "test-public-key",
-      );
-    });
-  });
 });

package/src/bridge/getTransactionStatus.ts

@@ -1,6 +1,7 @@
 import {
   AmountRequired,
   FeeNotLoaded,
+  FeeRequired,
   FeeTooHigh,
   InvalidAddress,
   NotEnoughBalanceBecauseDestinationNotCreated,
@@ -20,8 +21,6 @@ import {
 import { isRecipientValid } from "../common-logic/utils";
 import coinConfig from "../config";
 import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets/abandonseed";
-import { isTopologyChangeRequiredCached } from "../network/gateway";
-import { TopologyChangeError } from "../types/errors";
 
 export const TO_MANY_UTXOS_CRITICAL_COUNT = 24;
 export const TO_MANY_UTXOS_WARNING_COUNT = 10;
@@ -82,15 +81,7 @@ export const getTransactionStatus: AccountBridge<
     errors.amount = new AmountRequired();
   }
 
-  const utxoWarning = validateUtxoCount(account, transaction);
-  if (utxoWarning) {
-    warnings.tooManyUtxos = utxoWarning;
-  }
-
-  const topologyError = await validateTopology(account);
-  if (topologyError) {
-    errors.topologyChange = topologyError;
-  }
+  validateUtxoCount(account, transaction, warnings);
 
   return {
     errors,
@@ -101,57 +92,29 @@ export const getTransactionStatus: AccountBridge<
   };
 };
 
-function validateUtxoCount(account: CantonAccount, transaction: Transaction): Error | null {
-  if (!account.cantonResources?.instrumentUtxoCounts) {
-    return null;
-  }
-
-  if (!transaction.recipient) {
-    return null;
-  }
-
-  if (!isRecipientValid(transaction.recipient) || account.xpub === transaction.recipient) {
-    return null;
-  }
-
+function validateUtxoCount(
+  account: CantonAccount,
+  transaction: Transaction,
+  warnings: Record<string, Error>,
+): void {
   const abandonSeedAddress = getAbandonSeedAddress(account.currency.id);
-  if (transaction.recipient.includes(abandonSeedAddress)) {
-    return null;
-  }
-
-  const { instrumentUtxoCounts } = account.cantonResources;
-  const instrumentUtxoCount = instrumentUtxoCounts[transaction.tokenId] || 0;
-
-  if (instrumentUtxoCount > TO_MANY_UTXOS_CRITICAL_COUNT) {
-    return new TooManyUtxosCritical();
-  }
-
-  if (instrumentUtxoCount > TO_MANY_UTXOS_WARNING_COUNT) {
-    return new TooManyUtxosWarning("families.canton.tooManyUtxos.warning");
-  }
-
-  return null;
-}
-
-export async function validateTopology(account: CantonAccount): Promise<Error | null> {
-  const publicKey = account.cantonResources?.publicKey;
-  if (!publicKey) {
-    return null;
-  }
-
-  try {
-    const isTopologyChangeRequired = await isTopologyChangeRequiredCached(
-      account.currency,
-      publicKey,
-    );
-
-    if (!isTopologyChangeRequired) {
-      return null;
+  const isAbandonSeedAddress = transaction.recipient?.includes(abandonSeedAddress);
+
+  // UTXO count validation - only validate if recipient is valid and not equal to sender
+  // Skip validation for abandon seed addresses
+  if (
+    account?.cantonResources?.instrumentUtxoCounts &&
+    transaction.recipient &&
+    isRecipientValid(transaction.recipient) &&
+    account.xpub !== transaction.recipient &&
+    !isAbandonSeedAddress
+  ) {
+    const { instrumentUtxoCounts } = account.cantonResources;
+    const instrumentUtxoCount = instrumentUtxoCounts[transaction.tokenId] || 0;
+    if (instrumentUtxoCount > TO_MANY_UTXOS_CRITICAL_COUNT) {
+      warnings.tooManyUtxos = new TooManyUtxosCritical();
+    } else if (instrumentUtxoCount > TO_MANY_UTXOS_WARNING_COUNT) {
+      warnings.tooManyUtxos = new TooManyUtxosWarning("families.canton.tooManyUtxos.warning");
     }
-
-    return new TopologyChangeError("Topology change detected. Re-onboarding required.");
-  } catch {
-    // If topology check fails, don't block the transaction
-    return null;
   }
 }

package/src/bridge/onboard.integ.test.ts

@@ -1,5 +1,5 @@
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import { firstValueFrom, toArray } from "rxjs";
-import { getEnv, setEnv } from "@ledgerhq/live-env";
 import coinConfig from "../config";
 import { createMockSigner, generateMockKeyPair } from "../test/cantonTestUtils";
 import { createMockAccount, createMockCantonCurrency } from "../test/fixtures";
@@ -12,12 +12,8 @@ import {
   OnboardStatus,
 } from "../types/onboard";
 import { buildAuthorizePreapproval, buildOnboardAccount, isAccountOnboarded } from "./onboard";
-import {
-  isTopologyChangeRequiredCached,
-  clearIsTopologyChangeRequiredCache,
-} from "../network/gateway";
 
-describe("onboard (devnet)", () => {
+describe.skip("onboard (devnet)", () => {
   const mockDeviceId = "test-device-id";
   const mockCurrency = createMockCantonCurrency();
   const mockAccount = createMockAccount();
@@ -31,7 +27,7 @@ describe("onboard (devnet)", () => {
 
   beforeAll(() => {
     coinConfig.setCoinConfig(() => ({
-      gatewayUrl: "https://canton-gateway-devnet.api.live.ledger-test.com",
+      gatewayUrl: "https://canton-gateway.api.live.ledger-test.com",
       useGateway: true,
       networkType: "devnet",
       nativeInstrumentId: "Amulet",
@@ -170,7 +166,7 @@ describe("onboard (devnet)", () => {
     }, 30000);
   });
 
-  describe.skip("buildAuthorizePreapproval", () => {
+  describe("buildAuthorizePreapproval", () => {
     it("should complete preapproval flow for onboarded account", async () => {
       // GIVEN
       const { mockSignerContext, onboardResult } = getOnboardedAccount();
@@ -203,81 +199,4 @@ describe("onboard (devnet)", () => {
       expect(typeof finalResult.isApproved).toBe("boolean");
     }, 30000);
   });
-
-  describe("TopologyChangeError", () => {
-    it("should require topology change and complete re-onboarding when accessing account from different node", async () => {
-      // GIVEN
-      const originalNodeId = getEnv("CANTON_NODE_ID_OVERRIDE");
-      setEnv("CANTON_NODE_ID_OVERRIDE", "devnet");
-      const keyPair = generateMockKeyPair();
-      const mockAccount = createMockAccount({ xpub: keyPair.publicKeyHex });
-      const mockSigner = createMockSigner(keyPair);
-      const mockSignerContext = jest.fn().mockImplementation((_, callback) => {
-        return callback(mockSigner);
-      });
-
-      const onboardObservable = buildOnboardAccount(mockSignerContext);
-      const onboardValues = await firstValueFrom(
-        onboardObservable(mockCurrency, mockDeviceId, mockAccount).pipe(toArray()),
-      );
-      const onboardResult = onboardValues.find(
-        (value): value is CantonOnboardResult => "partyId" in value,
-      );
-
-      if (!onboardResult) {
-        throw new Error("Failed to onboard account");
-      }
-
-      const partyId = onboardResult.partyId;
-      expect(partyId).toBeDefined();
-
-      // Verify account is accessible on devnet node
-      const isTopologyChangeRequiredOnDevnet = await isTopologyChangeRequiredCached(
-        mockCurrency,
-        keyPair.publicKeyHex,
-      );
-      expect(isTopologyChangeRequiredOnDevnet).toBe(false);
-
-      // WHEN: Switch to different node
-      setEnv("CANTON_NODE_ID_OVERRIDE", "devnet-replicated");
-      clearIsTopologyChangeRequiredCache(mockCurrency, keyPair.publicKeyHex);
-
-      // THEN: Verify topology change is required
-      const isTopologyChangeRequiredOnReplicated = await isTopologyChangeRequiredCached(
-        mockCurrency,
-        keyPair.publicKeyHex,
-      );
-      expect(isTopologyChangeRequiredOnReplicated).toBe(true);
-
-      // AND: Verify re-onboarding proceeds through full onboarding flow
-      const reonboardObservable = buildOnboardAccount(mockSignerContext);
-      const reonboardValues = await firstValueFrom(
-        reonboardObservable(mockCurrency, mockDeviceId, mockAccount).pipe(toArray()),
-      );
-      const progressValues = reonboardValues.filter(
-        (value): value is CantonOnboardProgress => "status" in value && !("partyId" in value),
-      );
-      const resultValues = reonboardValues.filter(
-        (value): value is CantonOnboardResult => "partyId" in value,
-      );
-
-      // Check expected status progression
-      expect(progressValues.some(p => p.status === OnboardStatus.INIT)).toBe(true);
-      expect(progressValues.some(p => p.status === OnboardStatus.PREPARE)).toBe(true);
-      expect(progressValues.some(p => p.status === OnboardStatus.SIGN)).toBe(true);
-      expect(progressValues.some(p => p.status === OnboardStatus.SUBMIT)).toBe(true);
-
-      // Check final result
-      expect(resultValues.length).toBeGreaterThan(0);
-      const finalResult = resultValues[resultValues.length - 1];
-      expect(finalResult.partyId).toBeDefined();
-      expect(typeof finalResult.partyId).toBe("string");
-
-      if (originalNodeId) {
-        setEnv("CANTON_NODE_ID_OVERRIDE", originalNodeId);
-      } else {
-        setEnv("CANTON_NODE_ID_OVERRIDE", "");
-      }
-    }, 60000);
-  });
 });

package/src/bridge/onboard.test.ts

@@ -1,17 +1,9 @@
 import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import { firstValueFrom, toArray } from "rxjs";
-import { SignerContext } from "@ledgerhq/coin-framework/signer";
-import { buildOnboardAccount, isCantonCoinPreapproved } from "./onboard";
+import { isCantonCoinPreapproved } from "./onboard";
 import * as gateway from "../network/gateway";
-import * as signTransactionModule from "../common-logic/transaction/sign";
-import { createMockAccount } from "../test/fixtures";
-import type { CantonSigner, CantonSignature } from "../types";
-import { OnboardStatus, CantonOnboardProgress, CantonOnboardResult } from "../types/onboard";
 
 jest.mock("../network/gateway");
-jest.mock("../common-logic/transaction/sign");
 const mockedGateway = gateway as jest.Mocked<typeof gateway>;
-const mockedSignTransaction = signTransactionModule as jest.Mocked<typeof signTransactionModule>;
 
 describe("onboard", () => {
   const mockPartyId = "test-party-id";
@@ -64,102 +56,4 @@ describe("onboard", () => {
       expect(mockedGateway.getTransferPreApproval).toHaveBeenCalledWith(mockCurrency, mockPartyId);
     });
   });
-
-  describe("buildOnboardAccount", () => {
-    const mockDeviceId = "test-device-id";
-    const mockPublicKey = "test-public-key";
-    const mockPartyId = "test-party-id";
-    const mockSignature: CantonSignature = {
-      signature: "test-signature",
-    };
-
-    const mockSigner: CantonSigner = {
-      getAddress: jest.fn().mockResolvedValue({
-        address: "test-address",
-        publicKey: mockPublicKey,
-        path: "44'/6767'/0'/0/0",
-      }),
-      signTransaction: jest.fn().mockResolvedValue(mockSignature),
-    } as unknown as CantonSigner;
-
-    const mockSignerContext: SignerContext<CantonSigner> = jest.fn(
-      async (deviceId: string, callback: (signer: CantonSigner) => Promise<CantonSignature>) => {
-        return callback(mockSigner);
-      },
-    ) as unknown as SignerContext<CantonSigner>;
-
-    beforeEach(() => {
-      jest.clearAllMocks();
-    });
-
-    it("should skip submission when account is onboarded on network but has no local xpub", async () => {
-      // GIVEN
-      const account = createMockAccount({ xpub: undefined });
-      mockedGateway.getPartyByPubKey.mockResolvedValue({ party_id: mockPartyId });
-
-      const onboardObservable = buildOnboardAccount(mockSignerContext);
-      const values = await firstValueFrom(
-        onboardObservable(mockCurrency, mockDeviceId, account).pipe(toArray()),
-      );
-
-      // THEN
-      const result = values.find((v): v is CantonOnboardResult => "partyId" in v);
-      expect(result).toBeDefined();
-      expect(result?.partyId).toBe(mockPartyId);
-      expect(result?.account.xpub).toBe(mockPartyId);
-
-      // Should NOT call prepareOnboarding or submitOnboarding
-      expect(mockedGateway.prepareOnboarding).not.toHaveBeenCalled();
-      expect(mockedGateway.submitOnboarding).not.toHaveBeenCalled();
-      expect(mockedSignTransaction.signTransaction).not.toHaveBeenCalled();
-    });
-
-    it("should proceed with submission when account has xpub (re-onboarding scenario)", async () => {
-      // GIVEN - account already has xpub (re-onboarding)
-      const existingPartyId = "existing-party-id";
-      const account = createMockAccount({ xpub: existingPartyId });
-      const newPartyId = "new-party-id";
-
-      mockedGateway.getPartyByPubKey.mockResolvedValue({ party_id: existingPartyId });
-      mockedGateway.prepareOnboarding.mockResolvedValue({
-        party_id: newPartyId,
-        transactions: {},
-      });
-      mockedGateway.submitOnboarding.mockResolvedValue({
-        party: {
-          party_id: newPartyId,
-          public_key: mockPublicKey,
-        },
-      });
-      mockedSignTransaction.signTransaction.mockResolvedValue(mockSignature);
-
-      const onboardObservable = buildOnboardAccount(mockSignerContext);
-      const values = await firstValueFrom(
-        onboardObservable(mockCurrency, mockDeviceId, account).pipe(toArray()),
-      );
-
-      // THEN - should proceed through full onboarding flow
-      const statuses = values
-        .filter((v): v is CantonOnboardProgress => "status" in v)
-        .map(v => v.status);
-      expect(statuses).toContain(OnboardStatus.PREPARE);
-      expect(statuses).toContain(OnboardStatus.SIGN);
-      expect(statuses).toContain(OnboardStatus.SUBMIT);
-
-      // Should call prepareOnboarding and submitOnboarding
-      expect(mockedGateway.prepareOnboarding).toHaveBeenCalledWith(mockCurrency, mockPublicKey);
-      expect(mockedGateway.submitOnboarding).toHaveBeenCalled();
-      expect(mockedSignTransaction.signTransaction).toHaveBeenCalled();
-
-      // Should clear topology change cache
-      expect(mockedGateway.clearIsTopologyChangeRequiredCache).toHaveBeenCalledWith(
-        mockCurrency,
-        mockPublicKey,
-      );
-
-      const result = values.find((v): v is CantonOnboardResult => "partyId" in v);
-      expect(result).toBeDefined();
-      expect(result?.partyId).toBe(newPartyId);
-    });
-  });
 });

package/src/bridge/onboard.ts

@@ -16,7 +16,6 @@ import {
   preparePreApprovalTransaction,
   submitPreApprovalTransaction,
   getTransferPreApproval,
-  clearIsTopologyChangeRequiredCache,
 } from "../network/gateway";
 import { signTransaction } from "../common-logic/transaction/sign";
 import {
@@ -91,9 +90,7 @@ export const buildOnboardAccount =
 
         let { partyId } = await isAccountOnboarded(currency, publicKey);
 
-        // Skip submission only if account is onboarded on network but has no local xpub.
-        // For re-onboarding (account has xpub), always proceed to submit a new onboarding transaction.
-        if (partyId && !account.xpub) {
+        if (partyId) {
           const onboardedAccount = createOnboardedAccount(account, partyId, currency);
           o.next({ partyId, account: onboardedAccount }); // success
           return;
@@ -112,8 +109,6 @@ export const buildOnboardAccount =
 
         await submitOnboarding(currency, publicKey, preparedTransaction, signature);
 
-        clearIsTopologyChangeRequiredCache(currency, publicKey);
-
         const onboardedAccount = createOnboardedAccount(account, partyId, currency);
         o.next({ partyId, account: onboardedAccount }); // success
       }

package/src/bridge/prepareTransaction.test.ts

@@ -16,7 +16,7 @@ describe("prepareTransaction", () => {
 
   beforeAll(async () => {
     coinConfig.setCoinConfig(() => ({
-      gatewayUrl: "https://canton-gateway-devnet.api.live.ledger-test.com",
+      gatewayUrl: "https://canton-gateway.api.live.ledger-test.com",
       useGateway: true,
       networkType: "devnet",
       nativeInstrumentId: "Amulet",