@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

package/dist/cjs/query/pqs/pqs-sql-compiler.js

@@ -0,0 +1,367 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileContractFindMany = compileContractFindMany;
+exports.compileContractGroupBy = compileContractGroupBy;
+const model_types_js_1 = require("../model-types.js");
+const pqs_schema_profile_js_1 = require("./pqs-schema-profile.js");
+const pqs_schema_profile_js_2 = require("./pqs-schema-profile.js");
+function compileContractFindMany(args, profile) {
+    (0, model_types_js_1.assertQueryPageArgs)(args);
+    const values = [];
+    const addValue = (value) => {
+        values.push(value);
+        return `$${values.length}`;
+    };
+    const conditions = [];
+    const where = args.where === undefined ? undefined : compileWhere(args.where, addValue, profile);
+    if (where !== undefined)
+        conditions.push(where);
+    if (args.parties !== undefined) {
+        conditions.push(`contract_row.witnesses && ${addValue(args.parties)}::text[]`);
+    }
+    const orderBy = compileOrderBy(args.orderBy);
+    const whereSql = conditions.length === 0 ? "" : `where ${conditions.join(" and ")}`;
+    const limitSql = args.take === undefined ? "" : `limit ${addValue(args.take)}`;
+    const offsetSql = args.skip === undefined ? "" : `offset ${addValue(args.skip)}`;
+    const included = compileProfileIncludes("__contracts", "contract_row", args.include, profile, addValue);
+    const jsonProjection = Object.entries(args.select?.json ?? {}).map(([name, projection]) => {
+        if (projection.field !== "payload")
+            throw new Error(`${projection.field} is not a JSON field of contracts`);
+        if (projection.path.length === 0 || projection.path.some((segment) => segment.length === 0))
+            throw new Error(`${name}.path must be a non-empty JSON path`);
+        const text = `contract_row.payload #>> ${addValue(projection.path)}::text[]`;
+        const expression = projection.as === "text" ? text : projection.as === "numeric" ? `(${text})::numeric::text` : projection.as === "boolean" ? `(${text})::boolean` : `(${text})::timestamptz`;
+        return `${expression} as "${name}"`;
+    });
+    return {
+        text: `select
+  contract_row.contract_id as contract_id,
+  contract_row.creation_package_id as package_id,
+  contract_row.payload,
+  contract_row.witnesses,
+  contract_row.created_at_ix::text as created_event_offset,
+  created_tx.effective_at as created_at,
+  contract_row.archived_at_ix::text as archived_event_offset,
+  archived_tx.effective_at as archived_at,
+  contract_row.archived_at_ix is null as active,
+  contract_row.creation_package_id as template_package_id,
+  contract_tpe_row.module_name as template_module_name,
+  contract_tpe_row.entity_name as template_entity_name${[...included, ...jsonProjection].length === 0 ? "" : `,\n  ${[...included, ...jsonProjection].join(",\n  ")}`}
+from ${profile.relation("__contracts")} contract_row
+join ${profile.relation("__contract_tpe")} contract_tpe_row on contract_tpe_row.pk = contract_row.tpe_pk
+left join ${profile.relation("__transactions")} created_tx on created_tx.ix = contract_row.created_at_ix
+left join ${profile.relation("__transactions")} archived_tx on archived_tx.ix = contract_row.archived_at_ix
+${whereSql}
+${orderBy}
+${limitSql}
+${offsetSql}`,
+        values,
+    };
+}
+function compileProfileIncludes(source, parentAlias, include, profile, addValue) {
+    const selected = [];
+    for (const [name, option] of Object.entries(include ?? {})) {
+        const edge = pqs_schema_profile_js_2.pqsRelationEdges[source]?.[name];
+        if (edge === undefined)
+            throw new Error(`${name} is not a relation of ${source}`);
+        const settings = option === true ? {} : option;
+        if (settings === null || typeof settings !== "object" || Array.isArray(settings))
+            throw new Error(`${name} must be an include option`);
+        const options = settings;
+        if (edge.cardinality === "many" && (typeof options.take !== "number" || !Number.isInteger(options.take) || options.take < 0))
+            throw new Error(`${name} is a to-many relation and requires a non-negative take`);
+        const alias = `"${name}"`;
+        const nested = compileProfileIncludes(edge.target, alias, options.include, profile, addValue);
+        const metadata = pqs_schema_profile_js_2.pqsRelationMetadata[edge.target];
+        const requested = compileIncludedFields(edge.target, options.select, alias, profile);
+        const json = options.select?.json ?? {};
+        const jsonSelections = Object.entries(json).map(([projectionName, projection]) => {
+            if (!pqs_schema_profile_js_1.PqsSchemaProfileV1.jsonField(edge.target, projection.field))
+                throw new Error(`${projection.field} is not a JSON field of ${edge.target}`);
+            if (projection.path.length === 0 || projection.path.some((segment) => segment.length === 0))
+                throw new Error(`${projectionName}.path must be a non-empty JSON path`);
+            const column = edge.target === "__contracts"
+                ? projection.field === "payload" ? "payload" : undefined
+                : metadata.fields[projection.field];
+            if (column === undefined)
+                throw new Error(`${projection.field} is not a field of ${edge.target}`);
+            const text = `${alias}."${column}" #>> ${addValue(projection.path)}::text[]`;
+            const expression = projection.as === "text" ? text : projection.as === "numeric" ? `(${text})::numeric::text` : projection.as === "boolean" ? `(${text})::boolean` : `(${text})::timestamptz`;
+            return [`'${projectionName}'`, expression];
+        });
+        if (requested.length === 0 && jsonSelections.length === 0)
+            throw new Error(`Nested ${name}.select must include at least one field`);
+        const fields = requested.flatMap(([field, expression]) => [`'${field}'`, expression]);
+        const nestedFields = nested.flatMap((selection) => {
+            const match = /^(.*) as "([^"]+)"$/.exec(selection);
+            return match === null ? [] : [`'${match[2]}'`, match[1]];
+        });
+        const object = `jsonb_build_object(${[...fields, ...jsonSelections.flat(), ...nestedFields].join(", ")})`;
+        const relationFilter = options.where === undefined ? "true" : compilePhysicalWhere(edge.target, options.where, alias, profile, addValue);
+        const condition = `${alias}."${edge.targetColumn}" = ${parentAlias}."${edge.sourceColumn}" and (${relationFilter})`;
+        const orderBy = compilePhysicalOrderBy(edge.target, options.orderBy, alias);
+        const expression = edge.cardinality === "one"
+            ? `(select ${object} from ${profile.relation(edge.target)} ${alias} where ${condition})`
+            : `(select coalesce(jsonb_agg("${name}_limited".value), '[]'::jsonb) from (select ${object} as value from ${profile.relation(edge.target)} ${alias} where ${condition}${orderBy} limit ${addValue(options.take)}) "${name}_limited")`;
+        selected.push(`${expression} as "${name}"`);
+    }
+    return selected;
+}
+function compileIncludedFields(target, select, alias, profile) {
+    if (target !== "__contracts") {
+        const metadata = pqs_schema_profile_js_2.pqsRelationMetadata[target];
+        const selected = select === undefined
+            ? Object.entries(metadata.fields)
+            : Object.entries(select).filter(([field, enabled]) => field !== "json" && enabled === true).map(([field]) => [field, metadata.fields[field]]);
+        if (selected.some(([, column]) => column === undefined))
+            throw new Error("Nested relation.select references an unknown field");
+        return selected.map(([field, column]) => [field, `${alias}."${column}"`]);
+    }
+    const selected = select === undefined
+        ? ["contractId", "templateId", "packageId", "payload", "witnesses", "createdEventOffset", "createdAt", "archivedEventOffset", "archivedAt", "active"]
+        : Object.entries(select).filter(([field, enabled]) => field !== "json" && enabled === true).map(([field]) => field);
+    const expressions = {
+        contractId: `${alias}."contract_id"`,
+        templateId: `jsonb_build_object('packageId', ${alias}."creation_package_id", 'moduleName', (select contract_type."module_name" from ${profile.relation("__contract_tpe")} contract_type where contract_type."pk" = ${alias}."tpe_pk"), 'entityName', (select contract_type."entity_name" from ${profile.relation("__contract_tpe")} contract_type where contract_type."pk" = ${alias}."tpe_pk"))`,
+        packageId: `${alias}."creation_package_id"`,
+        payload: `${alias}."payload"`,
+        witnesses: `${alias}."witnesses"`,
+        createdEventOffset: `${alias}."created_at_ix"::text`,
+        createdAt: `(select created_transaction."effective_at" from ${profile.relation("__transactions")} created_transaction where created_transaction."ix" = ${alias}."created_at_ix")`,
+        archivedEventOffset: `${alias}."archived_at_ix"::text`,
+        archivedAt: `(select archived_transaction."effective_at" from ${profile.relation("__transactions")} archived_transaction where archived_transaction."ix" = ${alias}."archived_at_ix")`,
+        active: `${alias}."archived_at_ix" is null`,
+    };
+    const requested = selected.map((field) => [field, expressions[field]]);
+    if (requested.some(([, expression]) => expression === undefined))
+        throw new Error("Nested contract.select references an unknown field");
+    return requested;
+}
+function compilePhysicalOrderBy(relation, orderBy, alias) {
+    if (orderBy === undefined)
+        return "";
+    if (!Array.isArray(orderBy) || orderBy.length === 0)
+        throw new Error("Nested orderBy must be a non-empty list");
+    const metadata = pqs_schema_profile_js_2.pqsRelationMetadata[relation];
+    const entries = orderBy.flatMap((entry) => entry !== null && typeof entry === "object" ? Object.entries(entry) : []);
+    if (entries.length !== orderBy.length || entries.some(([, direction]) => direction !== "asc" && direction !== "desc"))
+        throw new Error("Nested orderBy entries must have one valid direction");
+    return ` order by ${entries.map(([field, direction]) => {
+        const column = metadata.fields[field];
+        if (column === undefined)
+            throw new Error(`${field} is not a field of ${relation}`);
+        return `${alias}."${column}" ${direction}`;
+    }).join(", ")}`;
+}
+function compileContractGroupBy(args, profile) {
+    if (args.by.length === 0 || (!args.aggregate.count && !args.aggregate.min && !args.aggregate.max && !args.aggregate.sum))
+        throw new Error("groupBy requires keys and an aggregate");
+    const values = [];
+    const add = (value) => { values.push(value); return `$${values.length}`; };
+    const where = args.where === undefined ? undefined : compileWhere(args.where, add, profile);
+    const fields = {
+        contractId: "contract_row.contract_id",
+        createdEventOffset: "contract_row.created_at_ix",
+        archivedEventOffset: "contract_row.archived_at_ix",
+    };
+    const expressions = [];
+    const select = [];
+    let unnestWitnesses = false;
+    for (const key of args.by) {
+        if (key === "witnesses") {
+            unnestWitnesses = true;
+            expressions.push("witness.value");
+            select.push("witness.value as \"witnesses\"");
+        }
+        else if (typeof key === "string") {
+            const expression = fields[key];
+            if (expression === undefined)
+                throw new Error(`${key} is not a contract group key`);
+            expressions.push(expression);
+            select.push(`${expression} as "${key}"`);
+        }
+        else {
+            const payload = key.payload;
+            if (payload.path.length === 0 || payload.path.some((segment) => segment.length === 0))
+                throw new Error("payload group path must be non-empty");
+            const base = `contract_row.payload #>> ${add(payload.path)}::text[]`;
+            const cast = payload.as === "text" ? base : `(${base})::${payload.as === "numeric" ? "numeric" : payload.as === "boolean" ? "boolean" : "timestamptz"}`;
+            expressions.push(cast);
+            select.push(`${cast} as "${payload.name}"`);
+        }
+    }
+    if (args.aggregate.count)
+        select.push("count(*)::text as count");
+    for (const [operation, requested] of [["min", args.aggregate.min], ["max", args.aggregate.max], ["sum", args.aggregate.sum]]) {
+        for (const name of requested ?? []) {
+            const expression = fields[name];
+            select.push(`${operation}(${expression})::text as "${operation}_${name}"`);
+        }
+    }
+    return {
+        text: `select ${select.join(", ")} from ${profile.relation("__contracts")} contract_row${unnestWitnesses ? " cross join lateral unnest(contract_row.witnesses) as witness(value)" : ""}${where === undefined ? "" : ` where ${where}`} group by ${expressions.join(", ")}`,
+        values,
+    };
+}
+function compileWhere(where, addValue, profile) {
+    const columns = { contractId: "contract_row.contract_id", packageId: "contract_row.creation_package_id", createdEventOffset: "contract_row.created_at_ix", createdAt: "created_tx.effective_at", archivedEventOffset: "contract_row.archived_at_ix", archivedAt: "archived_tx.effective_at" };
+    const parts = [];
+    for (const [key, value] of Object.entries(where)) {
+        if (key === "and" || key === "or") {
+            if (!Array.isArray(value))
+                throw new Error(`${key} must be an array`);
+            parts.push(value.length === 0 ? key === "and" ? "true" : "false" : `(${value.map((child) => compileWhere(child, addValue, profile)).join(` ${key} `)})`);
+            continue;
+        }
+        if (key === "not") {
+            parts.push(`not (${compileWhere(value, addValue, profile)})`);
+            continue;
+        }
+        if (key === "active") {
+            const active = typeof value === "boolean" ? value : value.equals;
+            if (typeof active !== "boolean")
+                throw new Error("active supports only equals");
+            parts.push(active ? "contract_row.archived_at_ix is null" : "contract_row.archived_at_ix is not null");
+            continue;
+        }
+        if (key === "witnesses") {
+            const has = value.has;
+            if (has === undefined)
+                throw new Error("witnesses supports only has");
+            parts.push(`${addValue(has)} = any(contract_row.witnesses)`);
+            continue;
+        }
+        if (key === "payload") {
+            const payload = value;
+            const compilePayload = (path, filter) => { const ops = ["equals", "lt", "lte", "gt", "gte", "like", "ilike"].filter((op) => filter[op] !== undefined); if (ops.length === 1) {
+                const op = { equals: "=", lt: "<", lte: "<=", gt: ">", gte: ">=", like: "like", ilike: "ilike" }[ops[0]];
+                parts.push(`contract_row.payload #>> ${addValue(path)}::text[] ${op} ${addValue(filter[ops[0]])}`);
+                return;
+            } for (const [name, child] of Object.entries(filter))
+                compilePayload([...path, name], child); };
+            if (payload.match === undefined)
+                throw new Error("payload requires match");
+            compilePayload([], payload.match);
+            continue;
+        }
+        if (key === "templateId") {
+            const fields = { packageId: "contract_row.creation_package_id", moduleName: "contract_tpe_row.module_name", entityName: "contract_tpe_row.entity_name" };
+            for (const [name, filter] of Object.entries(value))
+                for (const [op, operand] of Object.entries(filter)) {
+                    const sql = { equals: "=", lt: "<", lte: "<=", gt: ">", gte: ">=", like: "like", ilike: "ilike" }[op];
+                    if (fields[name] === undefined || sql === undefined)
+                        throw new Error("invalid templateId filter");
+                    parts.push(`${fields[name]} ${sql} ${addValue(operand)}`);
+                }
+            continue;
+        }
+        const edge = pqs_schema_profile_js_2.pqsRelationEdges.__contracts?.[key];
+        if (edge !== undefined) {
+            parts.push(compilePhysicalRelationPredicate(edge.target, key, edge.targetColumn, edge.sourceColumn, edge.cardinality, value, "contract_row", profile, addValue));
+            continue;
+        }
+        const column = columns[key];
+        if (column === undefined || value === null || typeof value !== "object")
+            throw new Error(`${key} is not a supported contract filter`);
+        for (const [op, operand] of Object.entries(value)) {
+            const sql = { equals: "=", lt: "<", lte: "<=", gt: ">", gte: ">=", like: "like", ilike: "ilike" }[op];
+            if (sql !== undefined)
+                parts.push(`${column} ${sql} ${addValue(operand)}`);
+            else if (op === "is" && operand === null)
+                parts.push(`${column} is null`);
+            else if (op === "isNot" && operand === null)
+                parts.push(`${column} is not null`);
+            else if (op === "in" && Array.isArray(operand))
+                parts.push(operand.length ? `${column} = any(${addValue(operand)})` : "false");
+            else
+                throw new Error(`${op} is not supported for ${key}`);
+        }
+    }
+    return parts.length === 0 ? "true" : parts.join(" and ");
+}
+function compilePhysicalRelationPredicate(target, edgeName, targetColumn, sourceColumn, cardinality, value, parentAlias, profile, addValue) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new Error(`${edgeName} must be a relation filter`);
+    const relation = value;
+    const alias = `"${edgeName}"`;
+    const join = `${alias}."${targetColumn}" = ${parentAlias}."${sourceColumn}"`;
+    if (cardinality === "one") {
+        const predicate = compilePhysicalWhere(target, relation, alias, profile, addValue);
+        return `exists (select 1 from ${profile.relation(target)} ${alias} where ${join} and (${predicate}))`;
+    }
+    const operators = ["some", "none", "every"].filter((name) => relation[name] !== undefined);
+    if (operators.length !== 1)
+        throw new Error(`${edgeName} requires exactly one of some, none, or every`);
+    const predicate = compilePhysicalWhere(target, relation[operators[0]], alias, profile, addValue);
+    const base = `select 1 from ${profile.relation(target)} ${alias} where ${join} and (${predicate})`;
+    return operators[0] === "some" ? `exists (${base})` : operators[0] === "none" ? `not exists (${base})` : `not exists (select 1 from ${profile.relation(target)} ${alias} where ${join} and not (${predicate}))`;
+}
+function compilePhysicalWhere(relation, expression, alias, profile, addValue) {
+    if (expression === null || typeof expression !== "object" || Array.isArray(expression))
+        throw new Error(`${relation} relation predicate must be an expression`);
+    const metadata = pqs_schema_profile_js_2.pqsRelationMetadata[relation];
+    const conditions = [];
+    for (const [field, value] of Object.entries(expression)) {
+        if (field === "and" || field === "or") {
+            if (!Array.isArray(value))
+                throw new Error(`${field} must be an array`);
+            conditions.push(value.length === 0 ? field === "and" ? "true" : "false" : `(${value.map((child) => compilePhysicalWhere(relation, child, alias, profile, addValue)).join(` ${field} `)})`);
+            continue;
+        }
+        if (field === "not") {
+            conditions.push(`not (${compilePhysicalWhere(relation, value, alias, profile, addValue)})`);
+            continue;
+        }
+        const edge = pqs_schema_profile_js_2.pqsRelationEdges[relation]?.[field];
+        if (edge !== undefined) {
+            conditions.push(compilePhysicalRelationPredicate(edge.target, field, edge.targetColumn, edge.sourceColumn, edge.cardinality, value, alias, profile, addValue));
+            continue;
+        }
+        const column = metadata.fields[field];
+        if (column === undefined || value === null || typeof value !== "object" || Array.isArray(value))
+            throw new Error(`${field} is not a field of ${relation}`);
+        const filter = value;
+        const text = pqs_schema_profile_js_1.PqsSchemaProfileV1.jsonField(relation, field) && Array.isArray(filter.path) ? `${alias}."${column}" #>> ${addValue(filter.path)}::text[]` : `${alias}."${column}"`;
+        if (Array.isArray(filter.path) && (filter.path.length === 0 || filter.path.some((segment) => typeof segment !== "string" || segment.length === 0)))
+            throw new Error(`${field}.path must be a non-empty JSON path`);
+        if (filter.is === null)
+            conditions.push(`${text} is null`);
+        if (filter.isNot === null)
+            conditions.push(`${text} is not null`);
+        if (filter.equals !== undefined)
+            conditions.push(`${text} = ${addValue(filter.equals)}`);
+        if (filter.in !== undefined) {
+            if (!Array.isArray(filter.in))
+                throw new Error(`${field}.in must be an array`);
+            conditions.push(filter.in.length === 0 ? "false" : `${text} = any(${addValue(filter.in)})`);
+        }
+        if (filter.has !== undefined) {
+            if (!metadata.arrayFields.includes(field))
+                throw new Error(`${field} is not an array field of ${relation}`);
+            conditions.push(`${addValue(filter.has)} = any(${alias}."${column}")`);
+        }
+        for (const [operator, operand] of Object.entries(filter)) {
+            const sql = { lt: "<", lte: "<=", gt: ">", gte: ">=", like: "like", ilike: "ilike" }[operator];
+            if (sql !== undefined)
+                conditions.push(`${text} ${sql} ${addValue(operand)}`);
+        }
+    }
+    return conditions.length === 0 ? "true" : conditions.join(" and ");
+}
+function compileOrderBy(orderBy) {
+    if (orderBy === undefined) {
+        return "order by contract_row.contract_id asc";
+    }
+    const fields = {
+        contractId: "contract_row.contract_id",
+        createdEventOffset: "contract_row.created_at_ix",
+        createdAt: "created_tx.effective_at",
+        archivedEventOffset: "contract_row.archived_at_ix",
+        archivedAt: "archived_tx.effective_at",
+    };
+    const entries = orderBy.flatMap((entry) => Object.entries(entry));
+    if (entries.some(([field, direction]) => fields[field] === undefined || (direction !== "asc" && direction !== "desc"))) {
+        throw new Error("orderBy must contain valid one-field entries");
+    }
+    return `order by ${entries.map(([field, direction]) => `${fields[field]} ${direction}`).join(", ")}`;
+}

