@ledgerhq/coin-canton 0.7.0-nightly.2 → 0.7.0-nightly.3

package/src/bridge/sync.ts

@@ -1,11 +1,14 @@
 import BigNumber from "bignumber.js";
 import { Operation, OperationType } from "@ledgerhq/types-live";
-import { decodeAccountId, encodeAccountId } from "@ledgerhq/coin-framework/account/index";
+import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
 import { GetAccountShape, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { getBalance, getLedgerEnd, getOperations, type OperationInfo } from "../network/gateway";
-import { CantonAccount } from "../types";
 import coinConfig from "../config";
+import resolver from "../signer";
+import { CantonAccount, CantonSigner } from "../types";
+import { isAccountOnboarded, isAccountAuthorized } from "./onboard";
 
 const txInfoToOperationAdapter =
   (accountId: string, partyId: string) =>
@@ -30,7 +33,6 @@ const txInfoToOperationAdapter =
     } else if (txInfo.type === "Initialize") {
       type = "PRE_APPROVAL";
     }
-
     const value = new BigNumber(transferValue);
     const feeValue = new BigNumber(fee);
     const memo = details.metadata.reason;
@@ -65,76 +67,89 @@ const filterOperations = (
   return transactions.map(txInfoToOperationAdapter(accountId, partyId));
 };
 
