@c7-digital/ledger 0.0.2

package/lib-lite/scripts/generate-asyncapi-types.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+/**
+ * Generate TypeScript types from AsyncAPI specification by converting to OpenAPI format
+ *
+ * This script converts the AsyncAPI YAML to OpenAPI format and uses the existing
+ * openapi-typescript generator to create types. Much simpler than custom schema parsing.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "yaml";
+import { exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+const __dirname = process.cwd();
+async function generateAsyncApiTypes(specPath) {
+    try {
+        // Get spec path from parameter or command line argument
+        const asyncApiSpecPath = specPath || process.argv[2];
+        if (!asyncApiSpecPath) {
+            console.error("Usage: node generate-asyncapi-types.ts <path-to-asyncapi-spec>");
+            process.exit(1);
+        }
+        // Read the AsyncAPI specification
+        const asyncApiPath = path.resolve(asyncApiSpecPath);
+        const asyncApiContent = fs.readFileSync(asyncApiPath, "utf8");
+        const asyncApiSpec = yaml.parse(asyncApiContent);
+        // Convert AsyncAPI to OpenAPI format by changing the header
+        const openApiSpec = {
+            ...asyncApiSpec,
+            openapi: "3.0.3",
+            info: asyncApiSpec.info,
+            components: asyncApiSpec.components,
+            // Remove AsyncAPI-specific fields
+            asyncapi: undefined,
+            channels: undefined,
+            operations: undefined,
+            // Add empty paths since OpenAPI requires it
+            paths: {},
+        };
+        // Clean up undefined properties
+        delete openApiSpec.asyncapi;
+        delete openApiSpec.channels;
+        delete openApiSpec.operations;
+        // Create temporary OpenAPI file
+        const tempOpenApiPath = path.join(__dirname, "temp-asyncapi-as-openapi.yaml");
+        fs.writeFileSync(tempOpenApiPath, yaml.stringify(openApiSpec));
+        console.log(`📝 Created temporary OpenAPI file: ${tempOpenApiPath}`);
+        console.log(`🔄 Generating types using openapi-typescript...`);
+        // Use the existing openapi-typescript generator
+        const outputPath = path.join(__dirname, "src", "generated", "async-api.ts");
+        const generateCommand = `pnpm exec openapi-typescript "${tempOpenApiPath}" --output "${outputPath}"`;
+        const { stdout, stderr } = await execAsync(generateCommand);
+        if (stderr && !stderr.includes("Warning")) {
+            console.warn("openapi-typescript warnings:", stderr);
+        }
+        if (stdout) {
+            console.log("openapi-typescript output:", stdout);
+        }
+        // Now add channels interface for WebSocket connections
+        console.log(`🔄 Adding channels interface for WebSocket connections...`);
+        // Parse the original AsyncAPI spec to extract channels
+        let channelsInterface = "\nexport interface channels {\n";
+        if (asyncApiSpec.channels) {
+            for (const [channelPath, channelData] of Object.entries(asyncApiSpec.channels)) {
+                const channel = channelData;
+                channelsInterface += `  "${channelPath}": {\n`;
+                // Add description if available
+                if (channel.description) {
+                    channelsInterface += `    /** @description ${channel.description} */\n`;
+                }
+                // Add operations (publish/subscribe)
+                if (channel.publish) {
+                    channelsInterface += `    publish: {\n`;
+                    if (channel.publish.description) {
+                        channelsInterface += `      /** @description ${channel.publish.description} */\n`;
+                    }
+                    if (channel.publish.message) {
+                        const messageRef = channel.publish.message.$ref || channel.publish.message;
+                        const messageName = typeof messageRef === "string" && messageRef.includes("#/")
+                            ? messageRef.replace("#/components/messages/", "")
+                            : messageRef;
+                        channelsInterface += `      message: components["schemas"]["${messageName}"];\n`;
+                    }
+                    channelsInterface += `    };\n`;
+                }
+                if (channel.subscribe) {
+                    channelsInterface += `    subscribe: {\n`;
+                    if (channel.subscribe.description) {
+                        channelsInterface += `      /** @description ${channel.subscribe.description} */\n`;
+                    }
+                    if (channel.subscribe.message) {
+                        const messageRef = channel.subscribe.message.$ref || channel.subscribe.message;
+                        const messageName = typeof messageRef === "string" && messageRef.includes("#/")
+                            ? messageRef.replace("#/components/messages/", "")
+                            : messageRef;
+                        channelsInterface += `      message: components["schemas"]["${messageName}"];\n`;
+                    }
+                    channelsInterface += `    };\n`;
+                }
+                channelsInterface += `  };\n`;
+            }
+        }
+        channelsInterface += "}\n";
+        // Append channels interface to the generated file
+        const generatedContent = fs.readFileSync(outputPath, "utf8");
+        const brandedContent = generatedContent + channelsInterface;
+        fs.writeFileSync(outputPath, brandedContent);
+        // Clean up temporary file
+        fs.unlinkSync(tempOpenApiPath);
+        console.log(`🧹 Cleaned up temporary file`);
+        console.log(`✅ Generated AsyncAPI types with channels interface: ${outputPath}`);
+    }
+    catch (error) {
+        console.error("❌ Error generating AsyncAPI types:", error.message);
+        // Clean up temporary file on error
+        const tempOpenApiPath = path.join(__dirname, "temp-asyncapi-as-openapi.yaml");
+        if (fs.existsSync(tempOpenApiPath)) {
+            fs.unlinkSync(tempOpenApiPath);
+            console.log(`🧹 Cleaned up temporary file after error`);
+        }
+        process.exit(1);
+    }
+}
+// Export the function for use in other scripts
+export { generateAsyncApiTypes };
+// Only run directly if this file is executed as main module
+if (import.meta.url === `file://${process.argv[1]}`) {
+    generateAsyncApiTypes();
+}