package/dist/cjs/query/pqs/read-only-sql.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertReadOnlySql = assertReadOnlySql;
+const allowedStarts = new Set(["select", "with", "explain", "show"]);
+const mutationTokens = new Set([
+    "insert",
+    "update",
+    "delete",
+    "merge",
+    "create",
+    "alter",
+    "drop",
+    "truncate",
+    "grant",
+    "revoke",
+    "copy",
+]);
+function assertReadOnlySql(sql) {
+    const normalized = stripLiteralsAndComments(sql).trim().toLowerCase();
+    const tokens = normalized.match(/[a-z_]+|;/g) ?? [];
+    const firstToken = tokens[0];
+    if (firstToken === undefined || !allowedStarts.has(firstToken)) {
+        throw new Error("PQS raw queries must be read-only statements.");
+    }
+    else if (tokens.some((token) => token === ";")) {
+        throw new Error("PQS raw queries must contain one read-only statement.");
+    }
+    else if (tokens.some((token) => mutationTokens.has(token))) {
+        throw new Error("PQS raw queries must be read-only statements.");
+    }
+}
+function stripLiteralsAndComments(sql) {
+    return sql
+        .replace(/--[^\n]*/g, "")
+        .replace(/\/\*[\s\S]*?\*\//g, "")
+        .replace(/'(?:''|[^'])*'/g, "''")
+        .replace(/"(?:""|[^"])*"/g, '""');
+}

