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

package/src/network/gateway.ts

@@ -1,11 +1,37 @@
 import network from "@ledgerhq/live-network";
+import type { LiveNetworkRequest } from "@ledgerhq/live-network/network";
+import { getEnv } from "@ledgerhq/live-env";
 import coinConfig from "../config";
+import {
+  PrepareTransactionRequest,
+  PrepareTransactionResponse,
+  SubmitTransactionRequest,
+  SubmitTransactionResponse,
+  PreApprovalResult,
+} from "../types/onboard";
 
 type OnboardingPrepareResponse = {
   party_id: string;
   party_name: string;
   public_key_fingerprint: string;
-  topology_transactions_hash: string;
+  transactions: {
+    namespace_transaction: {
+      serialized: string;
+      json: object;
+      hash: string;
+    };
+    party_to_key_transaction: {
+      serialized: string;
+      json: object;
+      hash: string;
+    };
+    party_to_participant_transaction: {
+      serialized: string;
+      json: object;
+      hash: string;
+    };
+    combined_hash: string;
+  };
 };
 
 type OnboardingPrepareRequest = {
@@ -13,6 +39,31 @@ type OnboardingPrepareRequest = {
   public_key_type: string;
 };
 
+export type PrepareTransferResponse = {
+  hash: string;
+  json: any; // The actual structure is complex, using any for now
+  serialized: string;
+};
+
+export type PrepareTransferRequest = {
+  type: "token-transfer-request";
+  amount: number;
+  recipient: string;
+  execute_before_secs: number;
+  instrument_id: string;
+  reason?: string;
+};
+
+export type PrepareTapRequest = {
+  type: "tap-request";
+  amount: number;
+};
+
+export type PreparePreapprovalRequest = {
+  type: "transfer-pre-approval-proposal";
+  receiver: string;
+};
+
 type OnboardingSubmitRequest = {
   prepare_request: OnboardingPrepareRequest;
   prepare_response: OnboardingPrepareResponse;
@@ -63,6 +114,9 @@ export type CreatedEvent = BaseEvent & {
   };
   signatories: string[];
   observers: string[];
+  details: {
+    createArguments: { fields: unknown[] };
+  };
 };
 
 type ExercisedEvent = BaseEvent & {
@@ -90,21 +144,165 @@ export type TxInfo = {
   trace_context: string;
 };
 
+export type OperationInfo =
+  | {
+      uid: string;
+      transaction_hash: string;
+      transaction_timestamp: string;
+      status: "Success";
+      type: "Initialize";
+      senders: string[];
+      recipients: string[];
+      transfers: [
+        {
+          address: string;
+          type: "Initialize";
+          value: string;
+          asset: string;
+          details: {
+            type: "pre-approval";
+          };
+        },
+      ];
+      block: {
+        height: number;
+        time: string;
+        hash: string;
+      };
+      fee: {
+        value: string;
+        asset: {
+          type: "native";
+          issuer: null;
+        };
+        details: {
+          type: string;
+        };
+      };
+      asset: {
+        type: "token";
+        issuer: string;
+      };
+      details: {
+        type: "pre-approval";
+      };
+    }
+  | {
+      uid: string;
+      transaction_hash: string;
+      transaction_timestamp: string;
+      status: "Success";
+      type: "Receive";
+      senders: string[];
+      recipients: string[];
+      transfers: [
+        {
+          address: string;
+          type: "Receive";
+          value: string;
+          asset: string;
+          details: {
+            type: "tap";
+          };
+        },
+      ];
+      block: {
+        height: number;
+        time: string;
+        hash: string;
+      };
+      fee: {
+        value: string;
+        asset: {
+          type: "native";
+          issuer: null;
+        };
+        details: {
+          type: string;
+        };
+      };
+      asset: {
+        type: "native";
+        issuer: null;
+      };
+      details: {
+        type: "tap";
+      };
+    }
+  | {
+      uid: string;
+      transaction_hash: string;
+      transaction_timestamp: string;
+      status: "Success";
+      type: "Send";
+      senders: string[];
+      recipients: string[];
+      transfers: [
+        {
+          address: string;
+          type: "Send";
+          value: string;
+          asset: string;
+          details: {
+            type: "transfer";
+          };
+        },
+      ];
+      block: {
+        height: number;
+        time: string;
+        hash: string;
+      };
+      fee: {
+        value: string;
+        asset: {
+          type: "native";
+          issuer: null;
+        };
+        details: {
+          type: string;
+        };
+      };
+      asset: {
+        type: "native";
+        issuer: null;
+      };
+      details: {
+        type: "transfer";
+      };
+    };
+
 const getGatewayUrl = () => coinConfig.getCoinConfig().gatewayUrl;
-const getNodeId = () => coinConfig.getCoinConfig().nodeId || "ledger-live-devnet-prd";
+const getNodeId = () => coinConfig.getCoinConfig().nodeId || "ledger-devnet-stg";
+
+const gatewayNetwork = <T, U = unknown>(req: LiveNetworkRequest<U>) => {
+  const API_KEY = getEnv("CANTON_API_KEY");
+  return network<T, U>({
+    ...req,
+    headers: {
+      ...(req.headers || {}),
+      ...(API_KEY && { "X-Ledger-Canton-Api-Key": API_KEY }),
+    },
+  });
+};
 
 export async function prepareOnboarding(
   pubKey: string,
   pubKeyType: string,
 ): Promise<OnboardingPrepareResponse> {
-  const { data } = await network<OnboardingPrepareResponse>({
+  const gatewayUrl = getGatewayUrl();
+  const nodeId = getNodeId();
+  const fullUrl = `${gatewayUrl}/v1/node/${nodeId}/onboarding/prepare`;
+
+  const { data } = await gatewayNetwork<OnboardingPrepareResponse, OnboardingPrepareRequest>({
     method: "POST",
-    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/onboarding/prepare`,
+    url: fullUrl,
     data: {
       public_key: pubKey,
       public_key_type: pubKeyType,
-    } satisfies OnboardingPrepareRequest,
+    },
   });
+
   return data;
 }
 
@@ -113,58 +311,56 @@ export async function submitOnboarding(
   prepareResponse: OnboardingPrepareResponse,
   signature: string,
 ) {
-  const { data } = await network<OnboardingSubmitResponse>({
+  const { data } = await gatewayNetwork<OnboardingSubmitResponse, OnboardingSubmitRequest>({
     method: "POST",
     url: `${getGatewayUrl()}/v1/node/${getNodeId()}/onboarding/submit`,
     data: {
       prepare_request: prepareRequest,
       prepare_response: prepareResponse,
       signature,
-    } satisfies OnboardingSubmitRequest,
+    },
   });
   return data;
 }
 
 export async function submit(serializedTx: string, signature: string) {
-  const { data } = await network<TransactionSubmitResponse>({
+  const { data } = await gatewayNetwork<TransactionSubmitResponse, TransactionSubmitRequest>({
     method: "POST",
     url: `${getGatewayUrl()}/v1/node/${getNodeId()}/transaction/submit`,
     data: {
       serialized: serializedTx,
       signature,
-    } satisfies TransactionSubmitRequest,
+    },
   });
   return data;
 }
 
 export async function getBalance(partyId: string): Promise<InstrumentBalance[]> {
-  const { data } = await network<InstrumentBalance[]>({
+  const { data } = await gatewayNetwork<InstrumentBalance[]>({
     method: "GET",
-    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/balance`,
+    // TODO: we need better solution ?
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId.replace(/_/g, ":")}/balance`,
   });
   return data;
 }
 
 export async function getPartyById(partyId: string): Promise<PartyInfo> {
-  return await getParty(partyId, "ID");
+  return await getParty(partyId, "party-id");
 }
 
 export async function getPartyByPubKey(pubKey: string): Promise<PartyInfo> {
-  return await getParty(pubKey, "PK");
+  return await getParty(pubKey, "public-key");
 }
 
-async function getParty(identifier: string, by: "ID" | "PK"): Promise<PartyInfo> {
-  const { data } = await network<PartyInfo>({
+async function getParty(identifier: string, by: "party-id" | "public-key"): Promise<PartyInfo> {
+  const { data } = await gatewayNetwork<PartyInfo>({
     method: "GET",
-    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${identifier}`,
-    data: {
-      by,
-    },
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${identifier}?by=${by}`,
   });
   return data;
 }
 
-export async function getTransactions(
+export async function getOperations(
   partyId: string,
   options?: {
     cursor?: number | undefined;
@@ -174,23 +370,134 @@ export async function getTransactions(
   },
 ): Promise<{
   next: number;
-  transactions: TxInfo[];
+  operations: OperationInfo[];
 }> {
-  const { data } = await network<{
+  const { data } = await gatewayNetwork<{
     next: number;
-    transactions: TxInfo[];
+    operations: OperationInfo[];
   }>({
     method: "GET",
-    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transactions`,
-    data: options,
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId.replace(/_/g, ":")}/operations`,
+    params: options,
+  });
+  return data;
+}
+
+type PrepareTapRequestRequest = {
+  partyId: string;
+  amount?: number;
+};
+
+type PrepareTapRequestResponse = {
+  serialized: "string";
+  json: null;
+  hash: "string";
+};
+
+enum TransactionType {
+  TAP_REQUEST = "tap-request",
+  TRANSFER_PRE_APPROVAL_PROPOSAL = "transfer-pre-approval-proposal",
+}
+
+export async function prepareTapRequest({
+  partyId,
+  amount = 1000000,
+}: PrepareTapRequestRequest): Promise<PrepareTapRequestResponse> {
+  const { data } = await gatewayNetwork<
+    PrepareTapRequestResponse,
+    { amount: number; type: string }
+  >({
+    method: "POST",
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transaction/prepare`,
+    data: {
+      amount: parseInt(amount.toString(), 10), // Convert to integer to avoid scientific notation
+      type: TransactionType.TAP_REQUEST,
+    },
+  });
+  return data;
+}
+
+type SubmitTapRequestRequest = {
+  partyId: string;
+  serialized: string;
+  signature: string;
+};
+
+type SubmitTapRequestResponse = {
+  submission_id: string;
+  update_id: string;
+};
+
+export async function submitTapRequest({
+  partyId,
+  serialized,
+  signature,
+}: SubmitTapRequestRequest): Promise<SubmitTapRequestResponse> {
+  const { data } = await gatewayNetwork<
+    SubmitTapRequestResponse,
+    Omit<SubmitTapRequestRequest, "partyId">
+  >({
+    method: "POST",
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transaction/submit`,
+    data: {
+      serialized,
+      signature,
+    },
+  });
+  return data;
+}
+
+export async function prepareTransferRequest(
+  partyId: string,
+  params: PrepareTransferRequest,
+): Promise<PrepareTransferResponse> {
+  const { data } = await network<PrepareTransferResponse>({
+    method: "POST",
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transaction/prepare`,
+    data: params,
   });
   return data;
 }
 
 export async function getLedgerEnd(): Promise<number> {
-  const { data } = await network<number>({
+  const { data } = await gatewayNetwork<number>({
     method: "GET",
     url: `${getGatewayUrl()}/v1/node/${getNodeId()}/ledger-end`,
   });
   return data;
 }
+
+export async function preparePreApprovalTransaction(
+  partyId: string,
+): Promise<PrepareTransactionResponse> {
+  const { data } = await gatewayNetwork<PrepareTransactionResponse, PrepareTransactionRequest>({
+    method: "POST",
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transaction/prepare`,
+    data: {
+      type: TransactionType.TRANSFER_PRE_APPROVAL_PROPOSAL,
+      receiver: partyId,
+    },
+  });
+  return data;
+}
+
+export async function submitPreApprovalTransaction(
+  partyId: string,
+  { serialized }: PrepareTransactionResponse,
+  signature: string,
+): Promise<PreApprovalResult> {
+  const { data } = await gatewayNetwork<SubmitTransactionResponse, SubmitTransactionRequest>({
+    method: "POST",
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transaction/submit`,
+    data: {
+      serialized,
+      signature,
+    },
+  });
+
+  return {
+    isApproved: true,
+    submissionId: data.submission_id,
+    updateId: data.update_id,
+  };
+}

package/src/network/node.ts

@@ -3,7 +3,7 @@ import network from "@ledgerhq/live-network";
 import type { LiveNetworkRequest } from "@ledgerhq/live-network/network";
 import { getEnv } from "@ledgerhq/live-env";
 import coinConfig from "../config";
-import { AccountInfoResponse, SubmitReponse } from "./types";
+import { AccountInfoResponse, SubmitResponse } from "./types";
 import crypto from "crypto";
 
 const getNodeUrl = () => coinConfig.getCoinConfig().nodeUrl || "";
@@ -86,10 +86,10 @@ export const getLedgerEnd = async (): Promise<number> => {
   return data.offset;
 };
 
-export const submit = async (signedTx: string): Promise<SubmitReponse> => {
+export const submit = async (signedTx: string): Promise<SubmitResponse> => {
   // @ts-expect-error: add NODE_BOILERPLATE to libs/env/src/env.ts
   const url = `${getEnv("NODE_BOILERPLATE")}/submit`;
-  const { data } = await network<SubmitReponse>({
+  const { data } = await network<SubmitResponse>({
     url,
     method: "GET",
   });

package/src/network/types.ts

@@ -40,7 +40,7 @@ export type AccountInfoResponse = {
   validated: boolean;
 } & ResponseStatus;
 
-export type SubmitReponse = {
+export type SubmitResponse = {
   accepted: boolean;
   tx_hash: string;
 };

package/src/signer/getAddress.ts

@@ -1,13 +1,11 @@
 import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
 import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
-import { CantonAddress, CantonSigner } from "../types";
+import { CantonSigner } from "../types";
 
 const getAddress = (signerContext: SignerContext<CantonSigner>): GetAddressFn => {
-  return async (deviceId: string, { path, verify }: GetAddressOptions) => {
-    const { address, publicKey } = (await signerContext(deviceId, signer =>
-      signer.getAddress(path),
-    )) as CantonAddress;
+  return async (deviceId: string, { path }: GetAddressOptions) => {
+    const { address, publicKey } = await signerContext(deviceId, signer => signer.getAddress(path));
 
     return {
       path,

package/src/test/cantonTestUtils.ts

@@ -0,0 +1,181 @@
+/**
+ * Canton Testing Utilities for Ed25519 Key Generation
+ *
+ * Provides utilities to generate proper Ed25519 keypairs for testing Canton
+ * onboarding without requiring physical Ledger devices.
+ */
+
+import crypto from "crypto";
+
+export interface CantonTestKeyPair {
+  publicKeyHex: string; // Ready for Canton Gateway API
+  privateKeyHex: string; // ASN.1 DER encoded private key in hex format
+  privateKeyPem: string; // PEM format for signing operations
+  fingerprint: string; // Canton public key fingerprint (multihash: 1220 + SHA256(publicKey))
+  sign: (hashHex: string) => string; // Sign transaction hash
+}
+
+/**
+ * Generate fresh Ed25519 keypair
+ */
+export function generateMockKeyPair(): CantonTestKeyPair {
+  const { publicKey, privateKey } = crypto.generateKeyPairSync("ed25519");
+
+  const publicKeyBuffer = publicKey.export({ type: "spki", format: "der" });
+  const rawPublicKey = publicKeyBuffer.slice(-32);
+  const publicKeyHex = rawPublicKey.toString("hex");
+
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  const privateKeyPem = privateKey.export({ type: "pkcs8", format: "pem" }) as string;
+  const privateKeyDer = privateKey.export({ type: "pkcs8", format: "der" });
+  const privateKeyHex = privateKeyDer.toString("hex");
+
+  // Generate fingerprint: Canton computes SHA256(purpose_bytes + public_key_bytes)
+  // where purpose_bytes is 4-byte big-endian representation of PURPOSE_PUBLIC_KEY_FINGERPRINT (12)
+  const PURPOSE_PUBLIC_KEY_FINGERPRINT = 12;
+  const purposeBytes = Buffer.allocUnsafe(4);
+  purposeBytes.writeInt32BE(PURPOSE_PUBLIC_KEY_FINGERPRINT, 0);
+
+  const hash = crypto.createHash("sha256");
+  hash.update(purposeBytes);
+  hash.update(rawPublicKey);
+  const hashedContent = hash.digest();
+
+  // Multihash encoding: 0x12 (SHA256) + 0x20 (32 bytes) + hash
+  const multihashPrefix = Buffer.from([0x12, 0x20]);
+  const fingerprintBuffer = Buffer.concat([multihashPrefix, hashedContent]);
+  const fingerprint = fingerprintBuffer.toString("hex");
+
+  return {
+    publicKeyHex, // 64-char hex string (no 0x prefix)
+    privateKeyHex, // ASN.1 DER encoded private key in hex format
+    privateKeyPem, // PEM format string
+    fingerprint, // Canton format: multihash prefix + SHA256(public key)
+
+    /**
+     * Sign a transaction hash using proper Ed25519 signature
+     */
+    sign: (hashHex: string): string => {
+      const hashBuffer = Buffer.from(hashHex, "hex");
+      const privateKeyObj = crypto.createPrivateKey({
+        key: privateKeyPem,
+        format: "pem",
+        type: "pkcs8",
+      });
+
+      const signature = crypto.sign(null, hashBuffer, privateKeyObj);
+      return signature.toString("hex");
+    },
+  };
+}
+
+/**
+ * Verify Ed25519 signature against public key and message hash
+ */
+export function verifySignature(
+  publicKeyHex: string,
+  signatureHex: string,
+  messageHashHex: string,
+): { isValid: boolean; error?: string; details: any } {
+  try {
+    // Clean inputs - remove 0x prefixes if present
+    const cleanPublicKey = publicKeyHex.startsWith("0x") ? publicKeyHex.slice(2) : publicKeyHex;
+    const cleanSignature = signatureHex.startsWith("0x") ? signatureHex.slice(2) : signatureHex;
+    const cleanMessageHash = messageHashHex.startsWith("0x")
+      ? messageHashHex.slice(2)
+      : messageHashHex;
+
+    const details: any = {
+      publicKeyLength: cleanPublicKey.length,
+      signatureLength: cleanSignature.length,
+      messageHashLength: cleanMessageHash.length,
+      publicKeyBytes: cleanPublicKey.length / 2,
+      signatureBytes: cleanSignature.length / 2,
+      messageHashBytes: cleanMessageHash.length / 2,
+    };
+
+    // Validate input lengths
+    if (cleanPublicKey.length !== 64) {
+      return {
+        isValid: false,
+        error: `Invalid public key length: expected 64 hex chars (32 bytes), got ${cleanPublicKey.length}`,
+        details,
+      };
+    }
+
+    // Ed25519 signatures should be 64 bytes, but we might receive 65 bytes with recovery ID
+    let processedSignature = cleanSignature;
+    if (cleanSignature.length === 130) {
+      processedSignature = cleanSignature.slice(2, -2);
+      details.originalSignatureLength = cleanSignature.length;
+      details.processedSignatureLength = processedSignature.length;
+    } else if (cleanSignature.length !== 128) {
+      return {
+        isValid: false,
+        error: `Invalid signature length: expected 128 hex chars (64 bytes) or 130 hex chars (65 bytes), got ${cleanSignature.length}`,
+        details,
+      };
+    }
+
+    // Convert hex to buffers
+    const publicKeyBuffer = Buffer.from(cleanPublicKey, "hex");
+    const signatureBuffer = Buffer.from(processedSignature, "hex");
+    const messageBuffer = Buffer.from(cleanMessageHash, "hex");
+
+    // Create public key object for verification
+    // Ed25519 public keys need to be wrapped in SPKI format for Node.js crypto
+    const spkiHeader = Buffer.from([
+      0x30,
+      0x2a, // SEQUENCE, length 42
+      0x30,
+      0x05, // SEQUENCE, length 5
+      0x06,
+      0x03,
+      0x2b,
+      0x65,
+      0x70, // OID for Ed25519
+      0x03,
+      0x21,
+      0x00, // BIT STRING, length 33, no unused bits
+    ]);
+    const spkiPublicKey = Buffer.concat([spkiHeader, publicKeyBuffer]);
+
+    const publicKeyObj = crypto.createPublicKey({
+      key: spkiPublicKey,
+      format: "der",
+      type: "spki",
+    });
+
+    // Verify signature
+    const isValid = crypto.verify(null, messageBuffer, publicKeyObj, signatureBuffer);
+
+    return {
+      isValid,
+      details: {
+        ...details,
+        processedSignatureLength: processedSignature.length,
+        verificationMethod: "Node.js crypto.verify with Ed25519",
+      },
+    };
+  } catch (error) {
+    return {
+      isValid: false,
+      error: `Verification failed: ${error instanceof Error ? error.message : String(error)}`,
+      details: { error: String(error) },
+    };
+  }
+}
+
+export function createMockSigner(keyPair: CantonTestKeyPair) {
+  return {
+    getAddress: async (derivationPath: string) => ({
+      address: `canton_test_${keyPair.fingerprint.slice(-8)}`,
+      publicKey: keyPair.publicKeyHex,
+    }),
+
+    signTransaction: async (derivationPath: string, hashToSign: string) => {
+      const cleanHash = hashToSign.startsWith("0x") ? hashToSign.slice(2) : hashToSign;
+      return keyPair.sign(cleanHash);
+    },
+  };
+}