@ledgerhq/coin-canton 0.11.0 → 0.12.0-nightly.20251210100832

package/lib-es/types/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/types/errors.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe;;EAA4C,CAAC;AAEzE,eAAO,MAAM,oBAAoB;;EAAiD,CAAC;AACnF,eAAO,MAAM,mBAAmB;;EAAgD,CAAC"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/types/errors.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe;;EAA4C,CAAC;AAEzE,eAAO,MAAM,oBAAoB;;EAAiD,CAAC;AACnF,eAAO,MAAM,mBAAmB;;EAAgD,CAAC;AAEjF,eAAO,MAAM,mBAAmB;;EAAgD,CAAC"}

package/lib-es/types/errors.js

@@ -2,4 +2,5 @@ import { createCustomErrorClass } from "@ledgerhq/errors";
 export const SimulationError = createCustomErrorClass("SimulationError");
 export const TooManyUtxosCritical = createCustomErrorClass("TooManyUtxosCritical");
 export const TooManyUtxosWarning = createCustomErrorClass("TooManyUtxosWarning");
+export const TopologyChangeError = createCustomErrorClass("TopologyChangeError");
 //# sourceMappingURL=errors.js.map

package/lib-es/types/errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/types/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAE1D,MAAM,CAAC,MAAM,eAAe,GAAG,sBAAsB,CAAC,iBAAiB,CAAC,CAAC;AAEzE,MAAM,CAAC,MAAM,oBAAoB,GAAG,sBAAsB,CAAC,sBAAsB,CAAC,CAAC;AACnF,MAAM,CAAC,MAAM,mBAAmB,GAAG,sBAAsB,CAAC,qBAAqB,CAAC,CAAC"}
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/types/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAE1D,MAAM,CAAC,MAAM,eAAe,GAAG,sBAAsB,CAAC,iBAAiB,CAAC,CAAC;AAEzE,MAAM,CAAC,MAAM,oBAAoB,GAAG,sBAAsB,CAAC,sBAAsB,CAAC,CAAC;AACnF,MAAM,CAAC,MAAM,mBAAmB,GAAG,sBAAsB,CAAC,qBAAqB,CAAC,CAAC;AAEjF,MAAM,CAAC,MAAM,mBAAmB,GAAG,sBAAsB,CAAC,qBAAqB,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ledgerhq/coin-canton",
-  "version": "0.11.0",
+  "version": "0.12.0-nightly.20251210100832",
   "description": "Canton coin integration",
   "keywords": [
     "Ledger",
@@ -101,15 +101,15 @@
     "bignumber.js": "^9.1.2",
     "invariant": "^2.2.4",
     "protobufjs": "7.5.4",
-    "rxjs": "^7.8.1",
-    "@ledgerhq/coin-framework": "^6.10.0",
-    "@ledgerhq/cryptoassets": "^13.34.0",
-    "@ledgerhq/devices": "8.7.0",
-    "@ledgerhq/errors": "^6.27.0",
-    "@ledgerhq/live-env": "^2.22.0",
-    "@ledgerhq/live-network": "^2.1.2",
+    "rxjs": "7.8.2",
+    "@ledgerhq/coin-framework": "^6.11.0-nightly.20251210100832",
+    "@ledgerhq/cryptoassets": "^13.35.0-nightly.20251210100832",
+    "@ledgerhq/devices": "8.8.0-nightly.20251210100832",
+    "@ledgerhq/live-env": "^2.23.0-nightly.20251210100832",
+    "@ledgerhq/live-network": "^2.1.3-nightly.20251210100832",
     "@ledgerhq/logs": "^6.13.0",
-    "@ledgerhq/types-live": "^6.90.0"
+    "@ledgerhq/types-live": "^6.91.0-nightly.20251210100832",
+    "@ledgerhq/errors": "^6.28.0-nightly.20251210100832"
   },
   "devDependencies": {
     "@types/invariant": "^2.2.37",
@@ -121,7 +121,7 @@
     "ts-jest": "^29.1.1",
     "typescript": "^5.4.5",
     "@ledgerhq/disable-network-setup": "^0.1.0",
-    "@ledgerhq/types-cryptoassets": "^7.30.0"
+    "@ledgerhq/types-cryptoassets": "^7.31.0-nightly.20251210100832"
   },
   "scripts": {
     "clean": "rimraf lib lib-es",

package/src/api/getBalance.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.api.live.ledger-test.com",
+      gatewayUrl: "https://canton-gateway-devnet.api.live.ledger-test.com",
       useGateway: true,
       nativeInstrumentId: "Amulet",
     });

package/src/api/lastBlock.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.api.live.ledger-test.com",
+      gatewayUrl: "https://canton-gateway-devnet.api.live.ledger-test.com",
       useGateway: true,
       nativeInstrumentId: "Amulet",
     });

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.api.live.ledger-test.com",
+      gatewayUrl: "https://canton-gateway-devnet.api.live.ledger-test.com",
       useGateway: true,
       nativeInstrumentId: "Amulet",
     });

package/src/bridge/acceptOffer.test.ts

