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

package/src/bridge/sync.test.ts

@@ -52,6 +52,7 @@ describe("makeGetAccountShape", () => {
     mockedCoinConfig.mockReturnValue({
       nativeInstrumentId: "Native",
       minReserve: "0",
+      useGateway: true,
     });
 
     mockedIsAuthorized.mockResolvedValue(true);
@@ -64,6 +65,7 @@ describe("makeGetAccountShape", () => {
         instrument_id: "Native",
         amount: "1000",
         locked: false,
+        utxo_count: 1,
       },
     ]);
     mockedGetOperations.mockResolvedValue({
@@ -113,11 +115,13 @@ describe("makeGetAccountShape", () => {
         instrument_id: "LockedNative",
         amount: "1000",
         locked: true,
+        utxo_count: 1,
       },
       {
         instrument_id: "Native",
         amount: "10",
         locked: false,
+        utxo_count: 1,
       },
     ]);
 
@@ -128,7 +132,7 @@ describe("makeGetAccountShape", () => {
 
     expect(shape).toBeDefined();
     expect(shape.balance).toEqual(BigNumber(1010));
-    expect(shape.spendableBalance).toEqual(BigNumber(10));
+    expect(shape.spendableBalance).toEqual(BigNumber(1010));
   });
 
   it("should handle empty balances correctly", async () => {

package/src/bridge/sync.ts

@@ -4,7 +4,8 @@ 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 { getLedgerEnd, getOperations, type OperationInfo } 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";
@@ -108,18 +109,25 @@ export function makeGetAccountShape(
     const balances = xpubOrAddress ? await getBalance(currency, xpubOrAddress) : [];
 
     const balancesData = (balances || []).reduce(
-      (acc, { amount, instrument_id, locked }) => {
-        acc[instrument_id] = { amount, locked };
+      (acc, balance) => {
+        acc[balance.instrumentId] = balance;
         return acc;
       },
-      {} as Record<string, { amount: string; locked: boolean }>,
+      {} as Record<string, CantonBalance>,
     );
 
-    const unlockedAmount = new BigNumber(balancesData[nativeInstrumentId]?.amount || "0");
-    const lockedAmount = new BigNumber(balancesData[`Locked${nativeInstrumentId}`]?.amount || "0");
+    const unlockedAmount = new BigNumber(balancesData[nativeInstrumentId]?.value.toString() || "0");
+    const lockedAmount = new BigNumber(
+      balancesData[`Locked${nativeInstrumentId}`]?.value.toString() || "0",
+    );
     const totalBalance = unlockedAmount.plus(lockedAmount);
     const reserveMin = new BigNumber(coinConfig.getCoinConfig(currency).minReserve || 0);
-    const spendableBalance = BigNumber.max(0, unlockedAmount.minus(reserveMin));
+    const spendableBalance = BigNumber.max(0, totalBalance.minus(reserveMin));
+
+    const instrumentUtxoCounts: Record<string, number> = {};
+    for (const [instrumentId, balance] of Object.entries(balancesData)) {
+      instrumentUtxoCounts[instrumentId] = balance.utxoCount;
+    }
 
     let operations: Operation[] = [];
     if (xpubOrAddress) {
@@ -159,6 +167,9 @@ export function makeGetAccountShape(
       spendableBalance,
       xpub: xpubOrAddress,
       used,
+      cantonResources: {
+        instrumentUtxoCounts,
+      },
     };
 
     return shape;

package/src/bridge/transaction.ts

@@ -48,7 +48,7 @@ export const toTransactionRaw = (t: Transaction): TransactionRaw => {
   return {
     ...common,
     family: t.family,
-    fee: t.fee ? t.fee.toString() : null,
+    fee: t.fee ? t.fee.toFixed() : null,
     tokenId: t.tokenId,
   };
 };

package/src/common-logic/account/getBalance.ts

@@ -3,12 +3,17 @@ import { getBalance as gatewayGetBalance, type InstrumentBalance } from "../../n
 import coinConfig from "../../config";
 import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
+export type CantonBalance = Balance & {
+  utxoCount: number;
+  instrumentId: string;
+};
+
 const useGateway = (currency: CryptoCurrency) =>
   coinConfig.getCoinConfig(currency).useGateway === true;
 const getNativeId = (currency: CryptoCurrency) =>
   coinConfig.getCoinConfig(currency).nativeInstrumentId;
 
-function adaptInstrument(currency: CryptoCurrency, instrument: InstrumentBalance): Balance {
+function adaptInstrument(currency: CryptoCurrency, instrument: InstrumentBalance): CantonBalance {
   return {
     value: BigInt(instrument.amount),
     locked: instrument.locked === true ? BigInt(instrument.amount) : BigInt(0),
@@ -16,10 +21,15 @@ function adaptInstrument(currency: CryptoCurrency, instrument: InstrumentBalance
       getNativeId(currency) === instrument.instrument_id
         ? { type: "native" }
         : { type: "token", assetReference: instrument.instrument_id },
+    utxoCount: instrument.utxo_count,
+    instrumentId: instrument.instrument_id,
   };
 }
 
-export async function getBalance(currency: CryptoCurrency, partyId: string): Promise<Balance[]> {
+export async function getBalance(
+  currency: CryptoCurrency,
+  partyId: string,
+): Promise<CantonBalance[]> {
   if (useGateway(currency))
     return (await gatewayGetBalance(currency, partyId)).map(instrument =>
       adaptInstrument(currency, instrument),

package/src/common-logic/account/getBalance.unit.test.ts

@@ -29,11 +29,13 @@ describe("getBalance", () => {
       {
         instrument_id: "native-id",
         amount: "1000",
+        utxo_count: 1,
         locked: false,
       },
       {
         instrument_id: "token-123",
         amount: "5000",
+        utxo_count: 1,
         locked: true,
       },
     ];
@@ -43,16 +45,20 @@ describe("getBalance", () => {
     const result = await getBalance(mockCurrency, "party-id");
 
     expect(getBalanceFromNetwork).toHaveBeenCalledWith(mockCurrency, "party-id");
-    expect(result).toEqual<Balance[]>([
+    expect(result).toEqual([
       {
         value: BigInt(1000),
         locked: BigInt(0),
         asset: { type: "native" },
+        utxoCount: 1,
+        instrumentId: "native-id",
       },
       {
         value: BigInt(5000),
         locked: BigInt(5000),
         asset: { type: "token", assetReference: "token-123" },
+        utxoCount: 1,
+        instrumentId: "token-123",
       },
     ]);
   });

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";

package/src/common-logic/transaction/craftTransaction.ts

@@ -27,7 +27,7 @@ export async function craftTransaction(
 }> {
   const params: PrepareTransferRequest = {
     recipient: transaction.recipient || "",
-    amount: transaction.amount.toString(),
+    amount: transaction.amount.toFixed(),
     type: "token-transfer-request" as const,
     execute_before_secs: transaction.expireInSeconds,
     instrument_id: transaction.tokenId,

package/src/common-logic/transaction/estimateFees.test.ts

@@ -47,4 +47,14 @@ describe("estimateFees", () => {
     // 3 CC
     expect(result).toEqual(3n * magnitude);
   });
+
+  it("returns forced fees when 0 is setup in config", async () => {
+    mockGetCoinConfig.mockReturnValue({
+      fee: 0,
+    } as unknown as coinConfigModule.CantonCoinConfig);
+
+    const result = await estimateFees(mockCurrency, 1000n * magnitude);
+
+    expect(result).toEqual(0n);
+  });
 });

package/src/common-logic/transaction/estimateFees.ts

@@ -21,7 +21,7 @@ const feeValue = (currency: CryptoCurrency) => coinConfig.getCoinConfig(currency
 
 export async function estimateFees(currency: CryptoCurrency, amount: bigint): Promise<bigint> {
   const forcedValue = feeValue(currency);
-  if (forcedValue) {
+  if (forcedValue !== undefined) {
     return Promise.resolve(BigInt(forcedValue) * magnitude);
   } else {
     return Promise.resolve(

package/src/common-logic/transaction/sign.test.ts

@@ -0,0 +1,389 @@
+import { OnboardingPrepareResponse, PrepareTransferResponse } from "../../network/gateway";
+import {
+  CantonPreparedTransaction,
+  CantonSigner,
+  CantonSignature,
+  CantonUntypedVersionedMessage,
+} from "../../types/signer";
+import { signTransaction } from "./sign";
+
+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("signTransaction", () => {
+  const mockSigner = new MockCantonSigner();
+  const mockDerivationPath = "44'/6767'/0'/0'/0'";
+
+  it("should sign prepared transaction", async () => {
+    // GIVEN
+    const mockPrepareTransferResponse: PrepareTransferResponse = {
+      json: {
+        transaction: {
+          version: "2.1",
+          roots: ["0"],
+          nodes: [
+            {
+              nodeId: "0",
+              v1: {
+                create: {
+                  lfVersion: "2.1",
+                  contractId: "test-contract-id",
+                  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: ["test::party"],
+            commandId: "test-command-id",
+          },
+          synchronizerId: "test-synchronizer-id",
+          transactionUuid: "test-transaction-uuid",
+          submissionTime: "1234567890",
+          inputContracts: [],
+        },
+      },
+      serialized: "serialized-transaction",
+      hash: "test-hash",
+    };
+
+    // WHEN
+    const result = await signTransaction(
+      mockSigner,
+      mockDerivationPath,
+      mockPrepareTransferResponse,
+    );
+
+    // THEN
+    expect(result).toEqual({ signature: "prepared-transaction-signature-10-1" });
+  });
+
+  it("should sign untyped versioned message", async () => {
+    // GIVEN
+    const mockOnboardingPrepareResponse: OnboardingPrepareResponse = {
+      party_id: "test-party-id",
+      party_name: "test-party-name",
+      public_key_fingerprint: "test-fingerprint",
+      transactions: {
+        namespace_transaction: {
+          serialized: "namespace-transaction-data",
+          json: {},
+          hash: "namespace-hash",
+        },
+        party_to_key_transaction: {
+          serialized: "party-to-key-transaction-data",
+          json: {},
+          hash: "party-to-key-hash",
+        },
+        party_to_participant_transaction: {
+          serialized: "party-to-participant-transaction-data",
+          json: {},
+          hash: "party-to-participant-hash",
+        },
+        combined_hash: "combined-hash",
+      },
+    };
+
+    // WHEN
+    const result = await signTransaction(
+      mockSigner,
+      mockDerivationPath,
+      mockOnboardingPrepareResponse,
+    );
+
+    // THEN
+    expect(result).toEqual({ signature: "untyped-signature-3" });
+  });
+
+  it("should handle empty signature from signer", async () => {
+    // GIVEN
+    const mockSignerWithEmptySignature = {
+      ...mockSigner,
+      signTransaction: jest.fn().mockResolvedValue(""),
+    } as unknown as CantonSigner;
+
+    const mockPrepareTransferResponse: PrepareTransferResponse = {
+      json: {
+        transaction: {
+          version: "2.1",
+          roots: ["0"],
+          nodes: [],
+        },
+        metadata: {
+          submitterInfo: {
+            actAs: ["test::party"],
+            commandId: "test-command-id",
+          },
+          synchronizerId: "test-synchronizer-id",
+          transactionUuid: "test-transaction-uuid",
+          submissionTime: "1234567890",
+          inputContracts: [],
+        },
+      },
+      serialized: "serialized-transaction",
+      hash: "test-hash",
+    };
+
+    // WHEN & THEN
+    await expect(
+      signTransaction(
+        mockSignerWithEmptySignature,
+        mockDerivationPath,
+        mockPrepareTransferResponse,
+      ),
+    ).rejects.toThrow("Device returned empty signature");
+  });
+
+  it("should handle signer errors", async () => {
+    // GIVEN
+    const mockSignerWithError = {
+      ...mockSigner,
+      signTransaction: jest.fn().mockRejectedValue(new Error("Signer error")),
+    } as unknown as CantonSigner;
+
+    const mockPrepareTransferResponse: PrepareTransferResponse = {
+      json: {
+        transaction: {
+          version: "2.1",
+          roots: ["0"],
+          nodes: [],
+        },
+        metadata: {
+          submitterInfo: {
+            actAs: ["test::party"],
+            commandId: "test-command-id",
+          },
+          synchronizerId: "test-synchronizer-id",
+          transactionUuid: "test-transaction-uuid",
+          submissionTime: "1234567890",
+          inputContracts: [],
+        },
+      },
+      serialized: "serialized-transaction",
+      hash: "test-hash",
+    };
+
+    // WHEN & THEN
+    await expect(
+      signTransaction(mockSignerWithError, mockDerivationPath, mockPrepareTransferResponse),
+    ).rejects.toThrow("Signer error");
+  });
+
+  it("should call signer with correct parameters for prepared transaction", async () => {
+    // GIVEN
+    const mockSignerSpy = jest.fn().mockResolvedValue({ signature: "test-signature" });
+    const mockSignerWithSpy = {
+      ...mockSigner,
+      signTransaction: mockSignerSpy,
+    } as unknown as CantonSigner;
+
+    const mockPrepareTransferResponse: PrepareTransferResponse = {
+      json: {
+        transaction: {
+          version: "2.1",
+          roots: ["0"],
+          nodes: [
+            {
+              nodeId: "0",
+              v1: {
+                create: {
+                  lfVersion: "2.1",
+                  contractId: "test-contract-id",
+                  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: ["test::party"],
+            commandId: "test-command-id",
+          },
+          synchronizerId: "test-synchronizer-id",
+          transactionUuid: "test-transaction-uuid",
+          submissionTime: "1234567890",
+          inputContracts: [],
+        },
+      },
+      serialized: "serialized-transaction",
+      hash: "test-hash",
+    };
+
+    // WHEN
+    await signTransaction(mockSignerWithSpy, mockDerivationPath, mockPrepareTransferResponse);
+
+    // THEN
+    expect(mockSignerSpy).toHaveBeenCalledWith(
+      mockDerivationPath,
+      expect.objectContaining({
+        damlTransaction: expect.any(Uint8Array),
+        nodes: expect.any(Array),
+        metadata: expect.any(Uint8Array),
+        inputContracts: expect.any(Array),
+      }),
+    );
+  });
+
+  it("should call signer with correct parameters for untyped versioned message without challenge", async () => {
+    // GIVEN
+    const mockSignerSpy = jest.fn().mockResolvedValue({ signature: "test-signature" });
+    const mockSignerWithSpy = {
+      ...mockSigner,
+      signTransaction: mockSignerSpy,
+    } as unknown as CantonSigner;
+
+    const mockOnboardingPrepareResponse: OnboardingPrepareResponse = {
+      party_id: "test-party-id",
+      party_name: "test-party-name",
+      public_key_fingerprint: "test-fingerprint",
+      transactions: {
+        namespace_transaction: {
+          serialized: "namespace-transaction-data",
+          json: {},
+          hash: "namespace-hash",
+        },
+        party_to_key_transaction: {
+          serialized: "party-to-key-transaction-data",
+          json: {},
+          hash: "party-to-key-hash",
+        },
+        party_to_participant_transaction: {
+          serialized: "party-to-participant-transaction-data",
+          json: {},
+          hash: "party-to-participant-hash",
+        },
+        combined_hash: "combined-hash",
+      },
+    };
+
+    // WHEN
+    await signTransaction(mockSignerWithSpy, mockDerivationPath, mockOnboardingPrepareResponse);
+
+    // THEN
+    expect(mockSignerSpy).toHaveBeenCalledWith(mockDerivationPath, {
+      transactions: [
+        "namespace-transaction-data",
+        "party-to-key-transaction-data",
+        "party-to-participant-transaction-data",
+      ],
+    });
+  });
+
+  it("should call signer with correct parameters for untyped versioned message with challenge", async () => {
+    const mockSignerSpy = jest.fn().mockResolvedValue({
+      signature: "main-signature",
+      applicationSignature: "challenge-signature",
+    });
+    const mockSignerWithSpy = {
+      ...mockSigner,
+      signTransaction: mockSignerSpy,
+    } as unknown as CantonSigner;
+
+    const mockOnboardingPrepareResponse: OnboardingPrepareResponse = {
+      party_id: "test-party-id",
+      party_name: "test-party-name",
+      public_key_fingerprint: "test-fingerprint",
+      challenge_nonce: "1234567890abcdef",
+      challenge_deadline: 1735689599,
+      transactions: {
+        namespace_transaction: {
+          serialized: "namespace-transaction-data",
+          json: {},
+          hash: "namespace-hash",
+        },
+        party_to_key_transaction: {
+          serialized: "party-to-key-transaction-data",
+          json: {},
+          hash: "party-to-key-hash",
+        },
+        party_to_participant_transaction: {
+          serialized: "party-to-participant-transaction-data",
+          json: {},
+          hash: "party-to-participant-hash",
+        },
+        combined_hash: "combined-hash",
+      },
+    };
+
+    const result = await signTransaction(
+      mockSignerWithSpy,
+      mockDerivationPath,
+      mockOnboardingPrepareResponse,
+    );
+
+    expect(result).toEqual({
+      signature: "main-signature",
+      applicationSignature: "challenge-signature",
+    });
+
+    expect(mockSignerSpy).toHaveBeenCalledWith(mockDerivationPath, {
+      transactions: [
+        "namespace-transaction-data",
+        "party-to-key-transaction-data",
+        "party-to-participant-transaction-data",
+      ],
+      challenge: "181234567890abcdef000000006774857f",
+    });
+  });
+});

package/src/common-logic/transaction/sign.ts

@@ -0,0 +1,59 @@
+import { OnboardingPrepareResponse, PrepareTransferResponse } from "../../network/gateway";
+import { PrepareTransactionResponse } from "../../types/onboard";
+import { CantonSigner, CantonSignature } from "../../types/signer";
+import { splitTransaction } from "./split";
+
+/**
+ * Sign a Canton transaction - handles both prepared transactions and untyped versioned messages
+ */
+
+export async function signTransaction(
+  signer: CantonSigner,
+  derivationPath: string,
+  transactionData: PrepareTransferResponse | PrepareTransactionResponse | OnboardingPrepareResponse,
+): Promise<CantonSignature> {
+  let signature: CantonSignature;
+
+  if ("json" in transactionData) {
+    const components = splitTransaction(transactionData.json);
+    signature = await signer.signTransaction(derivationPath, components);
+  } else {
+    const challenge = getTransactionChallenge(transactionData);
+
+    const transactions = [
+      transactionData.transactions.namespace_transaction.serialized,
+      transactionData.transactions.party_to_key_transaction.serialized,
+      transactionData.transactions.party_to_participant_transaction.serialized,
+    ];
+
+    signature = await signer.signTransaction(derivationPath, {
+      transactions,
+      ...(challenge && { challenge }),
+    });
+  }
+
+  if (!signature?.signature) {
+    throw new Error("Device returned empty signature");
+  }
+
+  return signature;
+}
+
+const getTransactionChallenge = ({
+  challenge_nonce,
+  challenge_deadline,
+}: OnboardingPrepareResponse) => {
+  if (!challenge_nonce || !challenge_deadline) {
+    return undefined;
+  }
+
+  try {
+    const deadlineHex = Buffer.alloc(8);
+    deadlineHex.writeBigInt64BE(BigInt(challenge_deadline), 0);
+
+    // Format: [length (1B) = 0x18][challenge (16 bytes)][deadline (8 bytes)]
+    return "18" + challenge_nonce.toLowerCase() + deadlineHex.toString("hex");
+  } catch (error) {
+    return undefined;
+  }
+};