@ledgerhq/coin-canton 0.11.0-nightly.20251204023901 → 0.11.0-nightly.20251204135727

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();
@@ -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);
+  });
 });

package/src/bridge/onboard.test.ts

@@ -1,9 +1,17 @@
 import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import { isCantonCoinPreapproved } from "./onboard";
+import { firstValueFrom, toArray } from "rxjs";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { buildOnboardAccount, 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";
@@ -56,4 +64,102 @@ 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,6 +16,7 @@ import {
   preparePreApprovalTransaction,
   submitPreApprovalTransaction,
   getTransferPreApproval,
+  clearIsTopologyChangeRequiredCache,
 } from "../network/gateway";
 import { signTransaction } from "../common-logic/transaction/sign";
 import {
@@ -90,7 +91,9 @@ export const buildOnboardAccount =
 
         let { partyId } = await isAccountOnboarded(currency, publicKey);
 
-        if (partyId) {
+        // 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) {
           const onboardedAccount = createOnboardedAccount(account, partyId, currency);
           o.next({ partyId, account: onboardedAccount }); // success
           return;
@@ -109,6 +112,8 @@ 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/serialization.ts

@@ -15,10 +15,11 @@ function isCantonAccountRaw(accountRaw: AccountRaw): accountRaw is CantonAccount
 }
 
 function toResourcesRaw(r: CantonResources): CantonResourcesRaw {
-  const { instrumentUtxoCounts, pendingTransferProposals } = r;
+  const { instrumentUtxoCounts, pendingTransferProposals, publicKey } = r;
   return {
     instrumentUtxoCounts,
     pendingTransferProposals,
+    publicKey,
   };
 }
 
@@ -26,6 +27,7 @@ function fromResourcesRaw(r: CantonResourcesRaw): CantonResources {
   return {
     instrumentUtxoCounts: r.instrumentUtxoCounts,
     pendingTransferProposals: r.pendingTransferProposals,
+    publicKey: r.publicKey,
   };
 }
 

package/src/bridge/sync.ts

@@ -94,15 +94,17 @@ export function makeGetAccountShape(
     const { address, currency, derivationMode, derivationPath, initialAccount } = info;
 
     let xpubOrAddress = initialAccount?.xpub || "";
+    let publicKey: string | undefined = initialAccount?.cantonResources?.publicKey;
 
-    if (!xpubOrAddress) {
+    if (!xpubOrAddress || !publicKey) {
       const getAddress = resolver(signerContext);
-      const { publicKey } = await getAddress(info.deviceId || "", {
+      const addressResult = await getAddress(info.deviceId || "", {
         path: derivationPath,
         currency: currency,
         derivationMode: derivationMode,
         verify: false,
       });
+      publicKey = addressResult.publicKey;
 
       const { isOnboarded, partyId } = await isAccountOnboarded(currency, publicKey);
       if (isOnboarded && partyId) {
@@ -168,6 +170,7 @@ export function makeGetAccountShape(
       cantonResources: {
         instrumentUtxoCounts,
         pendingTransferProposals,
+        publicKey,
       },
     });
 
@@ -195,6 +198,7 @@ export function makeGetAccountShape(
       cantonResources: {
         instrumentUtxoCounts,
         pendingTransferProposals,
+        publicKey,
       },
     };
 

package/src/network/gateway.integ.test.ts

@@ -126,6 +126,29 @@ describe("gateway (devnet)", () => {
       },
       30000,
     );
+
+    it("should handle PARTY_ALREADY_EXISTS error and return party_id and public_key", async () => {
+      // GIVEN
+      const { keyPair, partyId } = getOnboardedAccount();
+      const signature = keyPair.sign(prepareResponse?.transactions?.combined_hash || "");
+
+      // WHEN
+      const response = await submitOnboarding(
+        mockCurrency,
+        keyPair.publicKeyHex,
+        prepareResponse!,
+        {
+          signature,
+        },
+      );
+
+      // THEN
+      expect(response).toHaveProperty("party");
+      expect(response.party).toHaveProperty("party_id");
+      expect(response.party).toHaveProperty("public_key");
+      expect(response.party.party_id).toBe(partyId);
+      expect(response.party.public_key).toBe(keyPair.publicKeyHex);
+    }, 30000);
   });
 
   describe("getLedgerEnd", () => {