@ledgerhq/coin-canton 0.7.0 → 0.8.0-nightly.0

package/src/bridge/onboard.ts

@@ -1,10 +1,8 @@
 import { Observable } from "rxjs";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
-import { emptyHistoryCache } from "@ledgerhq/coin-framework/account/index";
-import { getDerivationModesForCurrency } from "@ledgerhq/coin-framework/derivation";
-import { getAccountShape } from "./sync";
-import { CantonAccount, CantonSigner } from "../types";
-import type { Account, DerivationMode } from "@ledgerhq/types-live";
+import type { Account, Operation } from "@ledgerhq/types-live";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { log } from "@ledgerhq/logs";
 import {
   prepareOnboarding,
   submitOnboarding,
@@ -16,148 +14,84 @@ import {
 } from "../network/gateway";
 import {
   OnboardStatus,
-  PreApprovalStatus,
+  AuthorizeStatus,
   CantonOnboardProgress,
   CantonOnboardResult,
-  CantonPreApprovalProgress,
-  CantonPreApprovalResult,
-  PrepareTransactionResponse,
+  CantonAuthorizeProgress,
+  CantonAuthorizeResult,
 } from "../types/onboard";
 import resolver from "../signer";
-import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import type { CantonSigner } from "../types";
 
-async function _getKeypair(
-  signerContext: SignerContext<CantonSigner>,
-  deviceId: string,
-  derivationPath: string,
-) {
-  return signerContext(deviceId, async signer => {
-    const { publicKey, address } = await signer.getAddress(derivationPath);
-    return { signer, publicKey: publicKey.replace("0x", ""), address };
-  });
-}
-
-export const isAccountOnboarded = async (
-  currency: CryptoCurrency,
-  publicKey: string,
-): Promise<{ isOnboarded: boolean; party_id?: string }> => {
+export const isAccountOnboarded = async (currency: CryptoCurrency, publicKey: string) => {
   try {
     const { party_id } = await getPartyByPubKey(currency, publicKey);
 
     if (party_id) {
-      return { isOnboarded: true, party_id };
+      return { isOnboarded: true, partyId: party_id };
     } else {
       return { isOnboarded: false };
     }
   } catch (err) {
-    log("[isAccountOnboarded] Error checking party status (likely not onboarded):", err);
     return { isOnboarded: false };
   }
 };
 
+export const isAccountAuthorized = async (operations: Operation[], partyId: string) => {
+  // temporary solution to check if the account is authorized
+  return operations.some(operation => operation.senders.includes(partyId));
+};
+
 export const buildOnboardAccount =
   (signerContext: SignerContext<CantonSigner>) =>
   (
     currency: CryptoCurrency,
     deviceId: string,
-    derivationPath: string,
+    account: Account,
   ): Observable<CantonOnboardProgress | CantonOnboardResult> =>
-    new Observable(observer => {
+    new Observable(o => {
       async function main() {
-        observer.next({
-          status: OnboardStatus.INIT,
-        });
-        const derivationMode = getDerivationModesForCurrency(currency)[0];
+        o.next({ status: OnboardStatus.INIT });
+
         const getAddress = resolver(signerContext);
-        const { address, publicKey } = await getAddress(deviceId, {
-          path: derivationPath,
+        const { publicKey } = await getAddress(deviceId, {
+          path: account.freshAddressPath,
           currency,
-          derivationMode: derivationMode || "",
+          derivationMode: account.derivationMode,
         });
 
-        observer.next({
-          status: OnboardStatus.PREPARE,
-        });
+        o.next({ status: OnboardStatus.PREPARE });
 
-        const { party_id: partyId } = await isAccountOnboarded(currency, publicKey);
+        let { partyId } = await isAccountOnboarded(currency, publicKey);
         if (partyId) {
-          const account = await createAccount({
-            address,
-            derivationPath,
-            partyId,
-            currency,
-            derivationMode,
-          });
-          observer.next({
-            partyId,
-            account,
-          });
-          observer.complete();
+          o.next({ partyId, account }); // success
           return;
         }
 
-        const preparedTransaction = await prepareOnboarding(currency, publicKey, "ed25519");
+        const preparedTransaction = await prepareOnboarding(currency, publicKey);
+        partyId = preparedTransaction.party_id;
 
-        observer.next({
-          status: OnboardStatus.SIGN,
-        });
+        o.next({ status: OnboardStatus.SIGN });
 
         const signature = await signerContext(deviceId, signer =>
-          signer.signTransaction(derivationPath, preparedTransaction.transactions.combined_hash),
+          signer.signTransaction(
+            account.freshAddressPath,
+            preparedTransaction.transactions.combined_hash,
+          ),
         );
 
-        observer.next({
-          status: OnboardStatus.SUBMIT,
-        });
+        o.next({ status: OnboardStatus.SUBMIT });
 
-        const result = await submitOnboarding(
-          currency,
-          { public_key: publicKey, public_key_type: "ed25519" },
-          preparedTransaction,
-          signature,
-        ).catch(async err => {
-          if (err.type === "PARTY_ALREADY_EXISTS") {
-            const account = await createAccount({
-              address,
-              derivationPath,
-              partyId: preparedTransaction.party_id,
-              currency,
-              derivationMode,
-            });
-            observer.next({
-              partyId: preparedTransaction.party_id,
-              account,
-            });
-            return observer.complete();
-          }
-          throw err;
-        });
-
-        if (result) {
-          observer.next({
-            status: OnboardStatus.SUCCESS,
-          });
-          const account = await createAccount({
-            address,
-            derivationPath,
-            partyId: result.party.party_id,
-            currency,
-            derivationMode,
-          });
-          observer.next({
-            partyId: result.party.party_id,
-            account,
-          });
-        }
+        await submitOnboarding(currency, publicKey, preparedTransaction, signature);
 
-        observer.complete();
+        o.next({ partyId, account }); // success
       }
 
       main().then(
-        () => observer.complete(),
+        () => o.complete(),
         error => {
-          log("[onboardAccount] Error:", error);
-          observer.error(error);
+          log("[canton:onboard] onboardAccount failed:", error);
+          o.error(error);
         },
       );
     });
@@ -167,146 +101,64 @@ export const buildAuthorizePreapproval =
   (
     currency: CryptoCurrency,
     deviceId: string,
-    derivationPath: string,
+    account: Account,
     partyId: string,
-  ): Observable<CantonPreApprovalProgress | CantonPreApprovalResult> =>
-    new Observable(observer => {
+  ): Observable<CantonAuthorizeProgress | CantonAuthorizeResult> =>
+    new Observable(o => {
       async function main() {
-        observer.next({
-          status: PreApprovalStatus.PREPARE,
-        });
+        o.next({ status: AuthorizeStatus.INIT });
 
-        const preparedTransaction: PrepareTransactionResponse = await preparePreApprovalTransaction(
-          currency,
-          partyId,
-        );
+        const isAuthorized = await isAccountAuthorized(account.operations, partyId);
 
-        observer.next({
-          status: PreApprovalStatus.SIGN,
-        });
+        if (!isAuthorized) {
+          o.next({ status: AuthorizeStatus.PREPARE });
 
-        const signature = await signerContext(deviceId, signer =>
-          signer.signTransaction(derivationPath, preparedTransaction.hash),
-        );
+          const preparedTransaction = await preparePreApprovalTransaction(currency, partyId);
 
-        observer.next({
-          status: PreApprovalStatus.SUBMIT,
-        });
+          o.next({ status: AuthorizeStatus.SIGN });
 
-        const { isApproved } = await submitPreApprovalTransaction(
-          currency,
-          partyId,
-          preparedTransaction,
-          signature,
-        );
+          const signature = await signerContext(deviceId, signer =>
+            signer.signTransaction(account.freshAddressPath, preparedTransaction.hash),
+          );
 
-        observer.next({
-          status: PreApprovalStatus.SUCCESS,
-        });
+          o.next({ status: AuthorizeStatus.SUBMIT });
 
-        observer.next({
-          isApproved,
-        });
+          await submitPreApprovalTransaction(currency, partyId, preparedTransaction, signature);
+        }
+
+        o.next({ isApproved: true }); // success
 
         const handleTapRequest = async () => {
           try {
-            const { serialized, hash } = await prepareTapRequest(currency, {
-              partyId,
-            });
+            const { serialized, hash } = await prepareTapRequest(currency, { partyId });
 
             if (serialized && hash) {
-              observer.next({
-                status: PreApprovalStatus.SIGN,
-              });
+              o.next({ status: AuthorizeStatus.SIGN });
 
               const signature = await signerContext(deviceId, signer =>
-                signer.signTransaction(derivationPath, hash),
+                signer.signTransaction(account.freshAddressPath, hash),
               );
 
-              observer.next({
-                status: PreApprovalStatus.SUBMIT,
-              });
+              o.next({ status: AuthorizeStatus.SUBMIT });
 
               await submitTapRequest(currency, {
                 partyId,
                 serialized,
                 signature,
               });
-
-              observer.next({
-                status: PreApprovalStatus.SUCCESS,
-              });
             }
           } catch (err) {
             // Tap request failure should not break the pre-approval flow
           }
         };
         await handleTapRequest();
-
-        observer.complete();
       }
 
       main().then(
-        () => observer.complete(),
+        () => o.complete(),
         error => {
-          log("[buildAuthorizePreapproval] Error:", error);
-          observer.error(error);
+          log("[canton:onboard] authorizePreapproval failed:", error);
+          o.error(error);
         },
       );
     });
-
-const createAccount = async ({
-  address,
-  partyId,
-  derivationPath,
-  currency,
-  derivationMode,
-  index = 0,
-}: {
-  address: string;
-  derivationPath: string;
-  partyId: string;
-  currency: CryptoCurrency;
-  derivationMode: DerivationMode;
-  index?: number;
-}): Promise<Partial<Account>> => {
-  const accountShape = await getAccountShape(
-    {
-      address,
-      currency,
-      derivationMode,
-      derivationPath,
-      index,
-      rest: {
-        cantonResources: {
-          partyId,
-        },
-      },
-    },
-    { paginationConfig: {} },
-  );
-
-  const account: Partial<CantonAccount> = {
-    ...accountShape,
-    type: "Account",
-    xpub: partyId.replace(/:/g, "_"),
-    index,
-    // operations: [],
-    currency,
-    derivationMode,
-    lastSyncDate: new Date(),
-    pendingOperations: [],
-    seedIdentifier: address,
-    balanceHistoryCache: emptyHistoryCache,
-    cantonResources: {
-      partyId,
-    },
-  };
-
-  return account;
-};
-
-const log = (message: string, ...rest: unknown[]) => {
-  // eslint-disable-next-line no-console
-  console.log(message, ...rest);
-};

package/src/bridge/signOperation.ts

@@ -4,6 +4,7 @@ import { FeeNotLoaded } from "@ledgerhq/errors";
 import { AccountBridge, Operation } from "@ledgerhq/types-live";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { decodeAccountId } from "@ledgerhq/coin-framework/account";
 import { combine, craftTransaction } from "../common-logic";
 import { Transaction, CantonSigner } from "../types";
 
@@ -22,10 +23,8 @@ export const buildSignOperation =
           });
 
           const signature = await signerContext(deviceId, async signer => {
-            const { freshAddressPath: derivationPath } = account;
-            const partyId = (account as unknown as { cantonResources: { partyId: string } })
-              .cantonResources.partyId;
-
+            const { id, freshAddressPath: derivationPath, xpub } = account;
+            const address = xpub ?? decodeAccountId(id).xpubOrAddress;
             const params: {
               recipient?: string;
               amount: BigNumber;
@@ -45,13 +44,13 @@ export const buildSignOperation =
             const { hash, serializedTransaction } = await craftTransaction(
               account.currency,
               {
-                address: partyId,
+                address,
               },
               params,
             );
             const transactionSignature = await signer.signTransaction(derivationPath, hash);
 
-            return combine(serializedTransaction, `${transactionSignature}__PARTY__${partyId}`);
+            return combine(serializedTransaction, `${transactionSignature}__PARTY__${address}`);
           });
 
           o.next({

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

@@ -9,7 +9,9 @@ import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
 import { Account, Operation } from "@ledgerhq/types-live";
 import coinConfig from "../config";
 import * as gateway from "../network/gateway";
-import { getAccountShape } from "./sync";
+import { generateMockKeyPair, createMockSigner } from "../test/cantonTestUtils";
+import { CantonAccount } from "../types";
+import { makeGetAccountShape } from "./sync";
 
 const TEST_ADDRESS =
   "b6400f93ea1c74aea86be39b0ccc846fc5de01f12b2ad0d7c31848d6fb6eb6d9::1220c81315e2bf2524a9141bcc6cbf19b61c151e0dcaa95343c0ccf53aed7415c4ec";
@@ -22,14 +24,25 @@ const derivationPath = runDerivationScheme(
     account: 0,
   },
 );
-const ACCOUNT_SHAPE_INFO: AccountShapeInfo = {
+const xpub = TEST_ADDRESS;
+const ACCOUNT_SHAPE_INFO: AccountShapeInfo<CantonAccount> = {
   address: TEST_ADDRESS,
   currency,
   derivationMode,
   derivationPath,
   index: 0,
+  initialAccount: {
+    xpub,
+  } as CantonAccount,
 };
 
+// Mock signer context for testing
+const keyPair = generateMockKeyPair();
+const mockSigner = createMockSigner(keyPair);
+const mockSignerContext = jest.fn().mockImplementation((deviceId, callback) => {
+  return callback(mockSigner);
+});
+
 describe("sync (devnet)", () => {
   beforeAll(async () => {
     coinConfig.setCoinConfig(() => ({
@@ -43,13 +56,14 @@ describe("sync (devnet)", () => {
     }));
   });
 
-  describe("getAccountShape", () => {
+  describe("makeGetAccountShape", () => {
     it("should fetch account shape for a valid address", async () => {
+      const getAccountShape = makeGetAccountShape(mockSignerContext);
       const result = await getAccountShape(ACCOUNT_SHAPE_INFO, { paginationConfig: {} });
 
       expect(result).toBeDefined();
       expect(result.id).toBeDefined();
-      expect(result.xpub).toBe(TEST_ADDRESS.replace(/:/g, "_"));
+      expect(result.xpub).toBe(TEST_ADDRESS);
       expect(result.blockHeight).toBeGreaterThan(0);
       expect(result.balance).toBeDefined();
       expect(result.spendableBalance).toBeDefined();
@@ -67,12 +81,15 @@ describe("sync (devnet)", () => {
     });
 
     it("should handle address with colons correctly", async () => {
+      const getAccountShape = makeGetAccountShape(mockSignerContext);
       const result = await getAccountShape(ACCOUNT_SHAPE_INFO, { paginationConfig: {} });
 
-      expect(result.xpub).toBe(TEST_ADDRESS.replace(/:/g, "_"));
+      expect(result.xpub).toContain("::");
     });
 
     it("should merge operations correctly with initial account", async () => {
+      const getAccountShape = makeGetAccountShape(mockSignerContext);
+
       const operations: Operation[] = [
         {
           id: "test-op-1",
@@ -95,7 +112,7 @@ describe("sync (devnet)", () => {
         {
           ...ACCOUNT_SHAPE_INFO,
           // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          initialAccount: { operations } as Account,
+          initialAccount: { xpub, operations } as Account,
         },
         { paginationConfig: {} },
       );
@@ -112,20 +129,26 @@ describe("sync (devnet)", () => {
       mockGetBalance.mockResolvedValue([
         {
           instrument_id: "Amulet",
-          amount: 1000000,
+          amount: "500",
+          locked: false,
+        },
+        {
+          instrument_id: "LockedAmulet",
+          amount: "1000000",
           locked: true,
         },
       ]);
 
+      const getAccountShape = makeGetAccountShape(mockSignerContext);
       const result = await getAccountShape(ACCOUNT_SHAPE_INFO, { paginationConfig: {} });
 
-      expect(result.balance?.toNumber()).toBe(1000000);
-      expect(result.spendableBalance?.toNumber()).toBe(0);
+      expect(result.balance?.toNumber()).toBe(1000500);
+      expect(result.spendableBalance?.toNumber()).toBe(500);
 
       mockGetBalance.mockRestore();
     });
 
-    it("should call getOperations with correct cursor based with initial account", async () => {
+    it("should call getOperations with correct cursor based on initial account", async () => {
       const mockGetOperations = jest.spyOn(gateway, "getOperations");
       const operation: Operation = {
         id: "test-op-1",
@@ -144,8 +167,9 @@ describe("sync (devnet)", () => {
       };
 
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const initialAccount = { operations: [operation] } as Account;
+      const initialAccount = { xpub, operations: [operation] } as Account;
 
+      const getAccountShape = makeGetAccountShape(mockSignerContext);
       const result = await getAccountShape(
         {
           ...ACCOUNT_SHAPE_INFO,
@@ -154,7 +178,7 @@ describe("sync (devnet)", () => {
         { paginationConfig: {} },
       );
 
-      expect(mockGetOperations).toHaveBeenCalledWith(TEST_ADDRESS, {
+      expect(mockGetOperations).toHaveBeenCalledWith(currency, TEST_ADDRESS, {
         cursor: (operation.blockHeight || 0) + 1,
         limit: 100,
       });
@@ -165,12 +189,13 @@ describe("sync (devnet)", () => {
     it("should call getOperations with cursor 0 when no initial account", async () => {
       const mockGetOperations = jest.spyOn(gateway, "getOperations");
 
+      const getAccountShape = makeGetAccountShape(mockSignerContext);
       const result = await getAccountShape(ACCOUNT_SHAPE_INFO, { paginationConfig: {} });
 
       expect(result.operations).toBeDefined();
       expect(result.operationsCount).toBeGreaterThanOrEqual(1);
 
-      expect(mockGetOperations).toHaveBeenCalledWith(TEST_ADDRESS, {
+      expect(mockGetOperations).toHaveBeenCalledWith(currency, TEST_ADDRESS, {
         cursor: 0,
         limit: 100,
       });