-export const getAccountShape: GetAccountShape<CantonAccount> = async info => {
-  const { address, initialAccount, currency, derivationMode, derivationPath, rest } = info;
-
-  const xpubOrAddress = (
-    (initialAccount?.id && decodeAccountId(initialAccount.id).xpubOrAddress) ||
-    ""
-  ).replace(/:/g, "_");
-  const partyId =
-    rest?.cantonResources?.partyId ||
-    initialAccount?.cantonResources?.partyId ||
-    xpubOrAddress.replace(/_/g, ":");
-
-  const accountId = encodeAccountId({
-    type: "js",
-    version: "2",
-    currencyId: currency.id,
-    xpubOrAddress,
-    derivationMode,
-  });
-
-  // Account info retrieval + spendable balance calculation
-  // const accountInfo = await getAccountInfo(address);
-  const balances = await getBalance(currency, partyId);
-
-  const balanceData = balances.find(
-    balance => balance.instrument_id === coinConfig.getCoinConfig(currency).nativeInstrumentId,
-  ) || {
-    instrument_id: coinConfig.getCoinConfig(currency).nativeInstrumentId,
-    amount: 0,
-    locked: false,
-  };
+export function makeGetAccountShape(
+  signerContext: SignerContext<CantonSigner>,
+): GetAccountShape<CantonAccount> {
+  return async info => {
+    const { address, currency, derivationMode, derivationPath, initialAccount } = info;
+
+    let xpubOrAddress = initialAccount?.xpub || "";
 
-  const balance = new BigNumber(balanceData.amount);
-  const reserveMin = coinConfig.getCoinConfig(currency).minReserve || 0;
-  const lockedAmount = balanceData.locked ? balance : new BigNumber(0);
-  const spendableBalance = BigNumber.max(
-    0,
-    balance.minus(lockedAmount).minus(BigNumber(reserveMin)),
-  );
-
-  let operations: Operation[] = [];
-  // Tx history fetching if xpubOrAddress is not empty
-  if (xpubOrAddress) {
-    const oldOperations = initialAccount?.operations || [];
-    const startAt = oldOperations.length ? (oldOperations[0].blockHeight || 0) + 1 : 0;
-    const transactionData = await getOperations(currency, partyId, {
-      cursor: startAt,
-      limit: 100,
+    if (!xpubOrAddress) {
+      const getAddress = resolver(signerContext);
+      const { publicKey } = await getAddress(info.deviceId || "", {
+        path: derivationPath,
+        currency: currency,
+        derivationMode: derivationMode,
+        verify: false,
+      });
+
+      const { isOnboarded, partyId } = await isAccountOnboarded(currency, publicKey);
+      if (isOnboarded && partyId) {
+        xpubOrAddress = partyId;
+      }
+    }
+
+    const accountId = encodeAccountId({
+      type: "js",
+      version: "2",
+      currencyId: currency.id,
+      xpubOrAddress: xpubOrAddress,
+      derivationMode,
     });
 
-    const newOperations = filterOperations(transactionData.operations, accountId, partyId);
-    operations = mergeOps(oldOperations, newOperations);
-  }
-  // blockheight retrieval
-  const blockHeight = await getLedgerEnd(currency);
-  // We return the new account shape
-  const shape = {
-    id: accountId,
-    xpub: xpubOrAddress,
-    blockHeight,
-    balance,
-    spendableBalance,
-    operations,
-    operationsCount: operations.length,
-    freshAddress: address,
-    freshAddressPath: derivationPath,
-    cantonResources: {
-      partyId,
-    },
-  };
+    const { nativeInstrumentId } = coinConfig.getCoinConfig(currency);
+    const balances = xpubOrAddress ? await getBalance(currency, xpubOrAddress) : [];
+    const balanceData = balances.find(balance =>
+      balance.instrument_id.includes(nativeInstrumentId),
+    ) || {
+      instrument_id: nativeInstrumentId,
+      amount: 0,
+      locked: false,
+    };
+    const balance = new BigNumber(balanceData.amount);
+    const reserveMin = new BigNumber(coinConfig.getCoinConfig(currency).minReserve || 0);
+    const lockedAmount = balanceData.locked ? balance : new BigNumber(0);
+    const spendableBalance = BigNumber.max(0, balance.minus(lockedAmount).minus(reserveMin));
 
-  return shape;
-};
+    let operations: Operation[] = [];
+    if (xpubOrAddress) {
+      const oldOperations = initialAccount?.operations || [];
+      const startAt = oldOperations.length ? (oldOperations[0].blockHeight || 0) + 1 : 0;
+      const transactionData = await getOperations(currency, xpubOrAddress, {
+        cursor: startAt,
+        limit: 100,
+      });
+      const newOperations = filterOperations(transactionData.operations, accountId, xpubOrAddress);
+      operations = mergeOps(oldOperations, newOperations);
+    }
+
+    const isAuthorized = await isAccountAuthorized(operations, xpubOrAddress);
+    const used = isAuthorized && balance.gt(0);
+
+    const blockHeight = await getLedgerEnd(currency);
+
+    const creationDate =
+      operations.length > 0
+        ? new Date(Math.min(...operations.map(op => op.date.getTime())))
+        : new Date();
+
+    const shape = {
+      id: accountId,
+      type: "Account" as const,
+      balance,
+      blockHeight,
+      creationDate,
+      lastSyncDate: new Date(),
+      freshAddress: address,
+      seedIdentifier: address,
+      operations,
+      operationsCount: operations.length,
+      spendableBalance,
+      xpub: xpubOrAddress,
+      used,
+    };
+
+    return shape;
+  };
+}

package/src/common-logic/utils.test.ts

@@ -13,6 +13,10 @@ describe("utils", () => {
         "user123::42",
         "canton_1a2b3c4d5e6f7g8h9i0j1k2l3m4n5o6p7q8r9s0t1u2v3w4x5y6z::123",
         "test::123456789",
+        "abc::abc", // letters after ::
+        "test::ABC123", // mixed case letters and numbers
+        "user::a1b2c3", // alphanumeric after ::
+        "contract::XyZ789", // mixed case with numbers
       ];
 
       validAddresses.forEach(address => {
@@ -24,20 +28,23 @@ describe("utils", () => {
       const invalidAddresses = [
         "", // empty string
         "::123", // no characters before ::
-        "abc::", // no numbers after ::
+        "abc::", // no characters after ::
         "abc:123", // single colon instead of double
-        "abc::abc", // letters instead of numbers after ::
         "abc::", // empty after ::
         "::", // only colons
         "abc", // no colons
         "123", // no colons
-        "abc::123abc", // mixed letters and numbers after ::
         "abc::123.456", // decimal numbers
         "abc::-123", // negative numbers
         "abc::+123", // positive sign
-        "abc:: 123", // space before number
-        "abc::123 ", // space after number
+        "abc:: 123", // space before alphanumeric
+        "abc::123 ", // space after alphanumeric
         "abc:: 123", // space after ::
+        "abc::123-abc", // dash in alphanumeric part
+        "abc::123_abc", // underscore in alphanumeric part
+        "abc::123.abc", // dot in alphanumeric part
+        "abc::123 abc", // space in alphanumeric part
+        "abc::", // empty after ::
       ];
 
       invalidAddresses.forEach(address => {
@@ -46,18 +53,26 @@ describe("utils", () => {
     });
 
     it("should handle edge cases", () => {
-      expect(isRecipientValid("a::1")).toBe(true); // minimum valid case
+      expect(isRecipientValid("a::1")).toBe(true); // minimum valid case with number
+      expect(isRecipientValid("a::a")).toBe(true); // minimum valid case with letter
       expect(isRecipientValid("1::1")).toBe(true); // number before ::
+      expect(isRecipientValid("1::a")).toBe(true); // number before ::, letter after
       expect(isRecipientValid("_::1")).toBe(true); // underscore before ::
+      expect(isRecipientValid("_::a")).toBe(true); // underscore before ::, letter after
       expect(isRecipientValid("-::1")).toBe(true); // dash before ::
+      expect(isRecipientValid("-::a")).toBe(true); // dash before ::, letter after
       expect(isRecipientValid(".::1")).toBe(true); // dot before ::
+      expect(isRecipientValid(".::a")).toBe(true); // dot before ::, letter after
     });
 
     it("should handle addresses with spaces and multiple colons", () => {
       // These are valid according to our regex but might not be ideal Canton addresses
       expect(isRecipientValid(" abc::123")).toBe(true); // space before address
+      expect(isRecipientValid(" abc::abc")).toBe(true); // space before address with letters
       expect(isRecipientValid("abc ::123")).toBe(true); // space before ::
+      expect(isRecipientValid("abc ::abc")).toBe(true); // space before :: with letters
       expect(isRecipientValid("abc::123::456")).toBe(true); // multiple ::
+      expect(isRecipientValid("abc::abc::def")).toBe(true); // multiple :: with letters
     });
   });
 

package/src/common-logic/utils.ts

@@ -8,9 +8,9 @@ export const validateTag = (tag: BigNumber) => {
   );
 };
 
-const CANTON_ADDRESS_REGEX = /^.+::\d+$/;
+const CANTON_ADDRESS_REGEX = /^.+::[a-zA-Z0-9]+$/;
 
 export function isRecipientValid(recipient: string): boolean {
-  // Canton address format: at least 1 character :: at least 1 number
+  // Canton address format: at least 1 character :: at least 1 alphanumeric character
   return CANTON_ADDRESS_REGEX.test(recipient);
 }

package/src/config.ts

@@ -7,7 +7,7 @@ export type CantonConfig = {
   gatewayUrl?: string;
   // TODELETE
   minReserve?: number;
-  networkType: "mainnet" | "devnet" | "localnet";
+  networkType: "mainnet" | "devnet" | "testnet" | "localnet";
   useGateway?: boolean;
   nativeInstrumentId: string;
   fee?: number;

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

@@ -12,6 +12,7 @@ import {
   submitTapRequest,
   preparePreApprovalTransaction,
   submitPreApprovalTransaction,
+  type OnboardingPrepareResponse,
 } from "./gateway";
 import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
@@ -25,6 +26,8 @@ describe("gateway (devnet)", () => {
     partyId: string;
   } | null = null;
 
+  let prepareResponse: OnboardingPrepareResponse | null = null;
+
   beforeAll(async () => {
     coinConfig.setCoinConfig(() => ({
       gatewayUrl: "https://canton-gateway.api.live.ledger-test.com",
@@ -35,7 +38,7 @@ describe("gateway (devnet)", () => {
         type: "active",
       },
     }));
-  }, 60000);
+  });
 
   const getOnboardedAccount = () => {
     if (!onboardedAccount) {
@@ -56,7 +59,7 @@ describe("gateway (devnet)", () => {
       };
 
       // WHEN
-      const response = await prepareOnboarding(mockCurrency, keyPair.publicKeyHex, "ed25519");
+      const response = await prepareOnboarding(mockCurrency, keyPair.publicKeyHex);
 
       // THEN
       expect(response).toHaveProperty("party_id");
@@ -68,30 +71,26 @@ describe("gateway (devnet)", () => {
       expect(typeof response.party_name).toBe("string");
 
       expect(response.public_key_fingerprint).toBe(keyPair.fingerprint);
-    }, 30000);
+    });
   });
 
   describe("submitOnboarding", () => {
     it("should submit onboarding with proper signature", async () => {
       // GIVEN
       const { keyPair } = getOnboardedAccount();
-      const prepareRequest = { public_key: keyPair.publicKeyHex, public_key_type: "ed25519" };
-      const prepareResponse = await prepareOnboarding(
-        mockCurrency,
-        keyPair.publicKeyHex,
-        "ed25519",
-      );
+      // Save prepare response for next test
+      prepareResponse = await prepareOnboarding(mockCurrency, keyPair.publicKeyHex);
       const signature = keyPair.sign(prepareResponse.transactions.combined_hash);
 
       // WHEN
       const response = await submitOnboarding(
         mockCurrency,
-        prepareRequest,
+        keyPair.publicKeyHex,
         prepareResponse,
         signature,
       );
 
-      // Save onboarded account for all tests that need a valid party ID
+      // Save onboarded account for next tests that need a valid party ID
       onboardedAccount = {
         keyPair,
         partyId: response.party.party_id,
@@ -103,6 +102,31 @@ describe("gateway (devnet)", () => {
       expect(response.party).toHaveProperty("public_key");
       expect(response.party.public_key).toBe(keyPair.publicKeyHex);
     }, 30000);
+
+    const testIfPrepared = prepareResponse ? it.skip : it;
+    testIfPrepared(
+      "should not throw when already onboarded",
+      async () => {
+        // GIVEN
+        const { keyPair } = 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.public_key).toBe(keyPair.publicKeyHex);
+      },
+      30000,
+    );
   });
 
   describe("getLedgerEnd", () => {
@@ -125,17 +149,20 @@ describe("gateway (devnet)", () => {
   });
 
   describe("getPartyById", () => {
-    it.skip("should return party info", async () => {
-      const party = await getPartyById(mockCurrency, "4f2e1485107adf5f");
+    it("should return party info", async () => {
+      const party = await getPartyById(
+        mockCurrency,
+        "ldg::12208b12fa34be8a079bcbb68bba828e58313046c4208855b39885fab48661322e68",
+      );
       expect(party).toBeDefined();
     });
   });
 
   describe("getPartyByPubKey", () => {
-    it.skip("should return party info", async () => {
+    it("should return party info", async () => {
       const party = await getPartyByPubKey(
         mockCurrency,
-        "122027c6dbbbdbffe0fa3122ae05175f3b9328e879e9ce96b670354deb64a45683c1",
+        "c5cdb19624833f9a929a0125978c886ec4297320c14cea6bf667dc1d23a8e650",
       );
       expect(party).toBeDefined();
     });
@@ -153,7 +180,7 @@ describe("gateway (devnet)", () => {
   });
 
   describe("prepareTapRequest", () => {
-    it("should prepare tap request for onboarded party", async () => {
+    it.skip("should prepare tap request for onboarded party", async () => {
       // GIVEN
       const { partyId } = getOnboardedAccount();
       const amount = 1000;
@@ -166,11 +193,11 @@ describe("gateway (devnet)", () => {
       expect(response).toHaveProperty("hash");
       expect(typeof response.serialized).toBe("string");
       expect(typeof response.hash).toBe("string");
-    }, 30000);
+    });
   });
 
   describe("submitTapRequest", () => {
-    it("should submit tap request with proper signature", async () => {
+    it.skip("should submit tap request with proper signature", async () => {
       // GIVEN
       const { keyPair, partyId } = getOnboardedAccount();
       const tapPrepareResponse = await prepareTapRequest(mockCurrency, {
@@ -191,7 +218,7 @@ describe("gateway (devnet)", () => {
       expect(response).toHaveProperty("update_id");
       expect(typeof response.submission_id).toBe("string");
       expect(typeof response.update_id).toBe("string");
-    }, 30000);
+    });
   });
 
   describe("preparePreApprovalTransaction", () => {
@@ -207,7 +234,7 @@ describe("gateway (devnet)", () => {
       expect(response).toHaveProperty("hash");
       expect(typeof response.serialized).toBe("string");
       expect(typeof response.hash).toBe("string");
-    }, 30000);
+    });
   });
 
   describe("submitPreApprovalTransaction", () => {
@@ -232,6 +259,6 @@ describe("gateway (devnet)", () => {
       expect(response.isApproved).toBe(true);
       expect(typeof response.submissionId).toBe("string");
       expect(typeof response.updateId).toBe("string");
-    }, 30000);
+    });
   });
 });

package/src/network/gateway.ts

@@ -11,7 +11,7 @@ import {
 } from "../types/onboard";
 import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
-type OnboardingPrepareResponse = {
+export type OnboardingPrepareResponse = {
   party_id: string;
   party_name: string;
   public_key_fingerprint: string;
@@ -274,7 +274,7 @@ export type OperationInfo =
 
 const getGatewayUrl = (currency: CryptoCurrency) => coinConfig.getCoinConfig(currency).gatewayUrl;
 const getNodeId = (currency: CryptoCurrency) =>
-  coinConfig.getCoinConfig(currency).nodeId || "ledger-devnet-stg";
+  coinConfig.getCoinConfig(currency).nodeId || "ledger-live-devnet";
 const getNetworkType = (currency: CryptoCurrency) => coinConfig.getCoinConfig(currency).networkType;
 
 const gatewayNetwork = <T, U = unknown>(req: LiveNetworkRequest<U>) => {
@@ -288,11 +288,7 @@ const gatewayNetwork = <T, U = unknown>(req: LiveNetworkRequest<U>) => {
   });
 };
 
-export async function prepareOnboarding(
-  currency: CryptoCurrency,
-  pubKey: string,
-  pubKeyType: 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`;
@@ -302,29 +298,54 @@ export async function prepareOnboarding(
     url: fullUrl,
     data: {
       public_key: pubKey,
-      public_key_type: pubKeyType,
+      public_key_type: "ed25519",
     },
   });
 
   return data;
 }
 
+type OnboardingSubmitError409 = {
+  partyId: string;
+  status: 409;
+  type: "PARTY_ALREADY_EXISTS";
+  message: string;
+};
+
 export async function submitOnboarding(
   currency: CryptoCurrency,
-  prepareRequest: OnboardingPrepareRequest,
+  publicKey: string,
   prepareResponse: OnboardingPrepareResponse,
   signature: string,
 ) {
-  const { data } = await gatewayNetwork<OnboardingSubmitResponse, OnboardingSubmitRequest>({
-    method: "POST",
-    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/onboarding/submit`,
-    data: {
-      prepare_request: prepareRequest,
-      prepare_response: prepareResponse,
-      signature,
-    },
-  });
-  return data;
+  try {
+    const { data } = await gatewayNetwork<OnboardingSubmitResponse, OnboardingSubmitRequest>({
+      method: "POST",
+      url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/onboarding/submit`,
+      data: {
+        prepare_request: {
+          public_key: publicKey,
+          public_key_type: "ed25519",
+        },
+        prepare_response: prepareResponse,
+        signature,
+      },
+    });
+    return data;
+  } 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: partyId,
+          public_key: publicKey,
+        },
+      };
+    }
+
+    throw e;
+  }
 }
 
 export async function submit(
@@ -344,10 +365,7 @@ export async function submit(
   return data;
 }
 
-export async function getBalance(
-  currency: CryptoCurrency,
-  partyId: string,
-): Promise<InstrumentBalance[]> {
+export async function getBalance(currency: CryptoCurrency, partyId: string) {
   const { data } = await gatewayNetwork<InstrumentBalance[]>({
     method: "GET",
     url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/balance`,
@@ -421,7 +439,7 @@ enum TransactionType {
 export async function prepareTapRequest(
   currency: CryptoCurrency,
   { partyId, amount = 1000000 }: PrepareTapRequest,
-): Promise<PrepareTapResponse> {
+) {
   if (getNetworkType(currency) === "mainnet") {
     return {
       serialized: "",
@@ -429,11 +447,11 @@ export async function prepareTapRequest(
       hash: "",
     };
   }
-  const { data } = await gatewayNetwork<PrepareTapResponse, { amount: number; type: string }>({
+  const { data } = await gatewayNetwork<PrepareTapResponse, { amount: string; type: string }>({
     method: "POST",
     url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/prepare`,
     data: {
-      amount: parseInt(amount.toString(), 10), // Convert to integer to avoid scientific notation
+      amount: amount.toString(),
       type: TransactionType.TAP_REQUEST,
     },
   });
@@ -454,7 +472,7 @@ type SubmitTapRequestResponse = {
 export async function submitTapRequest(
   currency: CryptoCurrency,
   { partyId, serialized, signature }: SubmitTapRequestRequest,
-): Promise<SubmitTapRequestResponse> {
+) {
   const { data } = await gatewayNetwork<
     SubmitTapRequestResponse,
     Omit<SubmitTapRequestRequest, "partyId">
@@ -473,7 +491,7 @@ export async function prepareTransferRequest(
   currency: CryptoCurrency,
   partyId: string,
   params: PrepareTransferRequest,
-): Promise<PrepareTransferResponse> {
+) {
   const { data } = await gatewayNetwork<PrepareTransferResponse, PrepareTransferRequest>({
     method: "POST",
     url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/prepare`,
@@ -490,10 +508,7 @@ export async function getLedgerEnd(currency: CryptoCurrency): Promise<number> {
   return data;
 }
 
-export async function preparePreApprovalTransaction(
-  currency: CryptoCurrency,
-  partyId: string,
-): Promise<PrepareTransactionResponse> {
+export async function preparePreApprovalTransaction(currency: CryptoCurrency, partyId: string) {
   const { data } = await gatewayNetwork<PrepareTransactionResponse, PrepareTransactionRequest>({
     method: "POST",
     url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/prepare`,
@@ -510,7 +525,7 @@ export async function submitPreApprovalTransaction(
   partyId: string,
   { serialized }: PrepareTransactionResponse,
   signature: string,
-): Promise<PreApprovalResult> {
+) {
   const { data } = await gatewayNetwork<SubmitTransactionResponse, SubmitTransactionRequest>({
     method: "POST",
     url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/submit`,
@@ -524,5 +539,5 @@ export async function submitPreApprovalTransaction(
     isApproved: true,
     submissionId: data.submission_id,
     updateId: data.update_id,
-  };
+  } satisfies PreApprovalResult;
 }

package/src/types/bridge.ts

@@ -9,26 +9,26 @@ import type {
   TransactionStatusCommon,
   TransactionStatusCommonRaw,
 } from "@ledgerhq/types-live";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import type {
   CantonOnboardProgress,
   CantonOnboardResult,
-  CantonPreApprovalProgress,
-  CantonPreApprovalResult,
+  CantonAuthorizeProgress,
+  CantonAuthorizeResult,
 } from "./onboard";
-import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 export interface CantonCurrencyBridge extends CurrencyBridge {
   onboardAccount: (
     currency: CryptoCurrency,
     deviceId: string,
-    derivationPath: string,
+    creatableAccount: Account,
   ) => Observable<CantonOnboardProgress | CantonOnboardResult>;
   authorizePreapproval: (
     currency: CryptoCurrency,
     deviceId: string,
-    derivationPath: string,
+    creatableAccount: Account,
     partyId: string,
-  ) => Observable<CantonPreApprovalProgress | CantonPreApprovalResult>;
+  ) => Observable<CantonAuthorizeProgress | CantonAuthorizeResult>;
 }
 
 export type NetworkInfo = {
@@ -60,16 +60,5 @@ export type TransactionRaw = TransactionCommonRaw & {
 export type TransactionStatus = TransactionStatusCommon;
 export type TransactionStatusRaw = TransactionStatusCommonRaw;
 
-export type CantonResources = {
-  partyId: string;
-};
-export type CantonResourcesRaw = {
-  partyId: string;
-};
-
-export type CantonAccount = Account & {
-  cantonResources?: CantonResources;
-};
-export type CantonAccountRaw = AccountRaw & {
-  cantonResources: CantonResourcesRaw;
-};
+export type CantonAccount = Account;
+export type CantonAccountRaw = AccountRaw;