@distrohelena/canton-typescript-sdk 0.1.43 → 0.1.45

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

@@ -242,40 +242,92 @@ export function referencedGrpcPackageIds(fragment) {
  * 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.
+ * so no archive decode is needed. "version" is a per-package 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([]),
-            }));
+    addDerivedCreationEntries(packages, creationIdentities);
+    return finalizeDerivedPackages(packages);
+}
+/**
+ * Extends the creations-only derivation to exercises: for a direct exercise the choice owner IS the
+ * exercised template, so the event's own packageName names the owner's package and choice/consuming come
+ * straight off the event. Returns undefined when the window contains an interface-exercised choice — its
+ * owner is the interface, whose package name the event does not carry, so only the decoded archive can
+ * produce its canonical choiceFqn. Unobserved choices are simply absent, which is complete for query plans
+ * that reach exerciseTypes only through observed exercises (never for exerciseTypes catalog queries).
+ */
+export function packageMetadataFromEvents(fragment) {
+    if (fragment.typeIdentities.some((identity) => identity.choice !== undefined && identity.packageName === undefined)) {
+        return undefined;
+    }
+    const packages = new Map();
+    addDerivedCreationEntries(packages, fragment.creationIdentities);
+    for (const identity of fragment.typeIdentities) {
+        if (identity.packageName === undefined) {
+            throw new ValidationError("gRPC query contract type identity is missing its package name");
+        }
+        const template = derivedTemplateFor(derivedPackageFor(packages, identity.packageId, identity.packageName), identity.templateId.moduleName, identity.templateId.entityName);
+        if (identity.choice !== undefined) {
+            const consuming = template.choices.get(identity.choice);
+            if (consuming !== undefined && consuming !== identity.consuming) {
+                throw new ValidationError(`gRPC query choice ${identity.choice} reports conflicting consuming flags`);
+            }
+            template.choices.set(identity.choice, identity.consuming === true);
         }
     }
+    return finalizeDerivedPackages(packages);
+}
+function addDerivedCreationEntries(packages, creationIdentities) {
+    for (const creation of creationIdentities) {
+        derivedTemplateFor(derivedPackageFor(packages, creation.representativePackageId ?? creation.creationPackageId, creation.packageName), creation.templateId.moduleName, creation.templateId.entityName);
+    }
+}
+function derivedPackageFor(packages, packageId, packageName) {
+    const existing = packages.get(packageId);
+    if (existing === undefined) {
+        const created = { name: packageName, templates: new Map() };
+        packages.set(packageId, created);
+        return created;
+    }
+    else if (existing.name !== packageName) {
+        throw new ValidationError(`gRPC query package ${packageId} reports conflicting package names`);
+    }
+    return existing;
+}
+function derivedTemplateFor(pkg, moduleName, entityName) {
+    const identity = `${moduleName} ${entityName}`;
+    let template = pkg.templates.get(identity);
+    if (template === undefined) {
+        template = { moduleName, entityName, choices: new Map() };
+        pkg.templates.set(identity, template);
+    }
+    return template;
+}
+function finalizeDerivedPackages(packages) {
     return Object.freeze([...packages.entries()].map(([id, pkg]) => Object.freeze({
         id,
         name: pkg.name,
-        version: "unresolved",
-        templates: Object.freeze([...pkg.templates.values()]),
+        // Unique per package: two versions of the same package name can both appear in one window, and
+        // duplicate name+version pairs are rejected during dataset normalization.
+        version: `unresolved-${id}`,
+        templates: Object.freeze([...pkg.templates.values()].map((template) => {
+            const templateFqn = `${pkg.name}:${template.moduleName}:${template.entityName}`;
+            return Object.freeze({
+                moduleName: template.moduleName,
+                entityName: template.entityName,
+                payloadType: "template",
+                aliases: Object.freeze([templateFqn, `${template.moduleName}:${template.entityName}`, template.entityName]),
+                templateFqn,
+                choices: Object.freeze([...template.choices.entries()].map(([choice, consuming]) => Object.freeze({
+                    choice,
+                    consuming,
+                    aliases: Object.freeze([`${templateFqn}:${choice}`, `${template.moduleName}:${template.entityName}:${choice}`, `${template.entityName}:${choice}`, choice]),
+                    choiceFqn: `${templateFqn}:${choice}`,
+                })).sort((left, right) => left.choice.localeCompare(right.choice))),
+            });
+        })),
     })));
 }
 function compareTemplateMetadata(left, right) {
@@ -298,7 +350,6 @@ function normalizeGrpcPackageMetadataUnsafe(packages) {
     }
     const packageValues = Array.from(packages);
     const packageIds = new Set();
-    const packageNameVersions = new Set();
     const normalized = [];
     for (const pkg of packageValues) {
         if (pkg === null || typeof pkg !== "object") {
@@ -313,11 +364,10 @@ function normalizeGrpcPackageMetadataUnsafe(packages) {
             throw new ValidationError(`gRPC query has duplicate package metadata ${packageId}`);
         }
         packageIds.add(packageId);
-        const nameVersion = `${packageName}\u0000${packageVersion}`;
-        if (packageNameVersions.has(nameVersion)) {
-            throw new ValidationError(`gRPC query has duplicate package metadata ${packageName}@${packageVersion}`);
-        }
-        packageNameVersions.add(nameVersion);
+        // Same name+version under two different ids is NOT rejected: package ids are content-addressed, so a
+        // recompiled or re-uploaded DAR legitimately reappears with a new id and an unchanged manifest. The
+        // name-derived canonical rows go through deduplicateCanonicalRows, which throws on any genuine
+        // metadata conflict for one canonical key — the only conflict that would actually matter.
         const templatesValue = value.templates;
         if (!Array.isArray(templatesValue)) {
             throw new ValidationError(`gRPC query package ${packageId} templates are invalid`);
@@ -563,12 +613,19 @@ function identitiesFor(event) {
 }
 function typeIdentityRows(event, registry) {
     const template = requiredTemplate(event.templateId, "event template");
-    const contract = { pk: registry.get(contractIdentity(template)), templateId: copyTemplate(template), packageId: template.packageId };
+    const contract = { pk: registry.get(contractIdentity(template)), templateId: copyTemplate(template), packageId: template.packageId, packageName: event.packageName };
     if (!isExercised(event)) {
         return [contract];
     }
     const owner = exerciseOwner(event);
-    return [contract, { pk: registry.get(exerciseIdentity(owner, event.choice, event.consuming)), templateId: copyTemplate(owner), packageId: owner.packageId, choice: event.choice, consuming: event.consuming }];
+    return [contract, {
+            pk: registry.get(exerciseIdentity(owner, event.choice, event.consuming)),
+            templateId: copyTemplate(owner),
+            packageId: owner.packageId,
+            ...(event.interfaceId === undefined ? { packageName: event.packageName } : {}),
+            choice: event.choice,
+            consuming: event.consuming,
+        }];
 }
 function activeContractEntries(responses) {
     const entries = responses.map((response) => {

package/dist/transports/grpc/mappers/contracts-mapper.d.ts

@@ -1,10 +1,17 @@
 import { QueryContractsResponse } from "../../../core/types/responses/query-contracts-response.js";
 import { GetActiveContractsPageRequest } from "../generated/canton/com/daml/ledger/api/v2/state_service.js";
+/** A fully qualified template reference; packageId is a concrete package id or a "#package-name" reference. */
+export interface GrpcQueryTemplateRef {
+    readonly packageId: string;
+    readonly moduleName: string;
+    readonly entityName: string;
+}
 export declare function mapGrpcQueryContractsRequest(request: {
     party?: string;
     parties?: readonly string[];
     allParties?: boolean;
     templateId?: string;
+    templateRefs?: readonly GrpcQueryTemplateRef[];
     interfaceId?: string;
     includeInterfaceView?: boolean;
     includeCreatedEventBlob?: boolean;

package/dist/transports/grpc/mappers/contracts-mapper.js

@@ -52,6 +52,17 @@ function createFilters(request) {
             },
         });
     }
+    for (const ref of request.templateRefs ?? []) {
+        cumulative.push({
+            identifierFilter: {
+                oneofKind: "templateFilter",
+                templateFilter: {
+                    templateId: { packageId: ref.packageId, moduleName: ref.moduleName, entityName: ref.entityName },
+                    includeCreatedEventBlob,
+                },
+            },
+        });
+    }
     if (request.interfaceId) {
         cumulative.push({
             identifierFilter: {

package/package.json

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