@ledgerhq/coin-canton 0.9.0-nightly.1 → 0.9.0-nightly.2

package/src/bridge/onboard.ts

@@ -3,17 +3,21 @@ import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import type { Account } from "@ledgerhq/types-live";
 import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import { log } from "@ledgerhq/logs";
+import { TransportStatusError, UserRefusedOnDevice, LockedDeviceError } from "@ledgerhq/errors";
 import { encodeAccountId } from "@ledgerhq/coin-framework/account/accountId";
+
 import {
+  getNetworkType,
   prepareOnboarding,
   submitOnboarding,
   getPartyByPubKey,
-  preparePreApprovalTransaction,
-  submitPreApprovalTransaction,
   prepareTapRequest,
   submitTapRequest,
+  preparePreApprovalTransaction,
+  submitPreApprovalTransaction,
   getTransferPreApproval,
 } from "../network/gateway";
+import { signTransaction } from "../common-logic/transaction/sign";
 import {
   OnboardStatus,
   AuthorizeStatus,
@@ -96,12 +100,9 @@ export const buildOnboardAccount =
 
         o.next({ status: OnboardStatus.SIGN });
 
-        const signature = await signerContext(deviceId, signer =>
-          signer.signTransaction(
-            account.freshAddressPath,
-            preparedTransaction.transactions.combined_hash,
-          ),
-        );
+        const signature = await signerContext(deviceId, async signer => {
+          return await signTransaction(signer, account.freshAddressPath, preparedTransaction);
+        });
 
         o.next({ status: OnboardStatus.SUBMIT });
 
@@ -115,7 +116,9 @@ export const buildOnboardAccount =
         () => o.complete(),
         error => {
           log("[canton:onboard] onboardAccount failed:", error);
-          o.error(error);
+
+          const handledError = handleDeviceErrors(error);
+          o.error(handledError || error);
         },
       );
     });
@@ -141,10 +144,9 @@ export const buildAuthorizePreapproval =
 
           o.next({ status: AuthorizeStatus.SIGN });
 
-          const signature = await signerContext(deviceId, signer =>
-            signer.signTransaction(account.freshAddressPath, preparedTransaction.hash),
-          );
-
+          const signature = await signerContext(deviceId, async signer => {
+            return await signTransaction(signer, account.freshAddressPath, preparedTransaction);
+          });
           o.next({ status: AuthorizeStatus.SUBMIT });
 
           await submitPreApprovalTransaction(currency, partyId, preparedTransaction, signature);
@@ -152,37 +154,59 @@ export const buildAuthorizePreapproval =
 
         o.next({ isApproved: true }); // success
 
-        const handleTapRequest = async () => {
-          try {
-            const { serialized, hash } = await prepareTapRequest(currency, { partyId });
+        if (getNetworkType(currency) !== "mainnet") {
+          const handleTapRequest = async () => {
+            try {
+              const { serialized, hash } = await prepareTapRequest(currency, { partyId });
 
-            if (serialized && hash) {
-              o.next({ status: AuthorizeStatus.SIGN });
+              if (serialized && hash) {
+                o.next({ status: AuthorizeStatus.SIGN });
 
-              const signature = await signerContext(deviceId, signer =>
-                signer.signTransaction(account.freshAddressPath, hash),
-              );
+                const signature = await signerContext(deviceId, signer =>
+                  signer.signTransaction(account.freshAddressPath, hash),
+                );
 
-              o.next({ status: AuthorizeStatus.SUBMIT });
+                o.next({ status: AuthorizeStatus.SUBMIT });
 
-              await submitTapRequest(currency, {
-                partyId,
-                serialized,
-                signature,
-              });
+                await submitTapRequest(currency, {
+                  partyId,
+                  serialized,
+                  signature,
+                });
+              }
+            } catch (err) {
+              // Tap request failure should not break the pre-approval flow
             }
-          } catch (err) {
-            // Tap request failure should not break the pre-approval flow
-          }
-        };
-        await handleTapRequest();
+          };
+          await handleTapRequest();
+        }
       }
 
       main().then(
         () => o.complete(),
         error => {
           log("[canton:onboard] authorizePreapproval failed:", error);
-          o.error(error);
+
+          const handledError = handleDeviceErrors(error);
+          o.error(handledError || error);
         },
       );
     });
