@c7-digital/ledger 0.0.2

package/lib/scripts/enhance-types.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+// Script to automatically brand OpenAPI generated types with value.proto constraints
+// Ideally the spec would provide this, but this is sufficient for now.
+import { readFileSync, writeFileSync } from "fs";
+// Patterns to find fields with value.proto references based on JSDoc comments
+// Each entry automatically handles both string and string[] cases
+const VALUE_PROTO_PATTERNS = [
+    // LedgerString patterns
+    {
+        commentPattern: "Must be a valid LedgerString",
+        targetType: "LedgerString",
+    },
+    // PartyIdString patterns
+    {
+        commentPattern: "Must be a valid PartyIdString",
+        targetType: "PartyIdString",
+    },
+    // UserIdString patterns
+    {
+        commentPattern: "Must be a valid UserIdString",
+        targetType: "UserIdString",
+    },
+    // NameString patterns
+    {
+        commentPattern: "Must be a valid NameString",
+        targetType: "NameString",
+    },
+    // PackageIdString patterns
+    {
+        commentPattern: "Must be a valid PackageIdString",
+        targetType: "PackageIdString",
+    },
+    {
+        commentPattern: "The identifier uses the package-id reference format",
+        targetType: "PackageIdString",
+    },
+];
+function brandApiTypes(inputPath, outputPath, label) {
+    console.log(`🔄 Branding ${label} types with value.proto constraints...`);
+    const content = readFileSync(inputPath, "utf-8");
+    let brandedContent = content;
+    // Add imports at the top if not already present
+    if (!content.includes('from "../valueTypes.js"')) {
+        const importStatement = `import { LedgerString, PartyIdString, UserIdString, NameString, PackageIdString } from "../valueTypes.js";\n\n`;
+        brandedContent = importStatement + brandedContent;
+    }
+    let replacementCount = 0;
+    // Track usage of each comment pattern
+    const patternUsage = new Map();
+    // This regex captures JSDoc comments followed by field declarations
+    // We're looking for: /** JSDoc comment */ fieldName?: fieldType;
+    // 
+    // Regex breakdown:
+    // /\/\*\*                           - Match opening /** (literal forward slash, asterisk, asterisk)
+    // ([^*]|[\r\n]|(\*+([^*/]|[\r\n])))* - Match JSDoc content (non-greedy):
+    //   [^*]                            - Any character except asterisk
+    //   |[\r\n]                         - OR newline characters (carriage return or line feed)
+    //   |(\*+([^*/]|[\r\n]))            - OR one or more asterisks followed by non-closing chars
+    // \*+\/                             - Match closing */ (one or more asterisks + forward slash)
+    // \s*                               - Match optional whitespace after JSDoc
+    // (\w+)                             - Capture group 4: field name (word characters)
+    // (\?)?                             - Capture group 5: optional question mark for optional fields
+    // \s*:\s*                           - Match colon with optional whitespace around it
+    // ([^;,\}\n]+)                      - Capture group 6: field type (everything except semicolon, comma, closing brace, newline)
+    //
+    // The regex handles multi-line JSDoc with @description tags and indented fields within object types
+    const fieldRegex = /\/\*\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+\/\s*(\w+)(\?)?\s*:\s*([^;,\}\n]+)/g;
+    // Use a more compatible approach for regex matching
+    const matches = [];
+    let match;
+    while ((match = fieldRegex.exec(content)) !== null) {
+        matches.push(match);
+    }
+    // Process each match
+    for (const match of matches) {
+        if (match.length < 6)
+            continue;
+        const fullMatch = match[0];
+        const jsDocComment = match[0].substring(3, match[0].indexOf("*/")); // Extract JSDoc content
+        const fieldName = match[4]; // Field name
+        const isOptional = match[5] === "?"; // Optional marker
+        const fieldType = match[6]; // Field type (could be anything)
+        // Skip if we don't have the necessary data
+        if (!fullMatch || !fieldName || !fieldType)
+            continue;
+        // Check if this is a string-related type that we care about
+        const trimmedFieldType = fieldType.trim();
+        if (trimmedFieldType === "string" || trimmedFieldType === "string[]") {
+            // Check if the JSDoc comment matches any of our patterns
+            for (const { commentPattern, targetType } of VALUE_PROTO_PATTERNS) {
+                // Check if JSDoc contains the pattern
+                if (jsDocComment.includes(commentPattern)) {
+                    // Extra validation: ensure this is actually a value.proto constraint comment
+                    if (commentPattern.includes("Must be a valid") ||
+                        commentPattern.includes("package-id reference format")) {
+                        // Determine the correct target type based on whether it's an array
+                        const finalTargetType = trimmedFieldType === "string[]" ? `${targetType}[]` : targetType;
+                        // Create the branded declaration
+                        const brandedDeclaration = fullMatch.replace(trimmedFieldType, finalTargetType);
+                        // Replace in the content
+                        brandedContent = brandedContent.replace(fullMatch, brandedDeclaration);
+                        replacementCount++;
+                        // Track pattern usage
+                        const fieldExample = `${fieldName}${isOptional ? "?" : ""}: ${trimmedFieldType} → ${finalTargetType}`;
+                        if (!patternUsage.has(commentPattern)) {
+                            patternUsage.set(commentPattern, { count: 0, examples: [] });
+                        }
+                        const usage = patternUsage.get(commentPattern);
+                        usage.count++;
+                        if (usage.examples.length < 3) {
+                            // Keep up to 3 examples per pattern
+                            usage.examples.push(fieldExample);
+                        }
+                        // Log the branding with field name
+                        const optionalMarker = isOptional ? "?" : "";
+                        console.log(`✅ Branded ${fieldName}${optionalMarker}: ${trimmedFieldType} → ${finalTargetType}`);
+                        // console.log(`JSDoc: ${jsDocComment}`);
+                        // console.log(`Pattern: ${commentPattern}`);
+                        // console.log(`---------------------------------`);
+                        break; // Stop checking patterns once we've found a match
+                    }
+                }
+            }
+        }
+    }
+    // Write branded content directly to the output file
+    console.log(`📝 Writing branded types to ${outputPath}...`);
+    writeFileSync(outputPath, brandedContent);
+    console.log(`🎉 Branded ${replacementCount} field declarations with value.proto constraints`);
+    // Report pattern usage summary
+    if (patternUsage.size > 0) {
+        console.log(`\n📊 Pattern Usage Summary:`);
+        console.log(`════════════════════════════════════════`);
+        // Sort patterns by usage count (descending)
+        const sortedPatterns = Array.from(patternUsage.entries()).sort(([, a], [, b]) => b.count - a.count);
+        for (const [pattern, { count, examples }] of sortedPatterns) {
+            console.log(`\n🔖 "${pattern}"`);
+            console.log(`   Used ${count} time${count === 1 ? "" : "s"}`);
+            console.log(`   Examples:`);
+            for (const example of examples) {
+                console.log(`     • ${example}`);
+            }
+            if (count > examples.length) {
+                console.log(`     ... and ${count - examples.length} more`);
+            }
+        }
+        console.log(`\n════════════════════════════════════════`);
+    }
+    return replacementCount;
+}
+function brandTypes(inputPath, outputPath, label = "API") {
+    brandApiTypes(inputPath, outputPath, label);
+}
+// Export the function for use in other scripts
+export { brandTypes };
+// Check if this script is being run directly
+// For ES modules, we check if the import.meta.url matches the process.argv[1]
+const isMainModule = process.argv[1] &&
+    (process.argv[1].endsWith("brand-types.ts") || process.argv[1].endsWith("enhance-types.ts"));
+if (isMainModule) {
+    const args = process.argv.slice(2);
+    if (args.length < 2) {
+        console.error("Usage: brand-types.ts <input-file> <output-file> [label]");
+        process.exit(1);
+    }
+    if (!args[0] || !args[1]) {
+        console.error("Input and output files must be specified.");
+        process.exit(1);
+    }
+    const inputPath = args[0];
+    const outputPath = args[1];
+    const label = args[2] || "API";
+    brandTypes(inputPath, outputPath, label);
+}

package/lib/scripts/generate-asyncapi-types.d.ts

@@ -0,0 +1,9 @@
+#!/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.
+ */
+declare function generateAsyncApiTypes(specPath?: string): Promise<void>;
+export { generateAsyncApiTypes };

package/lib/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/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/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/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/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/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/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");
+    }
+}