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

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

@@ -0,0 +1,317 @@
+import { OnboardingPrepareResponse, PrepareTransferResponse } from "../../network/gateway";
+import { CantonPreparedTransaction, CantonSigner } 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 | { transactions: string[] },
+  ) {
+    if ("transactions" in data) {
+      return `untyped-signature-${data.transactions.length}`;
+    } else {
+      return `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).toBe("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).toBe("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("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", async () => {
+    // GIVEN
+    const mockSignerSpy = jest.fn().mockResolvedValue("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",
+      ],
+    });
+  });
+});

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

@@ -0,0 +1,33 @@
+import { OnboardingPrepareResponse, PrepareTransferResponse } from "../../network/gateway";
+import { PrepareTransactionResponse } from "../../types/onboard";
+import { CantonSigner } 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;
+
+  if ("json" in transactionData) {
+    const components = splitTransaction(transactionData.json);
+    signature = await signer.signTransaction(derivationPath, components);
+  } else {
+    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 });
+  }
+
+  if (!signature || signature.length === 0) {
+    throw new Error("Device returned empty signature");
+  }
+
+  return signature;
+}

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

@@ -107,6 +107,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);

package/src/network/gateway.ts

@@ -283,7 +283,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");
@@ -448,13 +449,6 @@ export async function prepareTapRequest(
   currency: CryptoCurrency,
   { partyId, amount = 1000000 }: PrepareTapRequest,
 ) {
-  if (getNetworkType(currency) === "mainnet") {
-    return {
-      serialized: "",
-      json: null,
-      hash: "",
-    };
-  }
   const { data } = await gatewayNetwork<PrepareTapResponse, { amount: string; type: string }>({
     method: "POST",
     url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/prepare`,
@@ -505,6 +499,7 @@ export async function prepareTransferRequest(
     url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/prepare`,
     data: params,
   });
+
   return data;
 }