@@ -1,17 +1,24 @@
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
-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 type { Account } from "@ledgerhq/types-live";
 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 = {
@@ -95,6 +102,7 @@ describe("acceptOffer", () => {
     mockedGateway.prepareTransferInstruction.mockResolvedValue(mockPreparedTransaction);
     mockedSignTransaction.signTransaction.mockResolvedValue(mockSignature);
     mockedGateway.submitTransferInstruction.mockResolvedValue({ update_id: "test-update-id" });
+    mockedGetTransactionStatus.validateTopology.mockResolvedValue(null);
   });
 
   describe("buildTransferInstruction", () => {
@@ -296,5 +304,36 @@ 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,9 +1,10 @@
 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 =
@@ -22,6 +23,13 @@ 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,7 +20,9 @@ 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 = {
@@ -28,8 +30,11 @@ 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,
       },
@@ -44,6 +49,7 @@ describe("getTransactionStatus", () => {
       status: { type: "active" },
       nativeInstrumentId: "Amulet",
     });
+    mockedGateway.isTopologyChangeRequiredCached.mockResolvedValue(false);
   });
 
   describe("fee validation", () => {
@@ -287,6 +293,7 @@ describe("getTransactionStatus", () => {
       const accountWithTooManyUtxos = {
         ...mockAccount,
         cantonResources: {
+          ...mockAccount.cantonResources,
           instrumentUtxoCounts: {
             Amulet: TO_MANY_UTXOS_CRITICAL_COUNT + 1,
           },
@@ -311,7 +318,7 @@ describe("getTransactionStatus", () => {
       const accountWithManyUtxos = {
         ...mockAccount,
         cantonResources: {
-          pendingTransferProposals: [],
+          ...mockAccount.cantonResources,
           instrumentUtxoCounts: {
             Amulet: TO_MANY_UTXOS_WARNING_COUNT + 1,
           },
@@ -339,6 +346,7 @@ describe("getTransactionStatus", () => {
       const accountWithFewUtxos = {
         ...mockAccount,
         cantonResources: {
+          ...mockAccount.cantonResources,
           instrumentUtxoCounts: {
             Amulet: TO_MANY_UTXOS_WARNING_COUNT - 1,
           },
@@ -362,6 +370,7 @@ describe("getTransactionStatus", () => {
       const accountWithManyUtxos = {
         ...mockAccount,
         cantonResources: {
+          ...mockAccount.cantonResources,
           instrumentUtxoCounts: {
             Amulet: 25,
           },
@@ -382,4 +391,87 @@ 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,7 +1,6 @@
 import {
   AmountRequired,
   FeeNotLoaded,
-  FeeRequired,
   FeeTooHigh,
   InvalidAddress,
   NotEnoughBalanceBecauseDestinationNotCreated,
@@ -21,6 +20,8 @@ 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;
@@ -81,7 +82,15 @@ export const getTransactionStatus: AccountBridge<
     errors.amount = new AmountRequired();
   }
 
-  validateUtxoCount(account, transaction, warnings);
+  const utxoWarning = validateUtxoCount(account, transaction);
+  if (utxoWarning) {
+    warnings.tooManyUtxos = utxoWarning;
+  }
+
+  const topologyError = await validateTopology(account);
+  if (topologyError) {
+    errors.topologyChange = topologyError;
+  }
 
   return {
     errors,
@@ -92,29 +101,57 @@ export const getTransactionStatus: AccountBridge<
   };
 };
 
-function validateUtxoCount(
-  account: CantonAccount,
-  transaction: Transaction,
-  warnings: Record<string, Error>,
-): void {
+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;
+  }
+
   const abandonSeedAddress = getAbandonSeedAddress(account.currency.id);
-  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");
+  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;
     }
+
+    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,8 +12,12 @@ import {
   OnboardStatus,
 } from "../types/onboard";
 import { buildAuthorizePreapproval, buildOnboardAccount, isAccountOnboarded } from "./onboard";
+import {
+  isTopologyChangeRequiredCached,
+  clearIsTopologyChangeRequiredCache,
+} from "../network/gateway";
 
-describe.skip("onboard (devnet)", () => {
+describe("onboard (devnet)", () => {
   const mockDeviceId = "test-device-id";
   const mockCurrency = createMockCantonCurrency();
   const mockAccount = createMockAccount();
@@ -27,7 +31,7 @@ describe.skip("onboard (devnet)", () => {
 
   beforeAll(() => {
     coinConfig.setCoinConfig(() => ({
-      gatewayUrl: "https://canton-gateway.api.live.ledger-test.com",
+      gatewayUrl: "https://canton-gateway-devnet.api.live.ledger-test.com",
       useGateway: true,
       networkType: "devnet",
       nativeInstrumentId: "Amulet",
@@ -166,7 +170,7 @@ describe.skip("onboard (devnet)", () => {
     }, 30000);
   });
 
-  describe("buildAuthorizePreapproval", () => {
+  describe.skip("buildAuthorizePreapproval", () => {
     it("should complete preapproval flow for onboarded account", async () => {
       // GIVEN
       const { mockSignerContext, onboardResult } = getOnboardedAccount();
@@ -199,4 +203,81 @@ describe.skip("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);
+  });
 });