package/dist/cjs/query/query-client.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/query/query-source.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuerySource = void 0;
+var QuerySource;
+(function (QuerySource) {
+    QuerySource["grpc"] = "grpc";
+    QuerySource["pqs"] = "pqs";
+})(QuerySource || (exports.QuerySource = QuerySource = {}));

package/dist/cjs/services/command/command-service-client.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandServiceClient = void 0;
+const command_submission_pipeline_js_1 = require("../commands/command-submission-pipeline.js");
+class CommandServiceClient {
+    pipeline;
+    constructor(transport, signer) {
+        this.pipeline = new command_submission_pipeline_js_1.CommandSubmissionPipeline({
+            transport,
+            signer,
+        });
+    }
+    submitAndWaitForTransactionAsync(request, options) { return this.pipeline.submitForTransactionAsync(request, options); }
+    /** Submits a command and waits for the result. Supported on JSON and gRPC. */
+    submitAndWaitAsync(request, options) {
+        return this.pipeline.submitAsync(request, options);
+    }
+    prepareAsync(request, options) { return this.pipeline.prepareAsync(request, options); }
+    executeAndWaitAsync(prepared, signatures, options) { return this.pipeline.executeAsync(prepared, signatures, options); }
+}
+exports.CommandServiceClient = CommandServiceClient;

