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

package/src/bridge/serialization.ts

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

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

package/src/bridge/sync.ts

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

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

@@ -30,7 +30,7 @@ describe("gateway (devnet)", () => {
 
   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,
       nativeInstrumentId: "Amulet",
       networkType: "devnet",
@@ -126,29 +126,6 @@ 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,15 +1,6 @@
-import {
-  getBalance,
-  isPartyAlreadyExists,
-  submitOnboarding,
-  type GetBalanceResponse,
-  type InstrumentBalance,
-  type OnboardingPrepareResponse,
-} from "./gateway";
+import { getBalance, type GetBalanceResponse, type InstrumentBalance } 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,
@@ -40,7 +31,7 @@ describe("getBalance", () => {
 
   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",
@@ -72,57 +63,4 @@ 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);
-  });
 });

package/src/network/gateway.ts

@@ -1,6 +1,5 @@
 import network from "@ledgerhq/live-network";
-import type { LiveNetworkRequest, LiveNetworkResponse } from "@ledgerhq/live-network/network";
-import { makeLRUCache, minutes } from "@ledgerhq/live-network/cache";
+import type { LiveNetworkRequest } from "@ledgerhq/live-network/network";
 import { getEnv } from "@ledgerhq/live-env";
 import coinConfig from "../config";
 import {
@@ -12,7 +11,6 @@ import {
 } from "../types/onboard";
 import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import type { CantonSignature } from "../types/signer";
-import { TopologyChangeError } from "../types/errors";
 
 export type OnboardingPrepareResponse = {
   party_id: string;
@@ -21,29 +19,17 @@ export type OnboardingPrepareResponse = {
   transactions: {
     namespace_transaction: {
       serialized: string;
-      transaction: {
-        operation: string;
-        serial: number;
-        mapping: Record<string, unknown>;
-      };
+      json: object;
       hash: string;
     };
     party_to_key_transaction: {
       serialized: string;
-      transaction: {
-        operation: string;
-        serial: number;
-        mapping: Record<string, unknown>;
-      };
+      json: object;
       hash: string;
     };
     party_to_participant_transaction: {
       serialized: string;
-      transaction: {
-        operation: string;
-        serial: number;
-        mapping: Record<string, unknown>;
-      };
+      json: object;
       hash: string;
     };
     combined_hash: string;
@@ -328,56 +314,23 @@ export type OperationInfo =
     };
 
 const getGatewayUrl = (currency: CryptoCurrency) => coinConfig.getCoinConfig(currency).gatewayUrl;
-const getNodeId = (currency: CryptoCurrency) => {
-  const overrideNodeId = getEnv("CANTON_NODE_ID_OVERRIDE");
-  if (overrideNodeId) {
-    return overrideNodeId;
-  }
-  return coinConfig.getCoinConfig(currency).nodeId || "ledger-live-devnet";
-};
+const getNodeId = (currency: CryptoCurrency) =>
+  coinConfig.getCoinConfig(currency).nodeId || "ledger-live-devnet";
 export const getNetworkType = (currency: CryptoCurrency) =>
   coinConfig.getCoinConfig(currency).networkType;
 
-export const isPartyNotFound = (error: unknown): boolean => {
-  if (error instanceof Error) {
-    const errorMessage = error.message.toLowerCase().replace(/_/g, " ");
-    return errorMessage.includes("party") && errorMessage.includes("not found");
-  }
-  return false;
-};
-
-export const isPartyAlreadyExists = (error: unknown): boolean => {
-  if (error instanceof Error) {
-    const errorMessage = error.message.toLowerCase().replace(/_/g, " ");
-    return errorMessage.includes("party") && errorMessage.includes("already exists");
-  }
-  return false;
-};
-
-const gatewayNetwork = async <T, U = unknown>(
-  req: LiveNetworkRequest<U>,
-): Promise<LiveNetworkResponse<T>> => {
+const gatewayNetwork = <T, U = unknown>(req: LiveNetworkRequest<U>) => {
   const API_KEY = getEnv("CANTON_API_KEY");
-  try {
-    return await network<T, U>({
-      ...req,
-      headers: {
-        ...(req.headers || {}),
-        ...(API_KEY && { "X-Ledger-Canton-Api-Key": API_KEY }),
-      },
-    });
-  } catch (error) {
-    if (isPartyNotFound(error)) {
-      throw new TopologyChangeError("Topology change detected. Re-onboarding required.");
-    }
-    throw error;
-  }
+  return network<T, U>({
+    ...req,
+    headers: {
+      ...(req.headers || {}),
+      ...(API_KEY && { "X-Ledger-Canton-Api-Key": API_KEY }),
+    },
+  });
 };
 
-export async function prepareOnboarding(
-  currency: CryptoCurrency,
-  pubKey: string,
-): Promise<OnboardingPrepareResponse> {
+export async function prepareOnboarding(currency: CryptoCurrency, pubKey: string) {
   const gatewayUrl = getGatewayUrl(currency);
   const nodeId = getNodeId(currency);
   const fullUrl = `${gatewayUrl}/v1/node/${nodeId}/onboarding/prepare`;
@@ -394,38 +347,13 @@ export async function prepareOnboarding(
   return data;
 }
 
-export async function isTopologyChangeRequired(currency: CryptoCurrency, pubKey: string) {
-  try {
-    const response = await prepareOnboarding(currency, pubKey);
-    // if response is not undefined (we have a transaction to sign) topology change is required
-    if (response) {
-      return true;
-    }
-    return false;
-  } catch (error) {
-    if (isPartyAlreadyExists(error)) {
-      return false;
-    }
-    throw error;
-  }
-}
-
-const getIsTopologyChangeRequiredCacheKey = (currency: CryptoCurrency, pubKey: string): string => {
-  const nodeId = getNodeId(currency);
-  return `${pubKey}_${nodeId}`;
+type OnboardingSubmitError409 = {
+  partyId: string;
+  status: 409;
+  type: "PARTY_ALREADY_EXISTS";
+  message: string;
 };
 
-export const isTopologyChangeRequiredCached = makeLRUCache(
-  isTopologyChangeRequired,
-  getIsTopologyChangeRequiredCacheKey,
-  minutes(10),
-);
-
-export function clearIsTopologyChangeRequiredCache(currency: CryptoCurrency, pubKey: string): void {
-  const cacheKey = getIsTopologyChangeRequiredCacheKey(currency, pubKey);
-  isTopologyChangeRequiredCached.clear(cacheKey);
-}
-
 export async function submitOnboarding(
   currency: CryptoCurrency,
   publicKey: string,
@@ -447,19 +375,19 @@ export async function submitOnboarding(
       },
     });
     return data;
-  } catch (error) {
-    if (isPartyAlreadyExists(error)) {
-      // If party already exists, use party_id from prepare response
-      // The network layer strips custom properties from errors, so we can't extract partyId from error
+  } catch (e) {
+    if (e instanceof Error && "type" in e && e.type === "PARTY_ALREADY_EXISTS") {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      const { partyId } = e as unknown as OnboardingSubmitError409;
       return {
         party: {
-          party_id: prepareResponse.party_id,
+          party_id: partyId,
           public_key: publicKey,
         },
       };
     }
 
-    throw error;
+    throw e;
   }
 }
 

package/src/test/cantonTestUtils.ts

@@ -225,7 +225,7 @@ export function createMockSigner(keyPair: CantonTestKeyPair) {
 
       const cleanHash = hashToSign.startsWith("0x") ? hashToSign.slice(2) : hashToSign;
       const signature = keyPair.sign(cleanHash);
-      return { signature };
+      return signature;
     },
   };
 }

package/src/types/bridge.ts

@@ -78,12 +78,10 @@ export type TransactionStatusRaw = TransactionStatusCommonRaw;
 export type CantonResources = {
   instrumentUtxoCounts: Record<string, number>;
   pendingTransferProposals: TransferProposal[];
-  publicKey: string;
 };
 export type CantonResourcesRaw = {
   instrumentUtxoCounts: Record<string, number>;
   pendingTransferProposals: TransferProposal[];
-  publicKey: string;
 };
 
 export type CantonAccount = Account & {

package/src/types/errors.ts

@@ -4,5 +4,3 @@ export const SimulationError = createCustomErrorClass("SimulationError");
 
 export const TooManyUtxosCritical = createCustomErrorClass("TooManyUtxosCritical");
 export const TooManyUtxosWarning = createCustomErrorClass("TooManyUtxosWarning");
-
-export const TopologyChangeError = createCustomErrorClass("TopologyChangeError");