package/lib-lite/scripts/generate-schema-modules.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env tsx
+declare function generateSchemaModule(yamlPath: string, outputPath: string, exportName: string): void;
+export { generateSchemaModule };

package/lib-lite/scripts/generate-schema-modules.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env tsx
+import { readFileSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+function generateSchemaModule(yamlPath, outputPath, exportName) {
+    const yamlContent = readFileSync(yamlPath, "utf-8");
+    // Escape the YAML content for TypeScript string literal
+    const escapedContent = yamlContent
+        .replace(/\\/g, "\\\\")
+        .replace(/`/g, "\\`")
+        .replace(/\$\{/g, "\\${");
+    const tsContent = `// Auto-generated file - do not edit manually
+// Generated from ${yamlPath}
+
+export const ${exportName} = \`${escapedContent}\`;
+`;
+    writeFileSync(outputPath, tsContent, "utf-8");
+    console.log(`✅ Generated ${outputPath} from ${yamlPath}`);
+}
+// Export the function for use in other scripts
+export { generateSchemaModule };
+// Only run directly if this file is executed as main module
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const projectRoot = join(__dirname, "..");
+    const specsDir = join(projectRoot, "specs");
+    const outputDir = join(projectRoot, "src", "generated");
+    // Generate modules for both schemas
+    generateSchemaModule(join(specsDir, "openapi_2025-08-31.yaml"), join(outputDir, "openapi-schema.ts"), "OPENAPI_SCHEMA");
+    generateSchemaModule(join(specsDir, "asyncapi_2025-08-31.yaml"), join(outputDir, "asyncapi-schema.ts"), "ASYNCAPI_SCHEMA");
+    console.log("🎉 All schema modules generated successfully!");
+}

package/lib-lite/src/TemplateEmitterMap.d.ts

@@ -0,0 +1,40 @@
+import { EventEmitter } from "eventemitter3";
+import { PackageIdString } from "./valueTypes.js";
+/**
+ * A specialized Map wrapper for template emitters that uses partiallyQualified
+ * template IDs for comparison to ensure consistent lookup regardless of package ID.
+ */
+export declare class TemplateEmitterMap {
+    private emitters;
+    /**
+     * Set an EventEmitter for a specific template ID
+     * @param templateId The full template ID
+     * @param emitter The EventEmitter instance
+     */
+    set(templateId: PackageIdString, emitter: EventEmitter): void;
+    /**
+     * Get the EventEmitter for a specific template ID
+     * @param templateId The template ID (full or partial)
+     * @returns The EventEmitter or undefined if not found
+     */
+    get(templateId: PackageIdString): EventEmitter | undefined;
+    /**
+     * Check if an emitter exists for a specific template ID
+     * @param templateId The template ID (full or partial)
+     * @returns True if an emitter exists, false otherwise
+     */
+    has(templateId: PackageIdString): boolean;
+    /**
+     * Get all emitters in the map
+     * @returns An iterator of all EventEmitter instances
+     */
+    values(): IterableIterator<EventEmitter>;
+    /**
+     * Clear all emitters from the map
+     */
+    clear(): void;
+    /**
+     * Get the number of emitters in the map
+     */
+    get size(): number;
+}

package/lib-lite/src/TemplateEmitterMap.js

@@ -0,0 +1,57 @@
+import { partiallyQualified } from "./util.js";
+/**
+ * A specialized Map wrapper for template emitters that uses partiallyQualified
+ * template IDs for comparison to ensure consistent lookup regardless of package ID.
+ */
+export class TemplateEmitterMap {
+    constructor() {
+        this.emitters = new Map();
+    }
+    /**
+     * Set an EventEmitter for a specific template ID
+     * @param templateId The full template ID
+     * @param emitter The EventEmitter instance
+     */
+    set(templateId, emitter) {
+        const partialId = partiallyQualified(templateId);
+        this.emitters.set(partialId, { fullId: templateId, emitter });
+    }
+    /**
+     * Get the EventEmitter for a specific template ID
+     * @param templateId The template ID (full or partial)
+     * @returns The EventEmitter or undefined if not found
+     */
+    get(templateId) {
+        const partialId = partiallyQualified(templateId);
+        return this.emitters.get(partialId)?.emitter;
+    }
+    /**
+     * Check if an emitter exists for a specific template ID
+     * @param templateId The template ID (full or partial)
+     * @returns True if an emitter exists, false otherwise
+     */
+    has(templateId) {
+        const partialId = partiallyQualified(templateId);
+        return this.emitters.has(partialId);
+    }
+    /**
+     * Get all emitters in the map
+     * @returns An iterator of all EventEmitter instances
+     */
+    values() {
+        return Array.from(this.emitters.values())
+            .map(entry => entry.emitter)[Symbol.iterator]();
+    }
+    /**
+     * Clear all emitters from the map
+     */
+    clear() {
+        this.emitters.clear();
+    }
+    /**
+     * Get the number of emitters in the map
+     */
+    get size() {
+        return this.emitters.size;
+    }
+}

package/lib-lite/src/client.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Low-level HTTP client for Canton's OpenAPI v2 JSON API
+ *
+ * This client provides direct, type-safe access to the raw OpenAPI endpoints
+ * with minimal abstraction. It handles authentication and request/response
+ * serialization but preserves the original API structure and data types.
+ *
+ * Use this when you need full control over the API calls or access to
+ * endpoints not covered by the higher-level Ledger abstraction.
+ */
+import { operations } from "./generated/api.js";
+import { ValidationMode } from "./validation.js";
+type SubmitAndWaitOperation = operations["postV2CommandsSubmit-and-wait"];
+type SubmitAndWaitRequest = SubmitAndWaitOperation["requestBody"]["content"]["application/json"];
+type SubmitAndWaitResponse = SubmitAndWaitOperation["responses"]["200"]["content"]["application/json"];
+type SubmitAndWaitForTransactionOperation = operations["postV2CommandsSubmit-and-wait-for-transaction"];
+type SubmitAndWaitForTransactionRequest = SubmitAndWaitForTransactionOperation["requestBody"]["content"]["application/json"];
+type SubmitAndWaitForTransactionResponse = SubmitAndWaitForTransactionOperation["responses"]["200"]["content"]["application/json"];
+type GetPartiesOperation = operations["getV2Parties"];
+type GetPartiesResponse = GetPartiesOperation["responses"]["200"]["content"]["application/json"];
+type GetUserOperation = operations["getV2UsersUser-id"];
+type GetUserResponse = GetUserOperation["responses"]["200"]["content"]["application/json"];
+type GetUserRightsOperation = operations["getV2UsersUser-idRights"];
+type GetUserRightsResponse = GetUserRightsOperation["responses"]["200"]["content"]["application/json"];
+type QueryActiveContractsOperation = operations["postV2StateActive-contracts"];
+type QueryActiveContractsRequest = QueryActiveContractsOperation["requestBody"]["content"]["application/json"];
+type QueryActiveContractsResponse = QueryActiveContractsOperation["responses"]["200"]["content"]["application/json"];
+type AllocatePartyOperation = operations["postV2Parties"];
+type AllocatePartyRequest = AllocatePartyOperation["requestBody"]["content"]["application/json"];
+type AllocatePartyResponse = AllocatePartyOperation["responses"]["200"]["content"]["application/json"];
+type GetLedgerEndOperation = operations["getV2StateLedger-end"];
+type GetLedgerEndResponse = GetLedgerEndOperation["responses"]["200"]["content"]["application/json"];
+export type transaction_shape = "TRANSACTION_SHAPE_ACS_DELTA" | "TRANSACTION_SHAPE_LEDGER_EFFECTS";
+export interface TypedHttpClientConfig {
+    token: string;
+    baseUrl: string;
+    validation?: ValidationMode;
+    openApiSchemaPath?: string;
+}
+export declare class TypedHttpClient {
+    readonly token: string;
+    readonly baseUrl: string;
+    private validator?;
+    constructor(config: TypedHttpClientConfig);
+    private request;
+    submitAndWait(commands: SubmitAndWaitRequest): Promise<SubmitAndWaitResponse>;
+    submitAndWaitForTransaction(commands: SubmitAndWaitForTransactionRequest): Promise<SubmitAndWaitForTransactionResponse>;
+    getParties(): Promise<GetPartiesResponse>;
+    getUserInfo(userId: string): Promise<GetUserResponse>;
+    getUserRights(userId: string): Promise<GetUserRightsResponse>;
+    queryActiveContracts(queryRequest: QueryActiveContractsRequest): Promise<QueryActiveContractsResponse>;
+    allocateParty(request: AllocatePartyRequest): Promise<AllocatePartyResponse>;
+    getLedgerEnd(): Promise<GetLedgerEndResponse>;
+}
+export {};

package/lib-lite/src/client.js

@@ -0,0 +1,62 @@
+import { SchemaValidator } from "./validation.js";
+import fetch from "cross-fetch";
+export class TypedHttpClient {
+    constructor(config) {
+        this.token = config.token;
+        this.baseUrl = config.baseUrl;
+        this.validator = config.validation
+            ? new SchemaValidator("openapi", config.validation)
+            : undefined;
+    }
+    async request(path, method, body, responseSchemaName, isArrayResponse) {
+        const url = `${this.baseUrl}${path}`;
+        const requestInit = {
+            method,
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+                "Content-Type": "application/json",
+            },
+        };
+        if (body) {
+            requestInit.body = JSON.stringify(body);
+        }
+        const response = await fetch(url, requestInit);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const parsed = await response.json();
+        if (this.validator && responseSchemaName) {
+            if (isArrayResponse) {
+                return this.validator.validateArraySchema(parsed, responseSchemaName);
+            }
+            else {
+                return this.validator.validateSchema(parsed, responseSchemaName);
+            }
+        }
+        return parsed;
+    }
+    async submitAndWait(commands) {
+        return this.request("/v2/commands/submit-and-wait", "POST", commands, "#/components/schemas/SubmitAndWaitResponse");
+    }
+    async submitAndWaitForTransaction(commands) {
+        return this.request("/v2/commands/submit-and-wait-for-transaction", "POST", commands, "#/components/schemas/JsSubmitAndWaitForTransactionResponse");
+    }
+    async getParties() {
+        return this.request("/v2/parties", "GET", undefined, "#/components/schemas/GetPartiesResponse");
+    }
+    async getUserInfo(userId) {
+        return this.request(`/v2/users/${userId}`, "GET", undefined, "#/components/schemas/GetUserResponse");
+    }
+    async getUserRights(userId) {
+        return this.request(`/v2/users/${userId}/rights`, "GET", undefined, "#/components/schemas/ListUserRightsResponse");
+    }
+    async queryActiveContracts(queryRequest) {
+        return this.request("/v2/state/active-contracts", "POST", queryRequest, "#/components/schemas/JsGetActiveContractsResponse", true);
+    }
+    async allocateParty(request) {
+        return this.request("/v2/parties", "POST", request, "#/components/schemas/AllocatePartyResponse");
+    }
+    async getLedgerEnd() {
+        return this.request("/v2/state/ledger-end", "GET", undefined, "#/components/schemas/GetLedgerEndResponse");
+    }
+}