package/dist/cjs/services/command-completion/command-completion-service-client.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandCompletionServiceClient = void 0;
+class CommandCompletionServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Reads command completions as a stream. Supported on gRPC; JSON rejects it. */
+    getCompletionsAsync(request, options) {
+        return this.getCompletionsLazy(request, options);
+    }
+    async *getCompletionsLazy(request, options) {
+        yield* this.transport.getCompletionsAsync(request, options);
+    }
+}
+exports.CommandCompletionServiceClient = CommandCompletionServiceClient;

package/dist/cjs/services/command-inspection/command-inspection-service-client.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandInspectionServiceClient = void 0;
+class CommandInspectionServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Reads ledger-admin command status records. Supported on gRPC; JSON rejects it. */
+    getCommandStatusAsync(request, options) {
+        return this.transport.getCommandStatusAsync(request, options);
+    }
+}
+exports.CommandInspectionServiceClient = CommandInspectionServiceClient;

package/dist/cjs/services/command-submission/command-submission-service-client.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandSubmissionServiceClient = void 0;
+const not_supported_error_js_1 = require("../../core/errors/not-supported-error.js");
+class CommandSubmissionServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Submits a command without waiting. Placeholder until explicitly implemented. */
+    async submitAsync(_request) {
+        throw new not_supported_error_js_1.NotSupportedError("CommandSubmissionService.Submit is not available yet");
+    }
+}
+exports.CommandSubmissionServiceClient = CommandSubmissionServiceClient;

