@ledgerhq/coin-canton 0.10.0 → 0.11.0-nightly.20251126023856

package/src/bridge/acceptOffer.test.ts

@@ -0,0 +1,300 @@
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { Account } from "@ledgerhq/types-live";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { buildTransferInstruction } from "./acceptOffer";
+import * as gateway from "../network/gateway";
+import * as signTransactionModule from "../common-logic/transaction/sign";
+import type { CantonSigner, CantonSignature } from "../types/signer";
+import type { PrepareTransferResponse } from "../network/gateway";
+
+jest.mock("../network/gateway");
+jest.mock("../common-logic/transaction/sign");
+
+const mockedGateway = gateway as jest.Mocked<typeof gateway>;
+const mockedSignTransaction = signTransactionModule as jest.Mocked<typeof signTransactionModule>;
+
+describe("acceptOffer", () => {
+  const mockCurrency = {
+    id: "canton_network",
+  } as unknown as CryptoCurrency;
+
+  const mockAccount = {
+    id: "test-account-id",
+    freshAddressPath: "44'/6767'/0'/0'/0'",
+  } as unknown as Account;
+
+  const mockPartyId = "test-party-id";
+  const mockContractId = "test-contract-id";
+  const mockDeviceId = "test-device-id";
+
+  const mockPreparedTransaction: PrepareTransferResponse = {
+    hash: "test-hash",
+    json: {
+      transaction: {
+        version: "2.1",
+        roots: ["0"],
+        nodes: [
+          {
+            nodeId: "0",
+            v1: {
+              create: {
+                lfVersion: "2.1",
+                contractId: mockContractId,
+                packageName: "test-package",
+                templateId: {
+                  packageId: "test-package-id",
+                  moduleName: "TestModule",
+                  entityName: "TestEntity",
+                },
+                argument: {
+                  record: {
+                    recordId: {
+                      packageId: "test-package-id",
+                      moduleName: "TestModule",
+                      entityName: "TestEntity",
+                    },
+                    fields: [],
+                  },
+                },
+              },
+            },
+          },
+        ],
+      },
+      metadata: {
+        submitterInfo: {
+          actAs: [mockPartyId],
+          commandId: "test-command-id",
+        },
+        synchronizerId: "test-synchronizer-id",
+        transactionUuid: "test-transaction-uuid",
+        submissionTime: "1234567890",
+        inputContracts: [],
+      },
+    },
+    serialized: "serialized-transaction",
+  };
+
+  const mockSignature: CantonSignature = {
+    signature: "test-signature",
+  };
+
+  const mockSigner: CantonSigner = {
+    getAddress: jest.fn(),
+    signTransaction: jest.fn(),
+  } as unknown as CantonSigner;
+
+  const mockSignerContext: SignerContext<CantonSigner> = jest.fn(
+    async (deviceId: string, callback: (signer: CantonSigner) => Promise<CantonSignature>) => {
+      return callback(mockSigner);
+    },
+  ) as unknown as SignerContext<CantonSigner>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockedGateway.prepareTransferInstruction.mockResolvedValue(mockPreparedTransaction);
+    mockedSignTransaction.signTransaction.mockResolvedValue(mockSignature);
+    mockedGateway.submitTransferInstruction.mockResolvedValue({ update_id: "test-update-id" });
+  });
+
+  describe("buildTransferInstruction", () => {
+    it("should accept transfer instruction without reason", async () => {
+      // GIVEN
+      const transferInstruction = buildTransferInstruction(mockSignerContext);
+
+      // WHEN
+      await transferInstruction(
+        mockCurrency,
+        mockDeviceId,
+        mockAccount,
+        mockPartyId,
+        mockContractId,
+        "accept-transfer-instruction",
+      );
+
+      // THEN
+      expect(mockedGateway.prepareTransferInstruction).toHaveBeenCalledWith(
+        mockCurrency,
+        mockPartyId,
+        {
+          type: "accept-transfer-instruction",
+          contract_id: mockContractId,
+        },
+      );
+      expect(mockedSignTransaction.signTransaction).toHaveBeenCalledWith(
+        mockSigner,
+        mockAccount.freshAddressPath,
+        mockPreparedTransaction,
+      );
+      expect(mockedGateway.submitTransferInstruction).toHaveBeenCalledWith(
+        mockCurrency,
+        mockPartyId,
+        mockPreparedTransaction.serialized,
+        mockSignature.signature,
+      );
+      expect(mockSignerContext).toHaveBeenCalledWith(mockDeviceId, expect.any(Function));
+    });
+
+    it("should accept transfer instruction with reason", async () => {
+      // GIVEN
+      const reason = "test-reason";
+      const transferInstruction = buildTransferInstruction(mockSignerContext);
+
+      // WHEN
+      await transferInstruction(
+        mockCurrency,
+        mockDeviceId,
+        mockAccount,
+        mockPartyId,
+        mockContractId,
+        "accept-transfer-instruction",
+        reason,
+      );
+
+      // THEN
+      expect(mockedGateway.prepareTransferInstruction).toHaveBeenCalledWith(
+        mockCurrency,
+        mockPartyId,
+        {
+          type: "accept-transfer-instruction",
+          contract_id: mockContractId,
+          reason,
+        },
+      );
+      expect(mockedSignTransaction.signTransaction).toHaveBeenCalledWith(
+        mockSigner,
+        mockAccount.freshAddressPath,
+        mockPreparedTransaction,
+      );
+      expect(mockedGateway.submitTransferInstruction).toHaveBeenCalledWith(
+        mockCurrency,
+        mockPartyId,
+        mockPreparedTransaction.serialized,
+        mockSignature.signature,
+      );
+    });
+
+    it("should reject transfer instruction", async () => {
+      // GIVEN
+      const transferInstruction = buildTransferInstruction(mockSignerContext);
+
+      // WHEN
+      await transferInstruction(
+        mockCurrency,
+        mockDeviceId,
+        mockAccount,
+        mockPartyId,
+        mockContractId,
+        "reject-transfer-instruction",
+      );
+
+      // THEN
+      expect(mockedGateway.prepareTransferInstruction).toHaveBeenCalledWith(
+        mockCurrency,
+        mockPartyId,
+        {
+          type: "reject-transfer-instruction",
+          contract_id: mockContractId,
+        },
+      );
+      expect(mockedSignTransaction.signTransaction).toHaveBeenCalled();
+      expect(mockedGateway.submitTransferInstruction).toHaveBeenCalled();
+    });
+
+    it("should withdraw transfer instruction", async () => {
+      // GIVEN
+      const transferInstruction = buildTransferInstruction(mockSignerContext);
+
+      // WHEN
+      await transferInstruction(
+        mockCurrency,
+        mockDeviceId,
+        mockAccount,
+        mockPartyId,
+        mockContractId,
+        "withdraw-transfer-instruction",
+      );
+
+      // THEN
+      expect(mockedGateway.prepareTransferInstruction).toHaveBeenCalledWith(
+        mockCurrency,
+        mockPartyId,
+        {
+          type: "withdraw-transfer-instruction",
+          contract_id: mockContractId,
+        },
+      );
+      expect(mockedSignTransaction.signTransaction).toHaveBeenCalled();
+      expect(mockedGateway.submitTransferInstruction).toHaveBeenCalled();
+    });
+
+    it("should handle errors from prepareTransferInstruction", async () => {
+      // GIVEN
+      const error = new Error("Prepare failed");
+      mockedGateway.prepareTransferInstruction.mockRejectedValue(error);
+      const transferInstruction = buildTransferInstruction(mockSignerContext);
+
+      // WHEN & THEN
+      await expect(
+        transferInstruction(
+          mockCurrency,
+          mockDeviceId,
+          mockAccount,
+          mockPartyId,
+          mockContractId,
+          "accept-transfer-instruction",
+        ),
+      ).rejects.toThrow("Prepare failed");
+
+      expect(mockedGateway.prepareTransferInstruction).toHaveBeenCalled();
+      expect(mockedSignTransaction.signTransaction).not.toHaveBeenCalled();
+      expect(mockedGateway.submitTransferInstruction).not.toHaveBeenCalled();
+    });
+
+    it("should handle errors from signTransaction", async () => {
+      // GIVEN
+      const error = new Error("Sign failed");
+      mockedSignTransaction.signTransaction.mockRejectedValue(error);
+      const transferInstruction = buildTransferInstruction(mockSignerContext);
+
+      // WHEN & THEN
+      await expect(
+        transferInstruction(
+          mockCurrency,
+          mockDeviceId,
+          mockAccount,
+          mockPartyId,
+          mockContractId,
+          "accept-transfer-instruction",
+        ),
+      ).rejects.toThrow("Sign failed");
+
+      expect(mockedGateway.prepareTransferInstruction).toHaveBeenCalled();
+      expect(mockedSignTransaction.signTransaction).toHaveBeenCalled();
+      expect(mockedGateway.submitTransferInstruction).not.toHaveBeenCalled();
+    });
+
+    it("should handle errors from submitTransferInstruction", async () => {
+      // GIVEN
+      const error = new Error("Submit failed");
+      mockedGateway.submitTransferInstruction.mockRejectedValue(error);
+      const transferInstruction = buildTransferInstruction(mockSignerContext);
+
+      // WHEN & THEN
+      await expect(
+        transferInstruction(
+          mockCurrency,
+          mockDeviceId,
+          mockAccount,
+          mockPartyId,
+          mockContractId,
+          "accept-transfer-instruction",
+        ),
+      ).rejects.toThrow("Submit failed");
+
+      expect(mockedGateway.prepareTransferInstruction).toHaveBeenCalled();
+      expect(mockedSignTransaction.signTransaction).toHaveBeenCalled();
+      expect(mockedGateway.submitTransferInstruction).toHaveBeenCalled();
+    });
+  });
+});

