@distrohelena/canton-typescript-sdk 0.1.41 → 0.1.42

package/dist/cjs/query/canonical/query-normalizer.js

@@ -475,7 +475,7 @@ function provesActive(predicate) {
         return false;
     }
     else if (predicate.kind === "scalar") {
-        return predicate.path.length === 1 && predicate.path[0] === "active" && predicate.operator === "equals" && predicate.value === true;
+        return provesActiveScalar(predicate);
     }
     else if (predicate.kind === "and") {
         return predicate.children.some(provesActive);
@@ -485,6 +485,20 @@ function provesActive(predicate) {
     }
     return false;
 }
+/** A contract is active iff archivedAt/archivedEventOffset are null, so either form proves the same fact as active: true. */
+function provesActiveScalar(predicate) {
+    if (predicate.path.length !== 1) {
+        return false;
+    }
+    const [field] = predicate.path;
+    if (field === "active") {
+        return predicate.operator === "equals" && predicate.value === true;
+    }
+    else if (field === "archivedAt" || field === "archivedEventOffset") {
+        return predicate.operator === "is" && predicate.value === null;
+    }
+    return false;
+}
 function validateOperatorValue(operator, value, field, kind, nullable) {
     if (operator === "is" || operator === "isNot") {
         if (value !== null) {

package/dist/cjs/query/grpc/grpc-package-relation-reader.js

@@ -23,6 +23,8 @@ exports.GrpcPackageRelationError = GrpcPackageRelationError;
 class GrpcPackageRelationReader {
     packageService;
     packageLoader;
+    /** Package IDs are content-addressed SHA-256 digests (verified below), so a resolved entry is cached forever. */
+    resolved = new Map();
     constructor(packageService, packageLoader = new daml_lf_package_loader_js_1.DamlLfPackageLoader()) {
         this.packageService = packageService;
         this.packageLoader = packageLoader;
@@ -53,6 +55,10 @@ class GrpcPackageRelationReader {
         return Object.freeze(packages.slice().sort((left, right) => left.id.localeCompare(right.id)));
     }
     async readPackageAsync(packageId) {
+        const cached = this.resolved.get(packageId);
+        if (cached !== undefined) {
+            return cached;
+        }
         let response;
         try {
             response = await this.packageService.getPackageAsync({ packageId });
@@ -88,12 +94,14 @@ class GrpcPackageRelationReader {
                     .map((template) => templateMetadata(packageId, packageName, module.name, template))),
                 ...interfaceMetadata(packageId, packageName, result.rawPackage),
             ];
-            return Object.freeze({
+            const metadata = Object.freeze({
                 id: packageId,
                 name: packageName,
                 version: requiredPackageText(pkg.packageVersion, "version"),
                 templates: Object.freeze(templates),
             });
+            this.resolved.set(packageId, metadata);
+            return metadata;
         }
         catch (error) {
             throw isGrpcPackageRelationError(error) ? error : new GrpcPackageRelationError(packageId, errorMessage(error));

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

@@ -88,14 +88,24 @@ class DefaultGrpcQueryDataProvider {
             const history = await this.snapshots.readHistoryAsync(endInclusive);
             const transactions = history.updates.flatMap((response) => response.update.oneofKind === "transaction" ? [response.update.transaction] : []);
             const fragment = (0, grpc_relation_mapper_js_1.mapGrpcQueryRelationFragment)(transactions);
+            const useCreationsOnlyMetadata = requiresPackageMetadata(closure)
+                && query.relation !== "packages" && query.relation !== "contractTypes" && query.relation !== "exerciseTypes"
+                && derivableFromCreationsOnly(closure);
             const packageMetadata = !requiresPackageMetadata(closure)
                 ? []
                 : query.relation === "packages" || query.relation === "contractTypes" || query.relation === "exerciseTypes"
                     ? await this.packages.readAllAsync()
-                    : await this.packages.readPackagesAsync((0, grpc_relation_mapper_js_1.referencedGrpcPackageIds)(fragment));
+                    : useCreationsOnlyMetadata
+                        ? (0, grpc_relation_mapper_js_1.contractTypeMetadataFromCreations)(fragment.creationIdentities)
+                        : await this.packages.readPackagesAsync((0, grpc_relation_mapper_js_1.referencedGrpcPackageIds)(fragment));
+            // The closure guarantees this query never reads "exercises" here, but the replayed window can still
+            // contain unrelated exercises (createGrpcQueryDataset always resolves package metadata for every
+            // exercise in the fragment). contractTypeMetadataFromCreations only knows about templates, so drop
+            // the exercises this query doesn't need instead of paying for their canonical keys.
+            const datasetFragment = useCreationsOnlyMetadata ? { ...fragment, exercises: [] } : fragment;
             return packageMetadata.length === 0
                 ? fragmentDataset(fragment, endInclusive, this.options.endpointScope ?? "ledger")
-                : (0, grpc_relation_mapper_js_1.createGrpcQueryDataset)(fragment, packageMetadata, endInclusive, this.options.endpointScope ?? "ledger");
+                : (0, grpc_relation_mapper_js_1.createGrpcQueryDataset)(datasetFragment, packageMetadata, endInclusive, this.options.endpointScope ?? "ledger");
         }
         const endInclusive = cached?.activeAtOffset ?? (await this.options.stateService.getLedgerEndAsync({})).offset;
         if (query.relation === "packages" || query.relation === "contractTypes" || query.relation === "exerciseTypes") {
@@ -112,9 +122,16 @@ class DefaultGrpcQueryDataProvider {
         }
         const active = await this.snapshots.readActiveContractsAsync(endInclusive, partiesFor(query));
         const fragment = (0, grpc_relation_mapper_js_1.mapGrpcQueryRelationFragment)([], active.activeContracts);
-        return requiresPackageMetadata(closure)
-            ? (0, grpc_relation_mapper_js_1.createGrpcQueryDataset)(fragment, await this.packages.readPackagesAsync((0, grpc_relation_mapper_js_1.referencedGrpcPackageIds)(fragment)), endInclusive, this.options.endpointScope ?? "ledger")
-            : fragmentDataset(fragment, endInclusive, this.options.endpointScope ?? "ledger", false);
+        if (!requiresPackageMetadata(closure)) {
+            return fragmentDataset(fragment, endInclusive, this.options.endpointScope ?? "ledger", false);
+        }
+        // Reaching here guarantees query.relation === "contracts" with needsHistory === false, which (per
+        // predicateRequiresHistory/includesRequireHistory above) is only possible when the closure never
+        // touches "exercises"/"exerciseTypes"/"packages"/"transactions"/"events" — those unconditionally force
+        // history. So requiresPackageMetadata(closure) here can only be "contractTypes", and every contract in
+        // this ACS-only fragment already carries its own packageName — no Package Service call needed.
+        const packageMetadata = (0, grpc_relation_mapper_js_1.contractTypeMetadataFromCreations)(fragment.creationIdentities);
+        return (0, grpc_relation_mapper_js_1.createGrpcQueryDataset)(fragment, packageMetadata, endInclusive, this.options.endpointScope ?? "ledger");
     }
 }
 function requiresHistory(query) {
@@ -143,7 +160,15 @@ function predicateProvesActive(predicate) {
         return false;
     }
     else if (predicate.kind === "scalar") {
-        return predicate.path.length === 1 && predicate.path[0] === "active" && predicate.operator === "equals" && predicate.value === true;
+        if (predicate.path.length !== 1) {
+            return false;
+        }
+        const [field] = predicate.path;
+        // A contract is active iff archivedAt/archivedEventOffset are null, so either form proves the
+        // same fact as active: true (kept in sync with provesActive in canonical/query-normalizer.ts).
+        return field === "active"
+            ? predicate.operator === "equals" && predicate.value === true
+            : (field === "archivedAt" || field === "archivedEventOffset") && predicate.operator === "is" && predicate.value === null;
     }
     else if (predicate.kind === "and") {
         return predicate.children.some(predicateProvesActive);
@@ -156,6 +181,24 @@ function predicateProvesActive(predicate) {
 function requiresPackageMetadata(closure) {
     return closure.has("packages") || closure.has("contractTypes") || closure.has("exercises") || closure.has("exerciseTypes");
 }
+/**
+ * True when contractType metadata can be derived from the fetched creation events alone (see
+ * contractTypeMetadataFromCreations), instead of decoding LF packages. Every CreatedEvent already carries its
+ * own packageName, so this always holds whenever the query's closure needs only "contractTypes" (plus
+ * "contracts"/"transactions"/"events", which carry no package linkage of their own). It does NOT extend to
+ * "exercises"/"exerciseTypes": ExercisedEvent.packageName documents "the package name of the contract" — i.e.
+ * the template side — so it is not a reliable source for the choice owner's package name when a choice was
+ * exercised via an interface. "packages" is excluded because its own rows (e.g. version) have no event
+ * equivalent at all.
+ *
+ * The caller is responsible for dropping any exercises the fetched fragment happens to contain before handing
+ * it to createGrpcQueryDataset: a full-history fragment reflects the *entire* replayed window, not just what
+ * this query's closure touches, and createGrpcQueryDataset unconditionally resolves package metadata for
+ * every exercise present — this function only knows about templates, not choices.
+ */
+function derivableFromCreationsOnly(closure) {
+    return closure.has("contractTypes") && !closure.has("exercises") && !closure.has("exerciseTypes") && !closure.has("packages");
+}
 function predicateRequiresHistory(relation, predicate) {
     if (predicate === undefined || predicate.kind === "scalar") {
         return false;

package/dist/cjs/query/grpc/grpc-relation-mapper.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mapGrpcQueryRelationFragment = mapGrpcQueryRelationFragment;
 exports.createGrpcQueryDataset = createGrpcQueryDataset;
 exports.referencedGrpcPackageIds = referencedGrpcPackageIds;
+exports.contractTypeMetadataFromCreations = contractTypeMetadataFromCreations;
 const validation_error_js_1 = require("../../core/errors/validation-error.js");
 const query_dataset_js_1 = require("../canonical/query-dataset.js");
 const public_identity_js_1 = require("../canonical/public-identity.js");
@@ -243,6 +244,46 @@ function referencedGrpcPackageIds(fragment) {
             ...fragment.typeIdentities.filter((identity) => identity.choice !== undefined).map((identity) => identity.packageId),
         ])].sort());
 }
+/**
+ * Derives contractType metadata straight from already-fetched created-contract events instead of the
+ * Package Service. Only valid where the caller has confirmed the query's relation closure is a subset of
+ * {contracts, contractTypes} — every contract's own creation event already carries packageName directly,
+ * so no archive decode is needed. "version" is a placeholder: this path is unreachable from any query that
+ * can see the "packages" relation, so it is never observed.
+ */
+function contractTypeMetadataFromCreations(creationIdentities) {
+    const packages = new Map();
+    for (const creation of creationIdentities) {
+        const packageId = creation.representativePackageId ?? creation.creationPackageId;
+        const { moduleName, entityName } = creation.templateId;
+        let pkg = packages.get(packageId);
+        if (pkg === undefined) {
+            pkg = { name: creation.packageName, templates: new Map() };
+            packages.set(packageId, pkg);
+        }
+        else if (pkg.name !== creation.packageName) {
+            throw new validation_error_js_1.ValidationError(`gRPC query package ${packageId} reports conflicting package names`);
+        }
+        const identity = `${moduleName}${entityName}`;
+        if (!pkg.templates.has(identity)) {
+            const templateFqn = `${pkg.name}:${moduleName}:${entityName}`;
+            pkg.templates.set(identity, Object.freeze({
+                moduleName,
+                entityName,
+                payloadType: "template",
+                aliases: Object.freeze([templateFqn, `${moduleName}:${entityName}`, entityName]),
+                templateFqn,
+                choices: Object.freeze([]),
+            }));
+        }
+    }
+    return Object.freeze([...packages.entries()].map(([id, pkg]) => Object.freeze({
+        id,
+        name: pkg.name,
+        version: "unresolved",
+        templates: Object.freeze([...pkg.templates.values()]),
+    })));
+}
 function compareTemplateMetadata(left, right) {
     return left.package.id.localeCompare(right.package.id) || left.template.moduleName.localeCompare(right.template.moduleName) || left.template.entityName.localeCompare(right.template.entityName);
 }
@@ -622,6 +663,7 @@ function creationDescriptor(event, offset) {
         templateId: copyTemplate(template),
         creationPackageId: template.packageId,
         representativePackageId: nullableString(event.representativePackageId),
+        packageName: event.packageName,
         payload: (0, grpc_query_value_mapper_js_1.mapGrpcQueryValue)({ sum: { oneofKind: "record", record: event.createArguments } }),
         witnesses: immutableStrings(event.witnessParties, "created event witnesses", true),
         createdAt,

package/dist/query/canonical/query-normalizer.js

@@ -466,7 +466,7 @@ function provesActive(predicate) {
         return false;
     }
     else if (predicate.kind === "scalar") {
-        return predicate.path.length === 1 && predicate.path[0] === "active" && predicate.operator === "equals" && predicate.value === true;
+        return provesActiveScalar(predicate);
     }
     else if (predicate.kind === "and") {
         return predicate.children.some(provesActive);
@@ -476,6 +476,20 @@ function provesActive(predicate) {
     }
     return false;
 }
+/** A contract is active iff archivedAt/archivedEventOffset are null, so either form proves the same fact as active: true. */
+function provesActiveScalar(predicate) {
+    if (predicate.path.length !== 1) {
+        return false;
+    }
+    const [field] = predicate.path;
+    if (field === "active") {
+        return predicate.operator === "equals" && predicate.value === true;
+    }
+    else if (field === "archivedAt" || field === "archivedEventOffset") {
+        return predicate.operator === "is" && predicate.value === null;
+    }
+    return false;
+}
 function validateOperatorValue(operator, value, field, kind, nullable) {
     if (operator === "is" || operator === "isNot") {
         if (value !== null) {

package/dist/query/grpc/grpc-package-relation-reader.d.ts

@@ -36,6 +36,8 @@ export declare class GrpcPackageRelationError extends CantonError {
 export declare class GrpcPackageRelationReader {
     private readonly packageService;
     private readonly packageLoader;
+    /** Package IDs are content-addressed SHA-256 digests (verified below), so a resolved entry is cached forever. */
+    private readonly resolved;
     constructor(packageService: GrpcPackageService, packageLoader?: DamlLfPackageLoader);
     readAllAsync(): Promise<readonly GrpcPackageMetadata[]>;
     readPackagesAsync(packageIds: readonly string[]): Promise<readonly GrpcPackageMetadata[]>;

package/dist/query/grpc/grpc-package-relation-reader.js

@@ -19,6 +19,8 @@ export class GrpcPackageRelationError extends CantonError {
 export class GrpcPackageRelationReader {
     packageService;
     packageLoader;
+    /** Package IDs are content-addressed SHA-256 digests (verified below), so a resolved entry is cached forever. */
+    resolved = new Map();
     constructor(packageService, packageLoader = new DamlLfPackageLoader()) {
         this.packageService = packageService;
         this.packageLoader = packageLoader;
@@ -49,6 +51,10 @@ export class GrpcPackageRelationReader {
         return Object.freeze(packages.slice().sort((left, right) => left.id.localeCompare(right.id)));
     }
     async readPackageAsync(packageId) {
+        const cached = this.resolved.get(packageId);
+        if (cached !== undefined) {
+            return cached;
+        }
         let response;
         try {
             response = await this.packageService.getPackageAsync({ packageId });
@@ -84,12 +90,14 @@ export class GrpcPackageRelationReader {
                     .map((template) => templateMetadata(packageId, packageName, module.name, template))),
                 ...interfaceMetadata(packageId, packageName, result.rawPackage),
             ];
-            return Object.freeze({
+            const metadata = Object.freeze({
                 id: packageId,
                 name: packageName,
                 version: requiredPackageText(pkg.packageVersion, "version"),
                 templates: Object.freeze(templates),
             });
+            this.resolved.set(packageId, metadata);
+            return metadata;
         }
         catch (error) {
             throw isGrpcPackageRelationError(error) ? error : new GrpcPackageRelationError(packageId, errorMessage(error));

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

@@ -5,7 +5,7 @@ import { createQueryDataset } from "../canonical/query-dataset.js";
 import { normalizeAggregate, normalizeCount, normalizeFindMany, normalizeFindUnique, normalizeGroupBy } from "../canonical/query-normalizer.js";
 import { queryRelationEdges, queryRelations } from "../canonical/query-schema.js";
 import { QuerySource } from "../query-source.js";
-import { createGrpcQueryDataset, mapGrpcQueryRelationFragment, referencedGrpcPackageIds } from "./grpc-relation-mapper.js";
+import { contractTypeMetadataFromCreations, createGrpcQueryDataset, mapGrpcQueryRelationFragment, referencedGrpcPackageIds } from "./grpc-relation-mapper.js";
 import { GrpcPackageRelationReader } from "./grpc-package-relation-reader.js";
 import { GrpcQuerySnapshotReader } from "./grpc-query-snapshot-reader.js";
 export class GrpcQueryClient {
@@ -84,14 +84,24 @@ class DefaultGrpcQueryDataProvider {
             const history = await this.snapshots.readHistoryAsync(endInclusive);
             const transactions = history.updates.flatMap((response) => response.update.oneofKind === "transaction" ? [response.update.transaction] : []);
             const fragment = mapGrpcQueryRelationFragment(transactions);
+            const useCreationsOnlyMetadata = requiresPackageMetadata(closure)
+                && query.relation !== "packages" && query.relation !== "contractTypes" && query.relation !== "exerciseTypes"
+                && derivableFromCreationsOnly(closure);
             const packageMetadata = !requiresPackageMetadata(closure)
                 ? []
                 : query.relation === "packages" || query.relation === "contractTypes" || query.relation === "exerciseTypes"
                     ? await this.packages.readAllAsync()
-                    : await this.packages.readPackagesAsync(referencedGrpcPackageIds(fragment));
+                    : useCreationsOnlyMetadata
+                        ? contractTypeMetadataFromCreations(fragment.creationIdentities)
+                        : await this.packages.readPackagesAsync(referencedGrpcPackageIds(fragment));
+            // The closure guarantees this query never reads "exercises" here, but the replayed window can still
+            // contain unrelated exercises (createGrpcQueryDataset always resolves package metadata for every
+            // exercise in the fragment). contractTypeMetadataFromCreations only knows about templates, so drop
+            // the exercises this query doesn't need instead of paying for their canonical keys.
+            const datasetFragment = useCreationsOnlyMetadata ? { ...fragment, exercises: [] } : fragment;
             return packageMetadata.length === 0
                 ? fragmentDataset(fragment, endInclusive, this.options.endpointScope ?? "ledger")
-                : createGrpcQueryDataset(fragment, packageMetadata, endInclusive, this.options.endpointScope ?? "ledger");
+                : createGrpcQueryDataset(datasetFragment, packageMetadata, endInclusive, this.options.endpointScope ?? "ledger");
         }
         const endInclusive = cached?.activeAtOffset ?? (await this.options.stateService.getLedgerEndAsync({})).offset;
         if (query.relation === "packages" || query.relation === "contractTypes" || query.relation === "exerciseTypes") {
@@ -108,9 +118,16 @@ class DefaultGrpcQueryDataProvider {
         }
         const active = await this.snapshots.readActiveContractsAsync(endInclusive, partiesFor(query));
         const fragment = mapGrpcQueryRelationFragment([], active.activeContracts);
-        return requiresPackageMetadata(closure)
-            ? createGrpcQueryDataset(fragment, await this.packages.readPackagesAsync(referencedGrpcPackageIds(fragment)), endInclusive, this.options.endpointScope ?? "ledger")
-            : fragmentDataset(fragment, endInclusive, this.options.endpointScope ?? "ledger", false);
+        if (!requiresPackageMetadata(closure)) {
+            return fragmentDataset(fragment, endInclusive, this.options.endpointScope ?? "ledger", false);
+        }
+        // Reaching here guarantees query.relation === "contracts" with needsHistory === false, which (per
+        // predicateRequiresHistory/includesRequireHistory above) is only possible when the closure never
+        // touches "exercises"/"exerciseTypes"/"packages"/"transactions"/"events" — those unconditionally force
+        // history. So requiresPackageMetadata(closure) here can only be "contractTypes", and every contract in
+        // this ACS-only fragment already carries its own packageName — no Package Service call needed.
+        const packageMetadata = contractTypeMetadataFromCreations(fragment.creationIdentities);
+        return createGrpcQueryDataset(fragment, packageMetadata, endInclusive, this.options.endpointScope ?? "ledger");
     }
 }
 function requiresHistory(query) {
@@ -139,7 +156,15 @@ function predicateProvesActive(predicate) {
         return false;
     }
     else if (predicate.kind === "scalar") {
-        return predicate.path.length === 1 && predicate.path[0] === "active" && predicate.operator === "equals" && predicate.value === true;
+        if (predicate.path.length !== 1) {
+            return false;
+        }
+        const [field] = predicate.path;
+        // A contract is active iff archivedAt/archivedEventOffset are null, so either form proves the
+        // same fact as active: true (kept in sync with provesActive in canonical/query-normalizer.ts).
+        return field === "active"
+            ? predicate.operator === "equals" && predicate.value === true
+            : (field === "archivedAt" || field === "archivedEventOffset") && predicate.operator === "is" && predicate.value === null;
     }
     else if (predicate.kind === "and") {
         return predicate.children.some(predicateProvesActive);
@@ -152,6 +177,24 @@ function predicateProvesActive(predicate) {
 function requiresPackageMetadata(closure) {
     return closure.has("packages") || closure.has("contractTypes") || closure.has("exercises") || closure.has("exerciseTypes");
 }
+/**
+ * True when contractType metadata can be derived from the fetched creation events alone (see
+ * contractTypeMetadataFromCreations), instead of decoding LF packages. Every CreatedEvent already carries its
+ * own packageName, so this always holds whenever the query's closure needs only "contractTypes" (plus
+ * "contracts"/"transactions"/"events", which carry no package linkage of their own). It does NOT extend to
+ * "exercises"/"exerciseTypes": ExercisedEvent.packageName documents "the package name of the contract" — i.e.
+ * the template side — so it is not a reliable source for the choice owner's package name when a choice was
+ * exercised via an interface. "packages" is excluded because its own rows (e.g. version) have no event
+ * equivalent at all.
+ *
+ * The caller is responsible for dropping any exercises the fetched fragment happens to contain before handing
+ * it to createGrpcQueryDataset: a full-history fragment reflects the *entire* replayed window, not just what
+ * this query's closure touches, and createGrpcQueryDataset unconditionally resolves package metadata for
+ * every exercise present — this function only knows about templates, not choices.
+ */
+function derivableFromCreationsOnly(closure) {
+    return closure.has("contractTypes") && !closure.has("exercises") && !closure.has("exerciseTypes") && !closure.has("packages");
+}
 function predicateRequiresHistory(relation, predicate) {
     if (predicate === undefined || predicate.kind === "scalar") {
         return false;

package/dist/query/grpc/grpc-relation-mapper.d.ts

@@ -28,6 +28,7 @@ export interface GrpcQueryCreationIdentity {
     }>;
     readonly creationPackageId: string;
     readonly representativePackageId: string | null;
+    readonly packageName: string;
     readonly payload: unknown;
     readonly witnesses: readonly string[];
     readonly createdAt: Date;
@@ -65,3 +66,11 @@ export declare function mapGrpcQueryRelationFragment(source: readonly Transactio
 export declare function createGrpcQueryDataset(fragment: GrpcQueryRelationFragment, packages: readonly GrpcPackageMetadata[], endInclusive: string, instanceId: string): QueryDataset;
 /** Package payloads required for a contract/history relation plan, excluding creation-only provenance. */
 export declare function referencedGrpcPackageIds(fragment: GrpcQueryRelationFragment): readonly string[];
+/**
+ * Derives contractType metadata straight from already-fetched created-contract events instead of the
+ * Package Service. Only valid where the caller has confirmed the query's relation closure is a subset of
+ * {contracts, contractTypes} — every contract's own creation event already carries packageName directly,
+ * so no archive decode is needed. "version" is a placeholder: this path is unreachable from any query that
+ * can see the "packages" relation, so it is never observed.
+ */
+export declare function contractTypeMetadataFromCreations(creationIdentities: readonly GrpcQueryCreationIdentity[]): readonly GrpcPackageMetadata[];

package/dist/query/grpc/grpc-relation-mapper.js

@@ -238,6 +238,46 @@ export function referencedGrpcPackageIds(fragment) {
             ...fragment.typeIdentities.filter((identity) => identity.choice !== undefined).map((identity) => identity.packageId),
         ])].sort());
 }
+/**
+ * Derives contractType metadata straight from already-fetched created-contract events instead of the
+ * Package Service. Only valid where the caller has confirmed the query's relation closure is a subset of
+ * {contracts, contractTypes} — every contract's own creation event already carries packageName directly,
+ * so no archive decode is needed. "version" is a placeholder: this path is unreachable from any query that
+ * can see the "packages" relation, so it is never observed.
+ */
+export function contractTypeMetadataFromCreations(creationIdentities) {
+    const packages = new Map();
+    for (const creation of creationIdentities) {
+        const packageId = creation.representativePackageId ?? creation.creationPackageId;
+        const { moduleName, entityName } = creation.templateId;
+        let pkg = packages.get(packageId);
+        if (pkg === undefined) {
+            pkg = { name: creation.packageName, templates: new Map() };
+            packages.set(packageId, pkg);
+        }
+        else if (pkg.name !== creation.packageName) {
+            throw new ValidationError(`gRPC query package ${packageId} reports conflicting package names`);
+        }
+        const identity = `${moduleName}${entityName}`;
+        if (!pkg.templates.has(identity)) {
+            const templateFqn = `${pkg.name}:${moduleName}:${entityName}`;
+            pkg.templates.set(identity, Object.freeze({
+                moduleName,
+                entityName,
+                payloadType: "template",
+                aliases: Object.freeze([templateFqn, `${moduleName}:${entityName}`, entityName]),
+                templateFqn,
+                choices: Object.freeze([]),
+            }));
+        }
+    }
+    return Object.freeze([...packages.entries()].map(([id, pkg]) => Object.freeze({
+        id,
+        name: pkg.name,
+        version: "unresolved",
+        templates: Object.freeze([...pkg.templates.values()]),
+    })));
+}
 function compareTemplateMetadata(left, right) {
     return left.package.id.localeCompare(right.package.id) || left.template.moduleName.localeCompare(right.template.moduleName) || left.template.entityName.localeCompare(right.template.entityName);
 }
@@ -617,6 +657,7 @@ function creationDescriptor(event, offset) {
         templateId: copyTemplate(template),
         creationPackageId: template.packageId,
         representativePackageId: nullableString(event.representativePackageId),
+        packageName: event.packageName,
         payload: mapGrpcQueryValue({ sum: { oneofKind: "record", record: event.createArguments } }),
         witnesses: immutableStrings(event.witnessParties, "created event witnesses", true),
         createdAt,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@distrohelena/canton-typescript-sdk",
-    "version": "0.1.41",
+    "version": "0.1.42",
     "license": "Apache-2.0",
     "type": "module",
     "main": "./dist/index.js",