package/dist/cjs/services/commands/command-payload-builder.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCanonicalCommandPayload = buildCanonicalCommandPayload;
+const create_and_exercise_command_js_1 = require("../../core/types/commands/create-and-exercise-command.js");
+const create_command_js_1 = require("../../core/types/commands/create-command.js");
+const exercise_by_key_command_js_1 = require("../../core/types/commands/exercise-by-key-command.js");
+const exercise_command_js_1 = require("../../core/types/commands/exercise-command.js");
+function buildCanonicalCommandPayload(request) {
+    return new TextEncoder().encode(JSON.stringify({
+        applicationId: request.applicationId,
+        actAs: request.actAs,
+        readAs: request.readAs,
+        command: mapCanonicalCommand(request.command),
+    }));
+}
+function mapCanonicalCommand(command) {
+    if (command instanceof create_command_js_1.CreateCommand) {
+        return {
+            kind: "create",
+            templateId: command.templateId,
+            createArguments: mapCanonicalRecord(command.createArguments),
+        };
+    }
+    else if (command instanceof exercise_command_js_1.ExerciseCommand) {
+        return {
+            kind: "exercise",
+            templateId: command.templateId,
+            contractId: command.contractId,
+            choice: command.choice,
+            choiceArgument: command.choiceArgument,
+        };
+    }
+    else if (command instanceof exercise_by_key_command_js_1.ExerciseByKeyCommand) {
+        return {
+            kind: "exerciseByKey",
+            templateId: command.templateId,
+            contractKey: command.contractKey,
+            choice: command.choice,
+            choiceArgument: command.choiceArgument,
+        };
+    }
+    else if (command instanceof create_and_exercise_command_js_1.CreateAndExerciseCommand) {
+        return {
+            kind: "createAndExercise",
+            templateId: command.templateId,
+            createArguments: mapCanonicalRecord(command.createArguments),
+            choice: command.choice,
+            choiceArgument: command.choiceArgument,
+        };
+    }
+    return {};
+}
+function mapCanonicalRecord(record) {
+    return {
+        fields: record.fields,
+        recordId: record.recordId ?? null,
+    };
+}