+
+/**
+ * Check if an error is a LockedDeviceError or UserRefusedOnDevice and create user-friendly error messages
+ */
+const handleDeviceErrors = (error: Error): Error | null => {
+  if (error instanceof TransportStatusError) {
+    if (error.statusCode === 0x6985) {
+      const userRefusedError = new UserRefusedOnDevice("errors.UserRefusedOnDevice.description");
+      return userRefusedError;
+    }
+    if (error.statusCode === 0x5515) {
+      const lockedDeviceError = new LockedDeviceError("errors.LockedDeviceError.description");
+      return lockedDeviceError;
+    }
+  }
+
+  return null;
+};

package/src/bridge/signOperation.test.ts

@@ -0,0 +1,114 @@
+import { BigNumber } from "bignumber.js";
+import { CantonSigner, CantonPreparedTransaction } from "../types";
+import { Transaction } from "../types";
+import { craftTransaction } from "../common-logic";
+import prepareTransferMock from "../test/prepare-transfer.json";
+import { buildSignOperation } from "./signOperation";
+
+jest.mock("../common-logic", () => {
+  const actual = jest.requireActual("../common-logic");
+  return {
+    ...actual,
+    craftTransaction: jest.fn(),
+  };
+});
+
+const mockCraftTransaction = craftTransaction as jest.MockedFunction<typeof craftTransaction>;
+
+class MockCantonSigner implements CantonSigner {
+  async getAddress(path: string, display?: boolean) {
+    return {
+      publicKey: "mock-public-key",
+      address: "mock-address",
+      path,
+    };
+  }
+
+  async signTransaction(
+    path: string,
+    data: CantonPreparedTransaction | { transactions: string[] },
+  ) {
+    if ("transactions" in data) {
+      return `untyped-signature-${data.transactions.length}`;
+    } else {
+      return `prepared-transaction-signature-${data.damlTransaction.length}-${data.nodes.length}`;
+    }
+  }
+}
+
+describe("buildSignOperation", () => {
+  const mockDeviceId = "test-device-id";
+  const mockDerivationPath = "44'/6767'/0'/0'/0'";
+  const mockPartyId = "alice::1220d466a5d96a3509736c821e25fe81fc8a73f226d92e57e94a65170e58b07fc08e";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockCraftTransaction.mockReset();
+  });
+
+  const mockAccount = {
+    id: "js:2:canton_network:test-party-id:",
+    freshAddress: "test-address",
+    freshAddressPath: mockDerivationPath,
+    xpub: "test-party-id",
+    currency: {
+      id: "canton_network",
+    },
+    cantonResources: {
+      partyId: mockPartyId,
+    },
+  } as any;
+
+  const mockTransaction: Transaction = {
+    family: "canton",
+    recipient: "bob::44444444444444444444444444444444444444444444444444444444444444444444",
+    amount: new BigNumber("1000000"),
+    tokenId: "Amulet",
+    fee: new BigNumber("1000"),
+    memo: "Test transaction",
+  };
+
+  it("should handle prepared transaction signing", async () => {
+    // GIVEN
+    const mockSigner = new MockCantonSigner();
+    const mockSignerContext = jest.fn().mockImplementation(async (deviceId, callback) => {
+      return await callback(mockSigner);
+    });
+
+    mockCraftTransaction.mockResolvedValue({
+      nativeTransaction: {
+        // @ts-expect-error fix types
+        transaction: prepareTransferMock.transaction,
+        metadata: prepareTransferMock.metadata,
+      },
+      serializedTransaction: "serialized-transaction",
+      hash: "mock-hash",
+    });
+
+    const signOperation = buildSignOperation(mockSignerContext);
+
+    // WHEN
+    const result = await new Promise((resolve, reject) => {
+      signOperation({
+        account: mockAccount,
+        deviceId: mockDeviceId,
+        transaction: mockTransaction,
+      }).subscribe({
+        next: value => {
+          if (value.type === "signed") {
+            resolve(value);
+          }
+        },
+        error: reject,
+      });
+    });
+
+    // THEN
+    expect(mockCraftTransaction).toHaveBeenCalled();
+    expect(result).toMatchObject({
+      signedOperation: {
+        signature: expect.stringContaining("prepared-transaction-signature-"),
+      },
+    });
+  });
+});

package/src/bridge/signOperation.ts

@@ -6,6 +6,7 @@ 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 { signTransaction } from "../common-logic/transaction/sign";
 import { Transaction, CantonSigner } from "../types";
 
 export const buildSignOperation =
@@ -41,14 +42,19 @@ export const buildSignOperation =
               params.memo = transaction.memo;
             }
 