package/src/bridge/acceptOffer.ts

@@ -0,0 +1,36 @@
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { Account } from "@ledgerhq/types-live";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+
+import { prepareTransferInstruction, submitTransferInstruction } from "../network/gateway";
+import { signTransaction } from "../common-logic/transaction/sign";
+import type { CantonSigner } from "../types";
+
+type TransferInstructionType =
+  | "accept-transfer-instruction"
+  | "reject-transfer-instruction"
+  | "withdraw-transfer-instruction";
+
+export const buildTransferInstruction =
+  (signerContext: SignerContext<CantonSigner>) =>
+  async (
+    currency: CryptoCurrency,
+    deviceId: string,
+    account: Account,
+    partyId: string,
+    contractId: string,
+    type: TransferInstructionType,
+    reason?: string,
+  ) => {
+    const preparedTransaction = await prepareTransferInstruction(currency, partyId, {
+      type,
+      contract_id: contractId,
+      ...(reason && { reason }),
+    });
+
+    const { signature } = await signerContext(deviceId, async signer => {
+      return await signTransaction(signer, account.freshAddressPath, preparedTransaction);
+    });
+
+    await submitTransferInstruction(currency, partyId, preparedTransaction.serialized, signature);
+  };

package/src/bridge/getTransactionStatus.test.ts

