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

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,
@@ -85,6 +89,7 @@ export const buildOnboardAccount =
         o.next({ status: OnboardStatus.PREPARE });
 
         let { partyId } = await isAccountOnboarded(currency, publicKey);
+
         if (partyId) {
           const onboardedAccount = createOnboardedAccount(account, partyId, currency);
           o.next({ partyId, account: onboardedAccount }); // success
@@ -96,12 +101,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 +117,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 +145,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 +155,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/prepareTransaction.ts

@@ -11,7 +11,7 @@ export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"
 ) => {
   const amount = transaction.amount || BigNumber(0);
   const fee = BigNumber(
-    (await estimateFees(account.currency, BigInt(amount.toString()))).toString(),
+    (await estimateFees(account.currency, BigInt(amount.toFixed()))).toString(),
   );
 
   if (!transaction.tokenId) {

package/src/bridge/serialization.ts

@@ -0,0 +1,44 @@
+import type { Account, AccountRaw } from "@ledgerhq/types-live";
+import {
+  type CantonAccount,
+  type CantonAccountRaw,
+  type CantonResources,
+  type CantonResourcesRaw,
+} from "../types";
+
+function isCantonAccount(account: Account): account is CantonAccount {
+  return "cantonResources" in account;
+}
+
+function isCantonAccountRaw(accountRaw: AccountRaw): accountRaw is CantonAccountRaw {
+  return "cantonResources" in accountRaw;
+}
+
+function toResourcesRaw(r: CantonResources): CantonResourcesRaw {
+  const { instrumentUtxoCounts } = r;
+  return {
+    instrumentUtxoCounts,
+  };
+}
+
+function fromResourcesRaw(r: CantonResourcesRaw): CantonResources {
+  return {
+    instrumentUtxoCounts: r.instrumentUtxoCounts,
+  };
+}
+
+export function assignToAccountRaw(account: Account, accountRaw: AccountRaw): void {
+  if (isCantonAccount(account) && isCantonAccountRaw(accountRaw)) {
+    if (account.cantonResources) {
+      accountRaw.cantonResources = toResourcesRaw(account.cantonResources);
+    }
+  }
+}
+
+export function assignFromAccountRaw(accountRaw: AccountRaw, account: Account): void {
+  if (isCantonAccountRaw(accountRaw) && isCantonAccount(account)) {
+    if (accountRaw.cantonResources) {
+      account.cantonResources = fromResourcesRaw(accountRaw.cantonResources);
+    }
+  }
+}

package/src/bridge/signOperation.test.ts

@@ -0,0 +1,123 @@
+import { BigNumber } from "bignumber.js";
+import {
+  CantonSigner,
+  CantonPreparedTransaction,
+  CantonSignature,
+  CantonUntypedVersionedMessage,
+} from "../types";
+import { Transaction } from "../types";
+import { craftTransaction } from "../common-logic";
+import prepareTransferMock from "../test/prepare-transfer.json";
+import { buildSignOperation } from "./signOperation";
+import { createMockAccount } from "../test/fixtures";
+
+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 | CantonUntypedVersionedMessage | string,
+  ): Promise<CantonSignature> {
+    if (typeof data === "string") {
+      return { signature: `txhash-signature-${data}` };
+    } else if ("transactions" in data) {
+      const result: CantonSignature = {
+        signature: `untyped-signature-${data.transactions.length}`,
+      };
+      if (data.challenge) {
+        result.applicationSignature = `challenge-signature-${data.challenge}`;
+      }
+      return result;
+    } else {
+      return {
+        signature: `prepared-transaction-signature-${data.damlTransaction.length}-${data.nodes.length}`,
+      };
+    }
+  }
+}
+
+describe("buildSignOperation", () => {
+  const mockDeviceId = "test-device-id";
+  const mockDerivationPath = "44'/6767'/0'/0'/0'";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockCraftTransaction.mockReset();
+  });
+
+  const mockAccount = createMockAccount({
+    id: "js:2:canton_network:test-party-id:",
+    freshAddress: "test-address",
+    freshAddressPath: mockDerivationPath,
+    xpub: "test-party-id",
+  });
+
+  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,16 +42,21 @@ 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);
 
-            return combine(serializedTransaction, `${transactionSignature}__PARTY__${address}`);
+            const { signature } = await signTransaction(signer, derivationPath, {
+              json: nativeTransaction,
+              serialized: serializedTransaction,
+              hash: hash,
+            });
+
+            return combine(serializedTransaction, `${signature}__PARTY__${address}`);
           });
 
           o.next({
@@ -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,
+    );
   });
 });