-            const { hash, serializedTransaction } = await craftTransaction(
+            const { nativeTransaction, serializedTransaction, hash } = await craftTransaction(
               account.currency,
               {
                 address,
               },
               params,
             );
-            const transactionSignature = await signer.signTransaction(derivationPath, hash);
+
+            const transactionSignature = await signTransaction(signer, derivationPath, {
+              json: nativeTransaction,
+              serialized: serializedTransaction,
+              hash: hash,
+            });
 
             return combine(serializedTransaction, `${transactionSignature}__PARTY__${address}`);
           });
@@ -83,9 +89,10 @@ export const buildSignOperation =
           });
         } catch (e) {
           if (e instanceof Error) {
-            throw new Error(
-              (e as Error & { data?: { resultMessage?: string } })?.data?.resultMessage,
-            );
+            const errorMessage =
+              (e as Error & { data?: { resultMessage?: string } })?.data?.resultMessage ||
+              e.message;
+            throw new Error(errorMessage);
           }
 
           throw e;

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

@@ -35,6 +35,7 @@ const ACCOUNT_SHAPE_INFO: AccountShapeInfo<CantonAccount> = {
     xpub,
   } as CantonAccount,
 };
+const TIMEOUT = 30000;
 
 // Mock signer context for testing
 const keyPair = generateMockKeyPair();
@@ -57,41 +58,118 @@ describe("sync (devnet)", () => {
   });
 
   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);