@@ -311,6 +311,7 @@ describe("getTransactionStatus", () => {
       const accountWithManyUtxos = {
         ...mockAccount,
         cantonResources: {
+          pendingTransferProposals: [],
           instrumentUtxoCounts: {
             Amulet: TO_MANY_UTXOS_WARNING_COUNT + 1,
           },

package/src/bridge/index.ts

@@ -21,6 +21,7 @@ import { buildSignOperation } from "./signOperation";
 import { makeGetAccountShape } from "./sync";
 import { updateTransaction } from "./updateTransaction";
 import { buildOnboardAccount, buildAuthorizePreapproval } from "./onboard";
+import { buildTransferInstruction } from "./acceptOffer";
 import { assignToAccountRaw, assignFromAccountRaw } from "./serialization";
 
 export function createBridges(
@@ -39,6 +40,7 @@ export function createBridges(
 
   const onboardAccount = buildOnboardAccount(signerContext);
   const authorizePreapproval = buildAuthorizePreapproval(signerContext);
+  const transferInstruction = buildTransferInstruction(signerContext);
 
   const currencyBridge: CantonCurrencyBridge = {
     preload: () => Promise.resolve({}),
@@ -46,6 +48,7 @@ export function createBridges(
     scanAccounts,
     onboardAccount,
     authorizePreapproval,
+    transferInstruction,
   };
 
   const signOperation = buildSignOperation(signerContext);

package/src/bridge/serialization.ts

@@ -6,7 +6,7 @@ import {
   type CantonResourcesRaw,
 } from "../types";
 
-function isCantonAccount(account: Account): account is CantonAccount {
+export function isCantonAccount(account: Account): account is CantonAccount {
   return "cantonResources" in account;
 }
 
@@ -15,15 +15,17 @@ function isCantonAccountRaw(accountRaw: AccountRaw): accountRaw is CantonAccount
 }
 
 function toResourcesRaw(r: CantonResources): CantonResourcesRaw {
-  const { instrumentUtxoCounts } = r;
+  const { instrumentUtxoCounts, pendingTransferProposals } = r;
   return {
     instrumentUtxoCounts,
+    pendingTransferProposals,
   };
 }
 
 function fromResourcesRaw(r: CantonResourcesRaw): CantonResources {
   return {
     instrumentUtxoCounts: r.instrumentUtxoCounts,
+    pendingTransferProposals: r.pendingTransferProposals,
   };
 }
 

package/src/bridge/sync.ts

@@ -4,12 +4,18 @@ 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 { getLedgerEnd, getOperations, type OperationInfo } from "../network/gateway";
+import {
+  getLedgerEnd,
+  getOperations,
+  type OperationInfo,
+  getPendingTransferProposals,
+} from "../network/gateway";
 import { getBalance, type CantonBalance } from "../common-logic/account/getBalance";
 import coinConfig from "../config";
 import resolver from "../signer";
 import { CantonAccount, CantonSigner } from "../types";
-import { isAccountOnboarded, isCantonCoinPreapproved } from "./onboard";
+import { isAccountOnboarded } from "./onboard";
+import { isCantonAccountEmpty } from "../helpers";
 
 const txInfoToOperationAdapter =
   (accountId: string, partyId: string) =>
@@ -107,6 +113,9 @@ export function makeGetAccountShape(
 
     const { nativeInstrumentId } = coinConfig.getCoinConfig(currency);
     const balances = xpubOrAddress ? await getBalance(currency, xpubOrAddress) : [];
+    const pendingTransferProposals = xpubOrAddress
+      ? await getPendingTransferProposals(currency, xpubOrAddress)
+      : [];
 
     const balancesData = (balances || []).reduce(
       (acc, balance) => {
@@ -141,10 +150,15 @@ export function makeGetAccountShape(
       operations = mergeOps(oldOperations, newOperations);
     }
 
-    const isPreapproved = xpubOrAddress
-      ? await isCantonCoinPreapproved(currency, xpubOrAddress)
-      : false;
-    const used = isPreapproved && totalBalance.gt(0);
+    const used = !isCantonAccountEmpty({
+      operationsCount: operations.length,
+      balance: totalBalance,
+      subAccounts: initialAccount?.subAccounts ?? [],
+      cantonResources: {
+        instrumentUtxoCounts,
+        pendingTransferProposals,
+      },
+    });
 
     const blockHeight = await getLedgerEnd(currency);
 
@@ -169,6 +183,7 @@ export function makeGetAccountShape(
       used,
       cantonResources: {
         instrumentUtxoCounts,
+        pendingTransferProposals,
       },
     };