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

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

@@ -0,0 +1,50 @@
+import prepareTransferMockSerialized from "../../test/prepare-transfer-serialized.json";
+import prepareTransferMock from "../../test/prepare-transfer.json";
+import { splitTransaction } from "./split";
+
+function uint8ArrayToHex(bytes: Uint8Array): string {
+  return Array.from(bytes, b => b.toString(16).padStart(2, "0")).join("");
+}
+
+describe("splitTransaction", () => {
+  it("should split transaction correctly", () => {
+    const transactionData = prepareTransferMock;
+    const result = splitTransaction(transactionData);
+
+    expect(result).toBeDefined();
+    expect(result.damlTransaction).toBeInstanceOf(Uint8Array);
+    expect(result.nodes).toBeInstanceOf(Array);
+    expect(result.metadata).toBeInstanceOf(Uint8Array);
+    expect(result.inputContracts).toBeInstanceOf(Array);
+  });
+
+  it("should properly serialize damlTransaction", () => {
+    const transactionData = prepareTransferMock;
+    const { damlTransaction } = splitTransaction(transactionData);
+
+    expect(uint8ArrayToHex(damlTransaction)).toEqual(prepareTransferMockSerialized.damlTransaction);
+  });
+
+  it("should properly serialize nodes", () => {
+    const transactionData = prepareTransferMock;
+    const { nodes } = splitTransaction(transactionData);
+
+    expect(nodes.map(uint8ArrayToHex)).toEqual(prepareTransferMockSerialized.nodes);
+  });
+
+  it("should properly serialize metadata", () => {
+    const transactionData = prepareTransferMock;
+    const { metadata } = splitTransaction(transactionData);
+
+    expect(uint8ArrayToHex(metadata)).toEqual(prepareTransferMockSerialized.metadata);
+  });
+
+  it("should properly serialize inputContracts", () => {
+    const transactionData = prepareTransferMock;
+    const { inputContracts } = splitTransaction(transactionData);
+
+    expect(inputContracts.map(uint8ArrayToHex)).toEqual(
+      prepareTransferMockSerialized.inputContracts,
+    );
+  });
+});

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