package/dist/cjs/services/commands/command-submission-pipeline.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandSubmissionPipeline = void 0;
+const not_supported_error_js_1 = require("../../core/errors/not-supported-error.js");
+class CommandSubmissionPipeline {
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    async submitAsync(request, options) {
+        if (this.dependencies.signer) {
+            if (!this.dependencies.transport.features.supportsCommandSigning) {
+                throw new not_supported_error_js_1.NotSupportedError("command signing is not supported by the selected transport");
+            }
+        }
+        return this.dependencies.transport.submitCommandAsync(request, this.dependencies.signer, options);
+    }
+    submitForTransactionAsync(request, options) { if (!this.dependencies.transport.submitCommandForTransactionAsync)
+        throw new not_supported_error_js_1.NotSupportedError("transaction-returning command submission is not supported by the selected transport"); return this.dependencies.transport.submitCommandForTransactionAsync(request, options); }
+    prepareAsync(request, options) { if (!this.dependencies.transport.prepareCommandAsync)
+        throw new not_supported_error_js_1.NotSupportedError("interactive command preparation is not supported by the selected transport"); return this.dependencies.transport.prepareCommandAsync(request, options); }
+    executeAsync(prepared, signatures, options) { if (!this.dependencies.transport.executePreparedCommandAndWaitAsync)
+        throw new not_supported_error_js_1.NotSupportedError("interactive command execution is not supported by the selected transport"); return this.dependencies.transport.executePreparedCommandAndWaitAsync(prepared, signatures, options); }
+}
+exports.CommandSubmissionPipeline = CommandSubmissionPipeline;

package/dist/cjs/services/contract/contract-service-client.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractServiceClient = void 0;
+class ContractServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Reads a single contract. Supported on gRPC; JSON rejects it. */
+    getContractAsync(request, options) {
+        return this.transport.getContractAsync(request, options);
+    }
+}
+exports.ContractServiceClient = ContractServiceClient;

package/dist/cjs/services/contracts/contract-observer.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/services/event-query/event-query-service-client.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventQueryServiceClient = void 0;
+class EventQueryServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Reads lifecycle events for a contract id. Supported on gRPC; JSON rejects it. */
+    getEventsByContractIdAsync(request, options) {
+        return this.transport.getEventsByContractIdAsync(request, options);
+    }
+}
+exports.EventQueryServiceClient = EventQueryServiceClient;

package/dist/cjs/services/events/transaction-observer.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/services/health/health-service-client.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthServiceClient = void 0;
+class HealthServiceClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+        void this.transport;
+    }
+    /** Checks gRPC health. Supported on gRPC; JSON rejects it. */
+    checkAsync(request, options) {
+        return this.transport.checkHealthAsync(request, options);
+    }
+}
+exports.HealthServiceClient = HealthServiceClient;