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

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

@@ -1,45 +1,22 @@
-import BigNumber from "bignumber.js";
-import { firstValueFrom, toArray } from "rxjs";
 import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import { emptyHistoryCache } from "@ledgerhq/coin-framework/account/index";
-import { generateMockKeyPair, createMockSigner } from "../test/cantonTestUtils";
+import { firstValueFrom, toArray } from "rxjs";
+import coinConfig from "../config";
+import { createMockSigner, generateMockKeyPair } from "../test/cantonTestUtils";
+import { createMockAccount, createMockCantonCurrency } from "../test/fixtures";
 import {
   AuthorizeStatus,
-  OnboardStatus,
   CantonAuthorizeProgress,
   CantonAuthorizeResult,
   CantonOnboardProgress,
   CantonOnboardResult,
+  OnboardStatus,
 } from "../types/onboard";
-import coinConfig from "../config";
-import { buildOnboardAccount, isAccountOnboarded, buildAuthorizePreapproval } from "./onboard";
+import { buildAuthorizePreapproval, buildOnboardAccount, isAccountOnboarded } from "./onboard";
 
 describe("onboard (devnet)", () => {
   const mockDeviceId = "test-device-id";
-  const mockCurrency = {
-    id: "canton_network",
-  } as unknown as CryptoCurrency;
-  const mockAccount = {
-    type: "Account" as const,
-    id: "js:2:canton_network:canton_3f5c9d9a:canton",
-    seedIdentifier: "canton_3f5c9d9a",
-    derivationMode: "canton" as const,
-    index: 0,
-    freshAddress: "canton_3f5c9d9a",
-    freshAddressPath: "44'/6767'/0'/0'/0'",
-    used: false,
-    balance: BigNumber(10000),
-    spendableBalance: BigNumber(10000),
-    creationDate: new Date(),
-    blockHeight: 1,
-    currency: mockCurrency,
-    operationsCount: 0,
-    operations: [],
-    pendingOperations: [],
-    lastSyncDate: new Date(),
-    balanceHistoryCache: emptyHistoryCache,
-    swapHistory: [],
-  };
+  const mockCurrency = createMockCantonCurrency();
+  const mockAccount = createMockAccount();
 
   let onboardedAccount: {
     keyPair: ReturnType<typeof generateMockKeyPair>;

package/src/bridge/onboard.ts

@@ -89,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
@@ -144,7 +145,7 @@ export const buildAuthorizePreapproval =
 
           o.next({ status: AuthorizeStatus.SIGN });
 
-          const signature = await signerContext(deviceId, async signer => {
+          const { signature } = await signerContext(deviceId, async signer => {
             return await signTransaction(signer, account.freshAddressPath, preparedTransaction);
           });
           o.next({ status: AuthorizeStatus.SUBMIT });
@@ -162,7 +163,7 @@ export const buildAuthorizePreapproval =
               if (serialized && hash) {
                 o.next({ status: AuthorizeStatus.SIGN });
 
-                const signature = await signerContext(deviceId, signer =>
+                const { signature } = await signerContext(deviceId, signer =>
                   signer.signTransaction(account.freshAddressPath, hash),
                 );
 

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

@@ -1,9 +1,15 @@
 import { BigNumber } from "bignumber.js";
-import { CantonSigner, CantonPreparedTransaction } from "../types";
+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");
@@ -26,12 +32,22 @@ class MockCantonSigner implements CantonSigner {
 
   async signTransaction(
     path: string,
-    data: CantonPreparedTransaction | { transactions: string[] },
-  ) {
-    if ("transactions" in data) {
-      return `untyped-signature-${data.transactions.length}`;
+    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 `prepared-transaction-signature-${data.damlTransaction.length}-${data.nodes.length}`;
+      return {
+        signature: `prepared-transaction-signature-${data.damlTransaction.length}-${data.nodes.length}`,
+      };
     }
   }
 }
@@ -39,25 +55,18 @@ class MockCantonSigner implements CantonSigner {
 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 = {
+  const mockAccount = createMockAccount({
     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",

package/src/bridge/signOperation.ts

@@ -50,13 +50,13 @@ export const buildSignOperation =
               params,
             );
 
-            const transactionSignature = await signTransaction(signer, derivationPath, {
+            const { signature } = await signTransaction(signer, derivationPath, {
               json: nativeTransaction,
               serialized: serializedTransaction,
               hash: hash,
             });
 
-            return combine(serializedTransaction, `${transactionSignature}__PARTY__${address}`);
+            return combine(serializedTransaction, `${signature}__PARTY__${address}`);
           });
 
           o.next({

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,
       },
     ]);
 

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,19 +109,26 @@ 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 instrumentUtxoCounts: Record<string, number> = {};
+    for (const [instrumentId, balance] of Object.entries(balancesData)) {
+      instrumentUtxoCounts[instrumentId] = balance.utxoCount;
+    }
+
     let operations: Operation[] = [];
     if (xpubOrAddress) {
       const oldOperations = initialAccount?.operations || [];
@@ -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/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/sign.test.ts

@@ -1,5 +1,10 @@
 import { OnboardingPrepareResponse, PrepareTransferResponse } from "../../network/gateway";
-import { CantonPreparedTransaction, CantonSigner } from "../../types/signer";
+import {
+  CantonPreparedTransaction,
+  CantonSigner,
+  CantonSignature,
+  CantonUntypedVersionedMessage,
+} from "../../types/signer";
 import { signTransaction } from "./sign";
 
 class MockCantonSigner implements CantonSigner {
@@ -13,12 +18,22 @@ class MockCantonSigner implements CantonSigner {
 
   async signTransaction(
     path: string,
-    data: CantonPreparedTransaction | { transactions: string[] },
-  ) {
-    if ("transactions" in data) {
-      return `untyped-signature-${data.transactions.length}`;
+    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 `prepared-transaction-signature-${data.damlTransaction.length}-${data.nodes.length}`;
+      return {
+        signature: `prepared-transaction-signature-${data.damlTransaction.length}-${data.nodes.length}`,
+      };
     }
   }
 }
@@ -85,7 +100,7 @@ describe("signTransaction", () => {
     );
 
     // THEN
-    expect(result).toBe("prepared-transaction-signature-10-1");
+    expect(result).toEqual({ signature: "prepared-transaction-signature-10-1" });
   });
 
   it("should sign untyped versioned message", async () => {
@@ -122,7 +137,7 @@ describe("signTransaction", () => {
     );
 
     // THEN
-    expect(result).toBe("untyped-signature-3");
+    expect(result).toEqual({ signature: "untyped-signature-3" });
   });
 
   it("should handle empty signature from signer", async () => {
@@ -201,7 +216,7 @@ describe("signTransaction", () => {
 
   it("should call signer with correct parameters for prepared transaction", async () => {
     // GIVEN
-    const mockSignerSpy = jest.fn().mockResolvedValue("test-signature");
+    const mockSignerSpy = jest.fn().mockResolvedValue({ signature: "test-signature" });
     const mockSignerWithSpy = {
       ...mockSigner,
       signTransaction: mockSignerSpy,
@@ -270,9 +285,9 @@ describe("signTransaction", () => {
     );
   });
 
-  it("should call signer with correct parameters for untyped versioned message", async () => {
+  it("should call signer with correct parameters for untyped versioned message without challenge", async () => {
     // GIVEN
-    const mockSignerSpy = jest.fn().mockResolvedValue("test-signature");
+    const mockSignerSpy = jest.fn().mockResolvedValue({ signature: "test-signature" });
     const mockSignerWithSpy = {
       ...mockSigner,
       signTransaction: mockSignerSpy,
@@ -314,4 +329,61 @@ describe("signTransaction", () => {
       ],
     });
   });
+
+  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

@@ -1,33 +1,59 @@
 import { OnboardingPrepareResponse, PrepareTransferResponse } from "../../network/gateway";
 import { PrepareTransactionResponse } from "../../types/onboard";
-import { CantonSigner } from "../../types/signer";
+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 | OnboardingPrepareResponse | PrepareTransactionResponse,
-): Promise<string> {
-  let signature: 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 });
+
+    signature = await signer.signTransaction(derivationPath, {
+      transactions,
+      ...(challenge && { challenge }),
+    });
   }
 
-  if (!signature || signature.length === 0) {
+  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;
+  }
+};

package/src/network/gateway.integ.test.ts

@@ -83,12 +83,9 @@ describe("gateway (devnet)", () => {
       const signature = keyPair.sign(prepareResponse.transactions.combined_hash);
 
       // WHEN
-      const response = await submitOnboarding(
-        mockCurrency,
-        keyPair.publicKeyHex,
-        prepareResponse,
+      const response = await submitOnboarding(mockCurrency, keyPair.publicKeyHex, prepareResponse, {
         signature,
-      );
+      });
 
       // Save onboarded account for next tests that need a valid party ID
       onboardedAccount = {
@@ -118,7 +115,7 @@ describe("gateway (devnet)", () => {
           mockCurrency,
           keyPair.publicKeyHex,
           prepareResponse!,
-          signature,
+          { signature },
         );
 
         // THEN