@@ -0,0 +1,101 @@
+import * as protobuf from "protobufjs";
+import { PrepareTransferResponse } from "../../network/gateway";
+import { CantonPreparedTransaction } from "../../types/signer";
+import * as transactionProto from "../../types/transaction-proto.json";
+
+const root: { [key: string]: any } = protobuf.Root.fromJSON(transactionProto) || {};
+
+const RESERVED_WORDS = {
+  bool: "bool_",
+  enum: "enum_",
+  constructor: "constructor_",
+};
+
+const replaceReservedWords = (obj: any): any => {
+  if (obj === null || typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(replaceReservedWords);
+
+  const transformed: any = {};
+  for (const [key, value] of Object.entries(obj)) {
+    transformed[RESERVED_WORDS[key as keyof typeof RESERVED_WORDS] || key] =
+      replaceReservedWords(value);
+  }
+  return transformed;
+};
+
+/**
+ * Splits a Canton transaction into components for prepared transaction signing.
+ * Converts protobuf transaction data into structured components that can be
+ * sent to the Ledger device for signing.
+ */
+export function splitTransaction(
+  transaction: PrepareTransferResponse["json"],
+): CantonPreparedTransaction {
+  const { transaction: transactionData, metadata } = transaction;
+
+  // Process DAML transaction
+  const DeviceDamlTransaction = root.lookupType(
+    "com.daml.ledger.api.v2.interactive.DeviceDamlTransaction",
+  );
+
+  const damlTransactionBytes = DeviceDamlTransaction.encode({
+    version: transactionData.version,
+    roots: transactionData.roots,
+    nodesCount: transactionData.nodes?.length || 0,
+    nodeSeeds: (transactionData.nodeSeeds || []).map((seed: any) => ({
+      seed: Uint8Array.from(Buffer.from(seed.seed, "base64")),
+      ...(seed.nodeId && seed.nodeId !== 0 && { nodeId: seed.nodeId }),
+    })),
+  }).finish();
+
+  // Process input contracts
+  const inputContracts = (metadata.inputContracts || []).map((contract: any) => {
+    const { eventBlob, ...contractWithoutBlob } = contract;
+    const InputContract = root.lookupType(
+      "com.daml.ledger.api.v2.interactive.DeviceMetadata.InputContract",
+    );
+    const contractPb = InputContract.fromObject(replaceReservedWords(contractWithoutBlob));
+    return InputContract.encode(contractPb).finish();
+  });
+
+  // Process metadata
+  const metadataData = {
+    submitterInfo: {
+      actAs: metadata.submitterInfo.actAs,
+      commandId: metadata.submitterInfo.commandId,
+    },
+    synchronizerId: metadata.synchronizerId,
+    ...(metadata.mediatorGroup !== undefined && { mediatorGroup: metadata.mediatorGroup }),
+    transactionUuid: metadata.transactionUuid,
+    submissionTime: Number.parseInt(metadata.preparationTime, 10),
+    inputContractsCount: metadata.inputContracts?.length || 0,
+    ...(metadata.minLedgerEffectiveTime && {
+      minLedgerEffectiveTime: Number.parseInt(metadata.minLedgerEffectiveTime, 10),
+    }),
+    ...(metadata.maxLedgerEffectiveTime && {
+      maxLedgerEffectiveTime: Number.parseInt(metadata.maxLedgerEffectiveTime, 10),
+    }),
+  };
+
+  const DeviceMetadata = root.lookupType("com.daml.ledger.api.v2.interactive.DeviceMetadata");
+  const metadataBytes = DeviceMetadata.encode(metadataData).finish();
+
+  // Process nodes
+  const nodesArray = transactionData.nodes || [];
+  const nodes = new Array(nodesArray.length);
+
+  for (const node of nodesArray) {
+    const nodeId = Number.parseInt(node.nodeId || "0", 10);
+    const Node = root.lookupType("com.daml.ledger.api.v2.interactive.DeviceDamlTransaction.Node");
+    const nodePb = Node.fromObject(replaceReservedWords(node));
+    const pos = nodesArray.length - 1 - nodeId;
+    nodes[pos] = Node.encode(nodePb).finish();
+  }
+
+  return {
+    damlTransaction: damlTransactionBytes,
+    nodes,
+    metadata: metadataBytes,
+    inputContracts,
+  };
+}

package/src/common-logic/utils.test.ts

@@ -5,18 +5,9 @@ describe("utils", () => {
   describe("isRecipientValid", () => {
     it("should return true for valid Canton addresses", () => {
       const validAddresses = [
-        "abc::123",
-        "hello::1",
-        "test123::456",
-        "a::0",
-        "party::999",
-        "user123::42",
-        "canton_1a2b3c4d5e6f7g8h9i0j1k2l3m4n5o6p7q8r9s0t1u2v3w4x5y6z::123",
-        "test::123456789",
-        "abc::abc", // letters after ::
-        "test::ABC123", // mixed case letters and numbers
-        "user::a1b2c3", // alphanumeric after ::
-        "contract::XyZ789", // mixed case with numbers
+        "ldg::1220691e945dc1b210f3b6be9fbad73efaf642bfb96022552f66c9e2b83b00cb20e8",
+        "ldg-with-dash::1220691e945dc1b210f3b6be9fbad73efaf642bfb96022552f66c9e2b83b00cb20e8",
+        "ldg-with-number-1::1220691e945dc1b210f3b6be9fbad73efaf642bfb96022552f66c9e2b83b00cb20e8",
       ];
 
       validAddresses.forEach(address => {
@@ -26,6 +17,8 @@ describe("utils", () => {
 
     it("should return false for invalid Canton addresses", () => {
       const invalidAddresses = [
+        "ldg::1220691e945dc1b210f3b6be9fbad73efaf642bfb96022552f66c9e2b83b00cb20e", // too short fingerprint
+        "ldg::1220691e945dc1b210f3b6be9fbad73efaf642bfb96022552f66c9e2b83b00cb20e80", // too long fingerprint
         "", // empty string
         "::123", // no characters before ::
         "abc::", // no characters after ::
@@ -53,26 +46,25 @@ describe("utils", () => {
     });
 
     it("should handle edge cases", () => {
-      expect(isRecipientValid("a::1")).toBe(true); // minimum valid case with number
-      expect(isRecipientValid("a::a")).toBe(true); // minimum valid case with letter
-      expect(isRecipientValid("1::1")).toBe(true); // number before ::
-      expect(isRecipientValid("1::a")).toBe(true); // number before ::, letter after
-      expect(isRecipientValid("_::1")).toBe(true); // underscore before ::
-      expect(isRecipientValid("_::a")).toBe(true); // underscore before ::, letter after
-      expect(isRecipientValid("-::1")).toBe(true); // dash before ::
-      expect(isRecipientValid("-::a")).toBe(true); // dash before ::, letter after
-      expect(isRecipientValid(".::1")).toBe(true); // dot before ::
-      expect(isRecipientValid(".::a")).toBe(true); // dot before ::, letter after
+      const validHex68 = "1220691e945dc1b210f3b6be9fbad73efaf642bfb96022552f66c9e2b83b00cb20e8";
+      expect(isRecipientValid(`a::${validHex68}`)).toBe(true); // single letter prefix
+      expect(isRecipientValid(`1::${validHex68}`)).toBe(true); // single number prefix
+      expect(isRecipientValid(`a-1::${validHex68}`)).toBe(true); // prefix with dash
+
+      // Invalid edge cases (should be false)
+      expect(isRecipientValid("a::1")).toBe(false); // too short hex
+      expect(isRecipientValid("a::a")).toBe(false); // too short hex
+      expect(isRecipientValid("_::1")).toBe(false); // invalid prefix character
+      expect(isRecipientValid(".::1")).toBe(false); // invalid prefix character
     });
 
-    it("should handle addresses with spaces and multiple colons", () => {
-      // These are valid according to our regex but might not be ideal Canton addresses
-      expect(isRecipientValid(" abc::123")).toBe(true); // space before address
-      expect(isRecipientValid(" abc::abc")).toBe(true); // space before address with letters
-      expect(isRecipientValid("abc ::123")).toBe(true); // space before ::
-      expect(isRecipientValid("abc ::abc")).toBe(true); // space before :: with letters
-      expect(isRecipientValid("abc::123::456")).toBe(true); // multiple ::
-      expect(isRecipientValid("abc::abc::def")).toBe(true); // multiple :: with letters
+    it("should reject addresses with spaces and multiple colons", () => {
+      expect(isRecipientValid(" abc::123")).toBe(false); // space before address
+      expect(isRecipientValid(" abc::abc")).toBe(false); // space before address with letters
+      expect(isRecipientValid("abc ::123")).toBe(false); // space before ::
+      expect(isRecipientValid("abc ::abc")).toBe(false); // space before :: with letters
+      expect(isRecipientValid("abc::123::456")).toBe(false); // multiple ::
+      expect(isRecipientValid("abc::abc::def")).toBe(false); // multiple :: with letters
     });
   });
 

package/src/common-logic/utils.ts

@@ -8,9 +8,9 @@ export const validateTag = (tag: BigNumber) => {
   );
 };
 
-const CANTON_ADDRESS_REGEX = /^.+::[a-zA-Z0-9]+$/;
+const CANTON_ADDRESS_REGEX = /^[a-zA-Z0-9-]+::[a-fA-F0-9]{68}$/;
 
 export function isRecipientValid(recipient: string): boolean {
-  // Canton address format: at least 1 character :: at least 1 alphanumeric character
+  // Canton address format: alphanumeric with dashes :: 68 hexadecimal characters
   return CANTON_ADDRESS_REGEX.test(recipient);
 }

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 = {
@@ -107,6 +104,8 @@ describe("gateway (devnet)", () => {
     testIfPrepared(
       "should not throw when already onboarded",
       async () => {
+        // Add delay to ensure previous operations are complete
+        await new Promise(resolve => setTimeout(resolve, 10000));
         // GIVEN
         const { keyPair } = getOnboardedAccount();
         const signature = keyPair.sign(prepareResponse!.transactions.combined_hash);
@@ -116,7 +115,7 @@ describe("gateway (devnet)", () => {
           mockCurrency,
           keyPair.publicKeyHex,
           prepareResponse!,
-          signature,
+          { signature },
         );
 
         // THEN

package/src/network/gateway.ts

@@ -10,6 +10,7 @@ import {
   PreApprovalResult,
 } from "../types/onboard";
 import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import type { CantonSignature } from "../types/signer";
 
 export type OnboardingPrepareResponse = {
   party_id: string;
@@ -33,6 +34,8 @@ export type OnboardingPrepareResponse = {
     };
     combined_hash: string;
   };
+  challenge_nonce?: string;
+  challenge_deadline?: number;
 };
 
 type OnboardingPrepareRequest = {
@@ -59,6 +62,7 @@ type OnboardingSubmitRequest = {
   prepare_request: OnboardingPrepareRequest;
   prepare_response: OnboardingPrepareResponse;
   signature: string;
+  application_signature?: string;
 };
 
 type OnboardingSubmitResponse = {
@@ -87,6 +91,7 @@ export type InstrumentBalance = {
   instrument_id: string;
   amount: string;
   locked: boolean;
+  utxo_count: number;
 };
 
 type PartyInfo = {
@@ -283,7 +288,8 @@ export type OperationInfo =
 const getGatewayUrl = (currency: CryptoCurrency) => coinConfig.getCoinConfig(currency).gatewayUrl;
 const getNodeId = (currency: CryptoCurrency) =>
   coinConfig.getCoinConfig(currency).nodeId || "ledger-live-devnet";
-const getNetworkType = (currency: CryptoCurrency) => coinConfig.getCoinConfig(currency).networkType;
+export const getNetworkType = (currency: CryptoCurrency) =>
+  coinConfig.getCoinConfig(currency).networkType;
 
 const gatewayNetwork = <T, U = unknown>(req: LiveNetworkRequest<U>) => {
   const API_KEY = getEnv("CANTON_API_KEY");
@@ -324,7 +330,7 @@ export async function submitOnboarding(
   currency: CryptoCurrency,
   publicKey: string,
   prepareResponse: OnboardingPrepareResponse,
-  signature: string,
+  { signature, applicationSignature }: CantonSignature,
 ) {
   try {
     const { data } = await gatewayNetwork<OnboardingSubmitResponse, OnboardingSubmitRequest>({
@@ -337,6 +343,7 @@ export async function submitOnboarding(
         },
         prepare_response: prepareResponse,
         signature,
+        ...(applicationSignature ? { application_signature: applicationSignature } : {}),
       },
     });
     return data;
@@ -448,18 +455,13 @@ export async function prepareTapRequest(
   currency: CryptoCurrency,
   { partyId, amount = 1000000 }: PrepareTapRequest,
 ) {
-  if (getNetworkType(currency) === "mainnet") {
-    return {
-      serialized: "",
-      json: null,
-      hash: "",
-    };
-  }
+  const fixedPointAmount = BigInt(amount) * BigInt(10) ** BigInt(38);
+
   const { data } = await gatewayNetwork<PrepareTapResponse, { amount: string; type: string }>({
     method: "POST",
     url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/prepare`,
     data: {
-      amount: amount.toString(),
+      amount: fixedPointAmount.toString(),
       type: TransactionType.TAP_REQUEST,
     },
   });
@@ -505,6 +507,7 @@ export async function prepareTransferRequest(
     url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/prepare`,
     data: params,
   });
+
   return data;
 }