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

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/prepareTransaction.test.ts

@@ -16,7 +16,7 @@ describe("prepareTransaction", () => {
 
   beforeAll(async () => {
     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",

package/src/bridge/serialization.ts

@@ -15,17 +15,23 @@ function isCantonAccountRaw(accountRaw: AccountRaw): accountRaw is CantonAccount
 }
 
 function toResourcesRaw(r: CantonResources): CantonResourcesRaw {
-  const { instrumentUtxoCounts, pendingTransferProposals } = r;
+  const { isOnboarded, instrumentUtxoCounts, pendingTransferProposals, publicKey, xpub } = r;
   return {
+    isOnboarded: isOnboarded,
     instrumentUtxoCounts,
     pendingTransferProposals,
+    ...(publicKey !== undefined && { publicKey }),
+    ...(xpub !== undefined && { xpub }),
   };
 }
 
 function fromResourcesRaw(r: CantonResourcesRaw): CantonResources {
   return {
+    isOnboarded: r.isOnboarded,
     instrumentUtxoCounts: r.instrumentUtxoCounts,
     pendingTransferProposals: r.pendingTransferProposals,
+    ...(r.publicKey !== undefined && { publicKey: r.publicKey }),
+    ...(r.xpub !== undefined && { xpub: r.xpub }),
   };
 }
 

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

@@ -47,7 +47,7 @@ const mockSignerContext = jest.fn().mockImplementation((deviceId, callback) => {
 describe.skip("sync (devnet)", () => {
   beforeAll(async () => {
     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",

package/src/bridge/sync.test.ts

@@ -1,5 +1,5 @@
 import { makeGetAccountShape } from "./sync";
-import { OperationInfo } from "../network/gateway";
+import { OperationInfo, type InstrumentBalance } from "../network/gateway";
 import * as gateway from "../network/gateway";
 import * as onboard from "./onboard";
 import * as config from "../config";
@@ -7,6 +7,8 @@ import resolver from "../signer";
 import { AccountShapeInfo } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { Account } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
+import { CantonAccount } from "../types";
+import { createMockCantonCurrency } from "../test/fixtures";
 
 jest.mock("../network/gateway");
 jest.mock("../signer");
@@ -25,6 +27,79 @@ const sampleCurrency = {
   id: "testcoin",
 };
 
+const createMockInstrumentBalances = (): InstrumentBalance[] => [
+  {
+    instrument_id: "Native",
+    amount: "1000",
+    locked: false,
+    utxo_count: 1,
+    admin_id: "admin1",
+  },
+];
+
+const createMockOperationView = (): OperationInfo =>
+  ({
+    transaction_hash: "tx-test",
+    uid: "uid-test",
+    type: "Send",
+    status: "Success",
+    fee: {
+      value: "5",
+      asset: {
+        type: "native",
+        issuer: null,
+      },
+      details: {
+        type: "fee",
+      },
+    },
+    transfers: [
+      {
+        address: "party123",
+        type: "Send",
+        value: "100",
+        asset: "Native",
+        details: {
+          operationType: "transfer",
+          metadata: {
+            reason: "test transfer",
+          },
+        },
+      },
+    ],
+    transaction_timestamp: new Date().toISOString(),
+    senders: ["party123"],
+    recipients: ["party456"],
+    block: {
+      height: 1,
+      time: new Date().toISOString(),
+      hash: "blockhash1",
+    },
+    asset: {
+      type: "native",
+      issuer: null,
+    },
+    details: {
+      operationType: "transfer",
+    },
+  }) as OperationInfo;
+
+const createMockCantonAccountShapeInfo = (
+  overrides: Partial<AccountShapeInfo<CantonAccount>> = {},
+): AccountShapeInfo<CantonAccount> => {
+  const currency = createMockCantonCurrency();
+  return {
+    address: "addr1",
+    currency,
+    derivationMode: "",
+    derivationPath: "44'/0'/0'/0/0",
+    deviceId: "fakeDevice",
+    index: 0,
+    initialAccount: undefined,
+    ...overrides,
+  };
+};
+
 describe("makeGetAccountShape", () => {
   const fakeSignerContext = {} as any;
 
@@ -335,4 +410,84 @@ describe("makeGetAccountShape", () => {
     expect(shape.operations[0].type).toBe("TRANSFER_WITHDRAWN");
     expect(shape.operations[0].value).toEqual(BigNumber(50)); // transfer value only, fees not added for TRANSFER_WITHDRAWN
   });
+
+  it("should sync without device when account has xpub but no publicKey", async () => {
+    mockedGetBalance.mockResolvedValue(createMockInstrumentBalances());
+    mockedGetOperations.mockResolvedValue({
+      operations: [createMockOperationView()],
+    });
+
+    const infoWithXpub = createMockCantonAccountShapeInfo({
+      deviceId: undefined, // No device
+      initialAccount: {
+        xpub: "test-party-id",
+        cantonResources: {
+          publicKey: undefined, // Missing publicKey
+          instrumentUtxoCounts: {},
+          pendingTransferProposals: [],
+        },
+      } as unknown as CantonAccount,
+    });
+
+    const getAccountShape = makeGetAccountShape(fakeSignerContext);
+    const shape = await getAccountShape(infoWithXpub, { paginationConfig: {} });
+
+    expect(shape).toHaveProperty("id");
+    expect(shape.xpub).toBe("test-party-id");
+    // Should not call getAddress since we have xpub
+    expect(mockedResolver).not.toHaveBeenCalled();
+  });
+
+  it("should sync without device when account has publicKey but no xpub", async () => {
+    mockedGetBalance.mockResolvedValue([]); // Empty balances since no xpub
+    mockedGetOperations.mockResolvedValue({
+      operations: [],
+    });
+
+    const infoWithPublicKey = createMockCantonAccountShapeInfo({
+      deviceId: undefined, // No device
+      initialAccount: {
+        xpub: "", // Missing xpub
+        cantonResources: {
+          publicKey: "test-public-key",
+          instrumentUtxoCounts: {},
+          pendingTransferProposals: [],
+        },
+      } as unknown as CantonAccount,
+    });
+
+    const getAccountShape = makeGetAccountShape(fakeSignerContext);
+    const shape = await getAccountShape(infoWithPublicKey, { paginationConfig: {} });
+
+    expect(shape).toHaveProperty("id");
+    // Should not call getAddress since we have publicKey (even though xpub is missing)
+    expect(mockedResolver).not.toHaveBeenCalled();
+  });
+
+  it("should sync without device when account has both xpub and publicKey", async () => {
+    mockedGetBalance.mockResolvedValue(createMockInstrumentBalances());
+    mockedGetOperations.mockResolvedValue({
+      operations: [createMockOperationView()],
+    });
+
+    const infoWithBoth = createMockCantonAccountShapeInfo({
+      deviceId: undefined, // No device
+      initialAccount: {
+        xpub: "test-party-id",
+        cantonResources: {
+          publicKey: "test-public-key",
+          instrumentUtxoCounts: {},
+          pendingTransferProposals: [],
+        },
+      } as unknown as CantonAccount,
+    });
+
+    const getAccountShape = makeGetAccountShape(fakeSignerContext);
+    const shape = await getAccountShape(infoWithBoth, { paginationConfig: {} });
+
+    expect(shape).toHaveProperty("id");
+    expect(shape.xpub).toBe("test-party-id");
+    // Should not call getAddress since we have both values
+    expect(mockedResolver).not.toHaveBeenCalled();
+  });
 });

package/src/bridge/sync.ts

@@ -13,7 +13,7 @@ import {
 import { getBalance, type CantonBalance } from "../common-logic/account/getBalance";
 import coinConfig from "../config";
 import resolver from "../signer";
-import { CantonAccount, CantonSigner } from "../types";
+import { CantonAccount, CantonResources, CantonSigner } from "../types";
 import { isAccountOnboarded } from "./onboard";
 import { isCantonAccountEmpty } from "../helpers";
 
@@ -93,20 +93,25 @@ export function makeGetAccountShape(
   return async info => {
     const { address, currency, derivationMode, derivationPath, initialAccount } = info;
 
-    let xpubOrAddress = initialAccount?.xpub || "";
+    let isOnboarded = initialAccount?.cantonResources?.isOnboarded ?? false;
+    let xpubOrAddress = (initialAccount?.xpub || initialAccount?.cantonResources?.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) {
-        xpubOrAddress = partyId;
+      const result = await isAccountOnboarded(currency, publicKey);
+      isOnboarded = result.isOnboarded;
+
+      if (isOnboarded && result.partyId) {
+        xpubOrAddress = result.partyId;
       }
     }
 
@@ -161,14 +166,19 @@ export function makeGetAccountShape(
       operations = mergeOps(oldOperations, newOperations);
     }
 
+    const cantonResources: CantonResources = {
+      isOnboarded,
+      instrumentUtxoCounts,
+      pendingTransferProposals,
+      ...(publicKey && { publicKey }),
+      xpub: xpubOrAddress,
+    };
+
     const used = !isCantonAccountEmpty({
       operationsCount: operations.length,
       balance: totalBalance,
       subAccounts: initialAccount?.subAccounts ?? [],
-      cantonResources: {
-        instrumentUtxoCounts,
-        pendingTransferProposals,
-      },
+      cantonResources,
     });
 
     const blockHeight = await getLedgerEnd(currency);
@@ -192,10 +202,7 @@ export function makeGetAccountShape(
       spendableBalance,
       xpub: xpubOrAddress,
       used,
-      cantonResources: {
-        instrumentUtxoCounts,
-        pendingTransferProposals,
-      },
+      cantonResources,
     };
 
     return shape;

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

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

package/src/network/gateway.test.ts

@@ -1,6 +1,15 @@
-import { getBalance, type GetBalanceResponse, type InstrumentBalance } from "./gateway";
+import {
+  getBalance,
+  isPartyAlreadyExists,
+  submitOnboarding,
+  type GetBalanceResponse,
+  type InstrumentBalance,
+  type OnboardingPrepareResponse,
+} from "./gateway";
 import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import coinConfig from "../config";
+import { TopologyChangeError } from "../types/errors";
+import { LedgerAPI4xx } from "@ledgerhq/errors";
 
 jest.mock("@ledgerhq/live-network", () => ({
   __esModule: true,
@@ -31,7 +40,7 @@ describe("getBalance", () => {
 
   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",
@@ -63,4 +72,57 @@ describe("getBalance", () => {
 
     expect(result).toEqual(mockResponse.balances);
   });
+
+  it("should handle PARTY_ALREADY_EXISTS error", async () => {
+    const mockPartyId = "test-party-id-123";
+    const mockPublicKey = "test-public-key-456";
+    const error = new LedgerAPI4xx("Party already exists", {
+      status: 409,
+      url: undefined,
+      method: "POST",
+    });
+    const mockPrepareResponse: OnboardingPrepareResponse = {
+      party_id: mockPartyId,
+      party_name: "Test Party",
+      public_key_fingerprint: "fingerprint",
+      transactions: {
+        namespace_transaction: {
+          serialized: "",
+          transaction: { operation: "", serial: 0, mapping: {} },
+          hash: "",
+        },
+        party_to_key_transaction: {
+          serialized: "",
+          transaction: { operation: "", serial: 0, mapping: {} },
+          hash: "",
+        },
+        party_to_participant_transaction: {
+          serialized: "",
+          transaction: { operation: "", serial: 0, mapping: {} },
+          hash: "",
+        },
+        combined_hash: "",
+      },
+    };
+
+    mockNetwork.mockRejectedValue(error);
+
+    const result = await submitOnboarding(mockCurrency, mockPublicKey, mockPrepareResponse, {
+      signature: "test-signature",
+    });
+
+    expect(isPartyAlreadyExists(error)).toBe(true);
+    expect(result.party).toEqual({ party_id: mockPartyId, public_key: mockPublicKey });
+  });
+
+  it("should handle PARTY_NOT_FOUND_BY_ID error", async () => {
+    const partyNotFoundError = new LedgerAPI4xx("Party not found", {
+      status: 400,
+      url: undefined,
+      method: "GET",
+    });
+    mockNetwork.mockRejectedValue(partyNotFoundError);
+
+    await expect(getBalance(mockCurrency, "test-party-id")).rejects.toThrow(TopologyChangeError);
+  });
 });