-      expect(result.blockHeight).toBeGreaterThan(0);
-      expect(result.balance).toBeDefined();
-      expect(result.spendableBalance).toBeDefined();
-      expect(result.operations).toBeDefined();
-      expect(result.operationsCount).toBeGreaterThanOrEqual(0);
-
-      expect(result.balance).toBeInstanceOf(Object);
-      expect(result.balance?.toNumber).toBeDefined();
-      expect(result.spendableBalance).toBeInstanceOf(Object);
-      expect(result.spendableBalance?.toNumber).toBeDefined();
-
-      expect(result.spendableBalance?.toNumber()).toBeLessThanOrEqual(
-        result.balance?.toNumber() || 0,
-      );
-    });
-
-    it("should handle address with colons correctly", async () => {
-      const getAccountShape = makeGetAccountShape(mockSignerContext);
-      const result = await getAccountShape(ACCOUNT_SHAPE_INFO, { paginationConfig: {} });
-
-      expect(result.xpub).toContain("::");
-    });
-
-    it("should merge operations correctly with initial account", async () => {
-      const getAccountShape = makeGetAccountShape(mockSignerContext);
-
-      const operations: Operation[] = [
-        {
+    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);
+        expect(result.blockHeight).toBeGreaterThan(0);
+        expect(result.balance).toBeDefined();
+        expect(result.spendableBalance).toBeDefined();
+        expect(result.operations).toBeDefined();
+        expect(result.operationsCount).toBeGreaterThanOrEqual(0);
+
+        expect(result.balance).toBeInstanceOf(Object);
+        expect(result.balance?.toNumber).toBeDefined();
+        expect(result.spendableBalance).toBeInstanceOf(Object);
+        expect(result.spendableBalance?.toNumber).toBeDefined();
+
+        expect(result.spendableBalance?.toNumber()).toBeLessThanOrEqual(
+          result.balance?.toNumber() || 0,
+        );
+      },
+      TIMEOUT,
+    );
+
+    it(
+      "should handle address with colons correctly",
+      async () => {
+        const getAccountShape = makeGetAccountShape(mockSignerContext);
+        const result = await getAccountShape(ACCOUNT_SHAPE_INFO, { paginationConfig: {} });
+
+        expect(result.xpub).toContain("::");
+      },
+      TIMEOUT,
+    );
+
+    it(
+      "should merge operations correctly with initial account",
+      async () => {
+        const getAccountShape = makeGetAccountShape(mockSignerContext);
+
+        const operations: Operation[] = [
+          {
+            id: "test-op-1",
+            hash: "test-hash-1",
+            accountId: "test-account",
+            type: "OUT" as const,
+            value: new BigNumber(1000000),
+            fee: new BigNumber(100000),
+            blockHash: "block-hash-1",
+            blockHeight: 100,
+            senders: [TEST_ADDRESS],
+            recipients: ["recipient-1"],
+            date: new Date("2023-01-01"),
+            transactionSequenceNumber: 100,
+            extra: { uid: "uid-1" },
+          },
+        ];
+
+        const result = await getAccountShape(
+          {
+            ...ACCOUNT_SHAPE_INFO,
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            initialAccount: { xpub, operations } as Account,
+          },
+          { paginationConfig: {} },
+        );
+
+        expect(result.operations).toBeDefined();
+        expect(result.operationsCount).toBeGreaterThanOrEqual(1);
+        const initialOp = result.operations?.find(op => op.id === "test-op-1");
+        expect(initialOp).toBeDefined();
+      },
+      TIMEOUT,
+    );
+
+    it(
+      "should take locked balance into account when calculating spendable balance",
+      async () => {
+        const mockGetBalance = jest.spyOn(gateway, "getBalance");
+
+        mockGetBalance.mockResolvedValue([
+          {
+            instrument_id: "Amulet",
+            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(1000500);
+        expect(result.spendableBalance?.toNumber()).toBe(500);
+
+        mockGetBalance.mockRestore();
+      },
+      TIMEOUT,
+    );
+
+    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",
           hash: "test-hash-1",
           accountId: "test-account",
@@ -105,102 +183,49 @@ describe("sync (devnet)", () => {
           date: new Date("2023-01-01"),
           transactionSequenceNumber: 100,
           extra: { uid: "uid-1" },
-        },
-      ];
-
-      const result = await getAccountShape(
-        {
-          ...ACCOUNT_SHAPE_INFO,
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          initialAccount: { xpub, operations } as Account,
-        },
-        { paginationConfig: {} },
-      );
-
-      expect(result.operations).toBeDefined();
-      expect(result.operationsCount).toBeGreaterThanOrEqual(1);
-      const initialOp = result.operations?.find(op => op.id === "test-op-1");
-      expect(initialOp).toBeDefined();
-    });
-
-    it("should take locked balance into account when calculating spendable balance", async () => {
-      const mockGetBalance = jest.spyOn(gateway, "getBalance");
-
-      mockGetBalance.mockResolvedValue([
-        {
-          instrument_id: "Amulet",
-          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(1000500);
-      expect(result.spendableBalance?.toNumber()).toBe(500);
-
-      mockGetBalance.mockRestore();
-    });
-
-    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",
-        hash: "test-hash-1",
-        accountId: "test-account",
-        type: "OUT" as const,
-        value: new BigNumber(1000000),
-        fee: new BigNumber(100000),
-        blockHash: "block-hash-1",
-        blockHeight: 100,
-        senders: [TEST_ADDRESS],
-        recipients: ["recipient-1"],
-        date: new Date("2023-01-01"),
-        transactionSequenceNumber: 100,
-        extra: { uid: "uid-1" },
-      };
-
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const initialAccount = { xpub, operations: [operation] } as Account;
-
-      const getAccountShape = makeGetAccountShape(mockSignerContext);
-      const result = await getAccountShape(
-        {
-          ...ACCOUNT_SHAPE_INFO,
-          initialAccount,
-        },
-        { paginationConfig: {} },
-      );
-
-      expect(mockGetOperations).toHaveBeenCalledWith(currency, TEST_ADDRESS, {
-        cursor: (operation.blockHeight || 0) + 1,
-        limit: 100,
-      });
-      expect(result.operations).toBeDefined();
-      expect(result.operationsCount).toBeGreaterThan(1);
-    });
-
-    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(currency, TEST_ADDRESS, {
-        cursor: 0,
-        limit: 100,
-      });
-
-      mockGetOperations.mockRestore();
-    });
+        };
+
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const initialAccount = { xpub, operations: [operation] } as Account;
+
+        const getAccountShape = makeGetAccountShape(mockSignerContext);
+        const result = await getAccountShape(
+          {
+            ...ACCOUNT_SHAPE_INFO,
+            initialAccount,
+          },
+          { paginationConfig: {} },
+        );
+
+        expect(mockGetOperations).toHaveBeenCalledWith(currency, TEST_ADDRESS, {
+          cursor: (operation.blockHeight || 0) + 1,
+          limit: 100,
+        });
+        expect(result.operations).toBeDefined();
+        expect(result.operationsCount).toBeGreaterThan(1);
+      },
+      TIMEOUT,
+    );
+
+    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(currency, TEST_ADDRESS, {
+          cursor: 0,
+          limit: 100,
+        });
+
+        mockGetOperations.mockRestore();
+      },
+      TIMEOUT,
+    );
   });
 });

package/src/common-logic/index.ts

@@ -2,6 +2,7 @@ export { broadcast } from "./transaction/broadcast";
 export { combine } from "./transaction/combine";
 export { craftTransaction } from "./transaction/craftTransaction";
 export { estimateFees } from "./transaction/estimateFees";
+export { signTransaction } from "./transaction/sign";
 export { getBalance } from "./account/getBalance";
 export { lastBlock } from "./history/lastBlock";
 export { listOperations } from "./history/listOperations";