@distrohelena/canton-typescript-sdk 0.1.35 → 0.1.37

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryRelationMetadata = exports.queryRelationEdges = exports.queryRelations = void 0;
+exports.queryRelations = [
+    "contracts",
+    "contractTypes",
+    "events",
+    "exercises",
+    "exerciseTypes",
+    "packages",
+    "transactions",
+    "watermark",
+];
+exports.queryRelationEdges = {
+    contracts: {
+        contractType: { target: "contractTypes", cardinality: "one", nullable: false },
+        createdTransaction: { target: "transactions", cardinality: "one", nullable: false },
+        archivedTransaction: { target: "transactions", cardinality: "one", nullable: true },
+        exercises: { target: "exercises", cardinality: "many", nullable: false },
+    },
+    contractTypes: {
+        contracts: { target: "contracts", cardinality: "many", nullable: false },
+        exercises: { target: "exercises", cardinality: "many", nullable: false },
+    },
+    events: {
+        transaction: { target: "transactions", cardinality: "one", nullable: false },
+        exercises: { target: "exercises", cardinality: "many", nullable: false },
+    },
+    exercises: {
+        exerciseType: { target: "exerciseTypes", cardinality: "one", nullable: false },
+        contractType: { target: "contractTypes", cardinality: "one", nullable: false },
+        event: { target: "events", cardinality: "one", nullable: true },
+        transaction: { target: "transactions", cardinality: "one", nullable: true },
+        package: { target: "packages", cardinality: "one", nullable: false },
+        contract: { target: "contracts", cardinality: "one", nullable: true },
+    },
+    exerciseTypes: { exercises: { target: "exercises", cardinality: "many", nullable: false } },
+    packages: { exercises: { target: "exercises", cardinality: "many", nullable: false } },
+    transactions: {
+        events: { target: "events", cardinality: "many", nullable: false },
+        createdContracts: { target: "contracts", cardinality: "many", nullable: false },
+        archivedContracts: { target: "contracts", cardinality: "many", nullable: false },
+        exercises: { target: "exercises", cardinality: "many", nullable: false },
+    },
+};
+exports.queryRelationMetadata = {
+    contracts: {
+        fields: ["contractId", "templateId", "packageId", "payload", "witnesses", "createdEventOffset", "createdAt", "archivedEventOffset", "archivedAt", "active"],
+        uniqueKeys: [["contractId"]], stableOrder: ["contractId"],
+        orderFields: ["contractId", "createdEventOffset", "createdAt", "archivedEventOffset", "archivedAt"],
+        groupFields: ["contractId", "createdEventOffset", "createdAt", "archivedEventOffset", "archivedAt", "witnesses"],
+        numericFields: ["createdEventOffset", "archivedEventOffset"], arrayFields: ["witnesses"], dateFields: ["createdAt", "archivedAt"], binaryFields: [], booleanFields: ["active"], nullableFields: ["packageId", "createdAt", "archivedEventOffset", "archivedAt"], stringFields: ["contractId", "packageId"], jsonFields: ["payload"], bucketFields: [],
+    },
+    contractTypes: {
+        fields: ["pk", "payloadType", "aliases", "packageName", "moduleName", "entityName", "templateFqn"],
+        uniqueKeys: [["pk"]], stableOrder: ["pk"], orderFields: ["pk", "payloadType", "aliases", "packageName", "moduleName", "entityName", "templateFqn"], groupFields: ["pk", "payloadType", "aliases", "packageName", "moduleName", "entityName", "templateFqn"],
+        numericFields: ["pk"], arrayFields: ["aliases"], dateFields: [], binaryFields: [], booleanFields: [], nullableFields: [], stringFields: ["payloadType", "packageName", "moduleName", "entityName", "templateFqn"], jsonFields: [], bucketFields: [],
+    },
+    events: {
+        fields: ["pk", "txIx", "eventId", "type"], uniqueKeys: [["pk"]], stableOrder: ["pk"], orderFields: ["pk", "txIx", "eventId", "type"], groupFields: ["pk", "txIx", "eventId", "type"],
+        numericFields: ["pk", "txIx"], arrayFields: [], dateFields: [], binaryFields: [], booleanFields: [], nullableFields: [], stringFields: ["eventId", "type"], jsonFields: [], bucketFields: [],
+    },
+    exercises: {
+        fields: ["tpePk", "contractTpePk", "exerciseEventPk", "exercisedAtIx", "contractId", "argument", "result", "redactionId", "packagePk", "controllers", "lastDescendantNodeId", "witnesses"],
+        uniqueKeys: [], stableOrder: ["tpePk", "contractTpePk", "exerciseEventPk", "contractId"], orderFields: ["tpePk", "contractTpePk", "exerciseEventPk", "exercisedAtIx", "contractId", "argument", "result", "redactionId", "packagePk", "controllers", "lastDescendantNodeId", "witnesses"], groupFields: ["tpePk", "contractTpePk", "exerciseEventPk", "exercisedAtIx", "contractId", "argument", "result", "redactionId", "packagePk", "controllers", "lastDescendantNodeId", "witnesses"],
+        numericFields: ["tpePk", "contractTpePk", "exerciseEventPk", "exercisedAtIx", "packagePk", "lastDescendantNodeId"], arrayFields: ["controllers", "witnesses"], dateFields: [], binaryFields: [], booleanFields: [], nullableFields: ["exerciseEventPk", "exercisedAtIx", "redactionId"], stringFields: ["contractId", "redactionId"], jsonFields: ["argument", "result"], bucketFields: [],
+    },
+    exerciseTypes: {
+        fields: ["pk", "choice", "consuming", "aliases", "packageName", "moduleName", "entityName", "templateFqn", "choiceFqn"],
+        uniqueKeys: [["pk"]], stableOrder: ["pk"], orderFields: ["pk", "choice", "consuming", "aliases", "packageName", "moduleName", "entityName", "templateFqn", "choiceFqn"], groupFields: ["pk", "choice", "consuming", "aliases", "packageName", "moduleName", "entityName", "templateFqn", "choiceFqn"],
+        numericFields: ["pk"], arrayFields: ["aliases"], dateFields: [], binaryFields: [], booleanFields: ["consuming"], nullableFields: [], stringFields: ["choice", "packageName", "moduleName", "entityName", "templateFqn", "choiceFqn"], jsonFields: [], bucketFields: [],
+    },
+    packages: {
+        fields: ["pk", "name", "version", "id"], uniqueKeys: [["pk"], ["id"]], stableOrder: ["pk"], orderFields: ["pk", "name", "version", "id"], groupFields: ["pk", "name", "version", "id"],
+        numericFields: ["pk"], arrayFields: [], dateFields: [], binaryFields: [], booleanFields: [], nullableFields: [], stringFields: ["name", "version", "id"], jsonFields: [], bucketFields: [],
+    },
+    transactions: {
+        fields: ["ix", "offset", "transactionId", "effectiveAt", "workflowId", "domainId", "traceContext", "externalTransactionHash", "paidTrafficCost"],
+        uniqueKeys: [["ix"], ["offset"]], stableOrder: ["ix"], orderFields: ["ix", "offset", "transactionId", "effectiveAt", "workflowId", "domainId", "traceContext", "externalTransactionHash", "paidTrafficCost"], groupFields: ["ix", "offset", "transactionId", "effectiveAt", "workflowId", "domainId", "traceContext", "externalTransactionHash", "paidTrafficCost"],
+        numericFields: ["ix", "offset", "paidTrafficCost"], arrayFields: [], dateFields: ["effectiveAt"], binaryFields: ["externalTransactionHash"], booleanFields: [], nullableFields: ["transactionId", "effectiveAt", "workflowId", "domainId", "traceContext", "externalTransactionHash", "paidTrafficCost"], stringFields: ["transactionId", "workflowId", "domainId"], jsonFields: ["traceContext"], bucketFields: ["effectiveAt"],
+    },
+    watermark: {
+        fields: ["singleton", "ix", "offset", "instanceId"], uniqueKeys: [["singleton"]], stableOrder: ["singleton"], orderFields: ["singleton", "ix", "offset", "instanceId"], groupFields: ["singleton", "ix", "offset", "instanceId"],
+        numericFields: ["ix", "offset"], arrayFields: [], dateFields: [], binaryFields: [], booleanFields: ["singleton"], nullableFields: ["ix", "offset", "instanceId"], stringFields: ["instanceId"], jsonFields: [], bucketFields: [],
+    },
+};

package/dist/cjs/query/canton-manager.js

@@ -4,7 +4,8 @@ exports.CantonManager = void 0;
 const canton_client_js_1 = require("../client/canton-client.js");
 const transport_kind_js_1 = require("../core/types/transport-kind.js");
 const validation_error_js_1 = require("../core/errors/validation-error.js");
-const grpc_contract_query_client_js_1 = require("./grpc/grpc-contract-query-client.js");
+const grpc_query_client_js_1 = require("./grpc/grpc-query-client.js");
+const grpc_contract_cache_js_1 = require("./grpc/grpc-contract-cache.js");
 const pqs_pool_js_1 = require("./pqs/pqs-pool.js");
 const pqs_query_client_js_1 = require("./pqs/pqs-query-client.js");
 const pqs_schema_profile_js_1 = require("./pqs/pqs-schema-profile.js");
@@ -18,12 +19,12 @@ class CantonManager {
         if (options.grpc.transportKind !== transport_kind_js_1.TransportKind.grpc) {
             throw new validation_error_js_1.ValidationError("CantonManager requires grpc transport for writes.");
         }
-        else if (options.querySource === query_source_js_1.QuerySource.grpc && options.pqs !== undefined) {
-            throw new validation_error_js_1.ValidationError("PQS options require QuerySource.pqs.");
-        }
         else if (options.querySource === query_source_js_1.QuerySource.pqs && options.pqs === undefined) {
             throw new validation_error_js_1.ValidationError("QuerySource.pqs requires PQS options.");
         }
+        else if (options.cache !== undefined && (!Number.isFinite(options.cache.ttlMs) || options.cache.ttlMs <= 0)) {
+            throw new validation_error_js_1.ValidationError("CantonManager cache ttlMs must be a positive finite number.");
+        }
         this.grpc = new canton_client_js_1.CantonClient(options.grpc);
         if (options.querySource === query_source_js_1.QuerySource.pqs) {
             this.pqsPool = pqs_pool_js_1.PqsPool.create(options.pqs.connectionString);
@@ -31,7 +32,15 @@ class CantonManager {
             this.query = new pqs_query_client_js_1.PqsQueryClient(this.pqsPool.pool, profile, (0, pqs_schema_profile_js_1.validatePqsSchemaAsync)(this.pqsPool.pool, profile));
         }
         else {
-            this.query = new grpc_contract_query_client_js_1.GrpcContractQueryClient(this.grpc.stateService, options.cache?.store, options.cache?.ttlMs, options.grpc.ledgerEndpoint ?? "ledger");
+            this.query = new grpc_query_client_js_1.GrpcQueryClient({
+                stateService: this.grpc.stateService,
+                updateService: this.grpc.updateService,
+                packageService: this.grpc.packageService,
+                endpointScope: options.grpc.ledgerEndpoint ?? "ledger",
+                contractCache: options.cache === undefined
+                    ? undefined
+                    : new grpc_contract_cache_js_1.GrpcContractCache(this.grpc.stateService, options.cache.store, options.cache.ttlMs, options.grpc.ledgerEndpoint ?? "ledger"),
+            });
         }
     }
     async disposeAsync() {

package/dist/cjs/query/errors/query-snapshot-incomplete-error.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuerySnapshotIncompleteError = void 0;
+const canton_error_js_1 = require("../../core/errors/canton-error.js");
+class QuerySnapshotIncompleteError extends canton_error_js_1.CantonError {
+    beginExclusive;
+    endInclusive;
+    activeAtOffset;
+    reason;
+    constructor(init) {
+        super(`gRPC query snapshot is incomplete: ${init.reason}.`);
+        this.beginExclusive = init.beginExclusive;
+        this.endInclusive = init.endInclusive;
+        this.activeAtOffset = init.activeAtOffset;
+        this.reason = init.reason;
+        Object.freeze(this);
+    }
+}
+exports.QuerySnapshotIncompleteError = QuerySnapshotIncompleteError;

package/dist/cjs/query/grpc/grpc-contract-cache.js

@@ -0,0 +1,484 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcContractCache = void 0;
+exports.normalizeParties = normalizeParties;
+const types_1 = require("node:util/types");
+const validation_error_js_1 = require("../../core/errors/validation-error.js");
+const contracts_mapper_js_1 = require("../../transports/grpc/mappers/contracts-mapper.js");
+const query_source_js_1 = require("../query-source.js");
+const grpc_relation_mapper_js_1 = require("./grpc-relation-mapper.js");
+const grpc_query_snapshot_reader_js_1 = require("./grpc-query-snapshot-reader.js");
+class GrpcContractCache {
+    stateService;
+    store;
+    ttlMs;
+    endpointScope;
+    now;
+    inflight = new Map();
+    constructor(stateService, store, ttlMs, endpointScope, now = Date.now) {
+        this.stateService = stateService;
+        this.store = store;
+        this.ttlMs = ttlMs;
+        this.endpointScope = endpointScope;
+        this.now = now;
+        if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+            throw new validation_error_js_1.ValidationError("Contract cache ttlMs must be a positive finite number.");
+        }
+    }
+    async cacheContracts(args) {
+        const parties = normalizeParties(args);
+        const key = cacheKey(this.endpointScope, parties);
+        const current = this.inflight.get(key);
+        if (current !== undefined) {
+            return current;
+        }
+        const promise = this.populateAsync(parties, key);
+        this.inflight.set(key, promise);
+        void promise.then(() => this.clearInflight(key, promise), () => this.clearInflight(key, promise));
+        return promise;
+    }
+    async readContractsAsync(args) {
+        const snapshot = await this.readSnapshotAsync(args);
+        return snapshot?.contracts;
+    }
+    async readSnapshotAsync(args) {
+        const parties = normalizeParties(args);
+        const cached = await this.store.getAsync(cacheKey(this.endpointScope, parties));
+        const nowEpochMs = currentEpochMs(this.now);
+        const snapshot = asCompatibleSnapshot(cached, this.endpointScope, parties, nowEpochMs);
+        if (snapshot === undefined) {
+            return undefined;
+        }
+        return Object.freeze({ activeAtOffset: snapshot.activeAtOffset, contracts: snapshot.contracts });
+    }
+    async invalidateContractsCache(args) {
+        const parties = normalizeParties(args);
+        const key = cacheKey(this.endpointScope, parties);
+        try {
+            await this.inflight.get(key);
+        }
+        catch {
+            // A failed prewarm leaves no completed snapshot to preserve.
+        }
+        await this.store.deleteAsync(key);
+    }
+    async populateAsync(parties, key) {
+        const activeContracts = [];
+        const seenPageTokens = new Set();
+        let activeAtOffset;
+        let pageToken;
+        do {
+            const page = materializeActiveContractsPage(await this.stateService.getActiveContractsPageAsync((0, contracts_mapper_js_1.mapGrpcQueryContractsRequest)(parties === undefined
+                ? { allParties: true, activeAtOffset, pageToken }
+                : { parties, activeAtOffset, pageToken })));
+            if (activeAtOffset === undefined) {
+                activeAtOffset = page.activeAtOffset;
+            }
+            else if (activeAtOffset !== page.activeAtOffset) {
+                throw new Error("Active-contracts response activeAtOffset changed during traversal.");
+            }
+            activeContracts.push(...page.activeContracts);
+            pageToken = page.nextPageToken;
+            if (pageToken !== undefined && pageToken.length > 0) {
+                const tokenKey = Array.from(pageToken).join(",");
+                if (seenPageTokens.has(tokenKey)) {
+                    throw new Error("Active-contracts response repeated a page token.");
+                }
+                seenPageTokens.add(tokenKey);
+            }
+        } while (pageToken !== undefined && pageToken.length > 0);
+        const contracts = (0, grpc_relation_mapper_js_1.mapGrpcQueryRelationFragment)([], activeContracts).contracts;
+        const expiresAtEpochMs = effectiveExpiryEpochMs(this.now, this.ttlMs);
+        const result = {
+            source: query_source_js_1.QuerySource.grpc,
+            cached: true,
+            activeAtOffset: activeAtOffset,
+            contractCount: contracts.length,
+            expiresAt: new Date(expiresAtEpochMs),
+        };
+        const snapshot = {
+            version: 1,
+            endpointScope: this.endpointScope,
+            parties,
+            activeAtOffset: activeAtOffset,
+            expiresAtEpochMs,
+            contracts: copyRows(contracts),
+        };
+        await this.store.setAsync(key, snapshot, this.ttlMs);
+        return result;
+    }
+    clearInflight(key, promise) {
+        if (this.inflight.get(key) === promise) {
+            this.inflight.delete(key);
+        }
+    }
+}
+exports.GrpcContractCache = GrpcContractCache;
+function normalizeParties(args) {
+    try {
+        if (args === undefined) {
+            return undefined;
+        }
+        const candidate = args.parties;
+        if (candidate === undefined) {
+            return undefined;
+        }
+        else if (!Array.isArray(candidate)) {
+            throw new validation_error_js_1.ValidationError("Contract cache parties must contain non-empty strings.");
+        }
+        const values = materializeIndexedArray(candidate);
+        if (values === undefined || values.length === 0) {
+            throw new validation_error_js_1.ValidationError("Contract cache parties must contain non-empty strings.");
+        }
+        const parties = values.map((party) => {
+            if (typeof party !== "string" || party.trim().length === 0) {
+                throw new validation_error_js_1.ValidationError("Contract cache parties must contain non-empty strings.");
+            }
+            return party;
+        });
+        return Object.freeze([...new Set(parties)].sort());
+    }
+    catch (error) {
+        if (isValidationError(error)) {
+            throw error;
+        }
+        throw new validation_error_js_1.ValidationError("Contract cache parties must be a non-empty array of strings when provided.");
+    }
+}
+function cacheKey(endpointScope, parties) {
+    return `grpc-contract-cache:v1:${JSON.stringify([endpointScope, parties])}`;
+}
+function asCompatibleSnapshot(value, endpointScope, parties, nowEpochMs) {
+    try {
+        if (value === null || typeof value !== "object") {
+            return undefined;
+        }
+        const candidate = value;
+        const version = candidate.version;
+        const storedEndpointScope = candidate.endpointScope;
+        const rawParties = candidate.parties;
+        const storedParties = rawParties === undefined ? undefined : materializeStringArray(rawParties);
+        const activeAtOffset = candidate.activeAtOffset;
+        const expiresAtEpochMs = candidate.expiresAtEpochMs;
+        const contracts = materializeContractRows(candidate.contracts);
+        if (version !== 1
+            || storedEndpointScope !== endpointScope
+            || (rawParties !== undefined && storedParties === undefined)
+            || !sameParties(storedParties, parties)
+            || typeof nowEpochMs !== "number"
+            || !Number.isFinite(nowEpochMs)
+            || !Number.isFinite(new Date(nowEpochMs).getTime())
+            || !(0, grpc_query_snapshot_reader_js_1.isCanonicalGrpcOffset)(activeAtOffset)
+            || typeof expiresAtEpochMs !== "number"
+            || !Number.isFinite(expiresAtEpochMs)
+            || !Number.isFinite(new Date(expiresAtEpochMs).getTime())
+            || expiresAtEpochMs <= nowEpochMs
+            || contracts === undefined) {
+            return undefined;
+        }
+        return {
+            version,
+            endpointScope: storedEndpointScope,
+            parties: storedParties,
+            activeAtOffset,
+            expiresAtEpochMs,
+            contracts,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function sameParties(left, right) {
+    return left === undefined
+        ? right === undefined
+        : Array.isArray(left)
+            && right !== undefined
+            && left.length === right.length
+            && left.every((party, index) => typeof party === "string" && party === right[index]);
+}
+function materializeActiveContractsPage(value) {
+    try {
+        if (value === null || typeof value !== "object") {
+            throw new Error("Active-contracts response is invalid.");
+        }
+        const candidate = value;
+        const activeAtOffset = candidate.activeAtOffset;
+        if (!(0, grpc_query_snapshot_reader_js_1.isCanonicalGrpcOffset)(activeAtOffset)) {
+            throw new Error("Active-contracts response is missing activeAtOffset.");
+        }
+        const activeContracts = materializeIndexedValues(candidate.activeContracts, materializeActiveContractResponse);
+        if (activeContracts === undefined) {
+            throw new Error("Active-contracts response activeContracts is invalid.");
+        }
+        const nextPageToken = materializePageToken(candidate.nextPageToken);
+        return {
+            activeAtOffset,
+            activeContracts,
+            nextPageToken,
+        };
+    }
+    catch (error) {
+        if (isError(error)) {
+            throw error;
+        }
+        throw new Error("Active-contracts response is invalid.");
+    }
+}
+function materializeActiveContractResponse(value) {
+    const copy = copyValue(value);
+    if (copy === null || typeof copy !== "object") {
+        throw new Error("Active-contracts response contains an invalid contract entry.");
+    }
+    return copy;
+}
+function materializePageToken(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    else if ((0, types_1.isProxy)(value) || !isUint8Array(value)) {
+        throw new Error("Active-contracts response nextPageToken is invalid.");
+    }
+    try {
+        return new Uint8Array(value);
+    }
+    catch {
+        throw new Error("Active-contracts response nextPageToken is invalid.");
+    }
+}
+function materializeContractRows(value) {
+    const rows = materializeIndexedValues(value, materializeContractRow);
+    if (rows === undefined) {
+        return undefined;
+    }
+    return rows.every((row) => row !== undefined) ? rows : undefined;
+}
+function materializeContractRow(value) {
+    if (value === null || typeof value !== "object") {
+        return undefined;
+    }
+    const candidate = value;
+    const contractId = candidate.contractId;
+    const templateId = materializeTemplateId(candidate.templateId);
+    const packageId = candidate.packageId;
+    const payload = copyValue(candidate.payload);
+    const witnesses = materializeStringArray(candidate.witnesses);
+    const createdEventOffset = candidate.createdEventOffset;
+    const createdAt = materializeOptionalDate(candidate.createdAt);
+    const archivedEventOffset = candidate.archivedEventOffset;
+    const archivedAt = candidate.archivedAt;
+    const active = candidate.active;
+    if (typeof contractId !== "string"
+        || templateId === undefined
+        || (typeof packageId !== "string" && packageId !== null)
+        || witnesses === undefined
+        || typeof createdEventOffset !== "string"
+        || createdAt === undefined
+        || archivedEventOffset !== null
+        || archivedAt !== null
+        || active !== true) {
+        return undefined;
+    }
+    return {
+        contractId,
+        templateId,
+        packageId,
+        payload,
+        witnesses,
+        createdEventOffset,
+        createdAt,
+        archivedEventOffset,
+        archivedAt,
+        active,
+    };
+}
+function materializeTemplateId(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const candidate = value;
+    const packageId = candidate.packageId;
+    const moduleName = candidate.moduleName;
+    const entityName = candidate.entityName;
+    return typeof packageId === "string" && typeof moduleName === "string" && typeof entityName === "string"
+        ? { packageId, moduleName, entityName }
+        : undefined;
+}
+function materializeStringArray(value) {
+    const values = materializeIndexedArray(value);
+    if (values === undefined) {
+        return undefined;
+    }
+    return values.every((entry) => typeof entry === "string") ? values : undefined;
+}
+function materializeIndexedArray(value) {
+    return materializeIndexedValues(value, (entry) => entry);
+}
+function materializeIndexedValues(value, materialize) {
+    if ((0, types_1.isProxy)(value) || !Array.isArray(value)) {
+        return undefined;
+    }
+    const length = value.length;
+    if (!Number.isSafeInteger(length) || length < 0) {
+        return undefined;
+    }
+    const values = [];
+    for (let index = 0; index < length; index += 1) {
+        values.push(materialize(value[index]));
+    }
+    return values;
+}
+function materializeOptionalDate(value) {
+    if (value === null) {
+        return null;
+    }
+    else if (!isDate(value)) {
+        return undefined;
+    }
+    const epochMs = value.getTime();
+    return Number.isFinite(epochMs) ? new Date(epochMs) : undefined;
+}
+function copyRows(rows) {
+    return rows.map((row) => ({
+        ...row,
+        templateId: { ...row.templateId },
+        payload: copyValue(row.payload),
+        witnesses: [...row.witnesses],
+        createdAt: row.createdAt === null ? null : new Date(row.createdAt.getTime()),
+        archivedAt: row.archivedAt === null ? null : new Date(row.archivedAt.getTime()),
+    }));
+}
+function copyValue(value) {
+    if (value === undefined || value === null || typeof value !== "object") {
+        return value;
+    }
+    const copy = structuredClone(value);
+    if (containsSharedMemory(copy, new Set())) {
+        throw new Error("Contract payload must not contain shared memory.");
+    }
+    return copy;
+}
+function containsSharedMemory(value, seen) {
+    if (value === null || typeof value !== "object") {
+        return false;
+    }
+    else if (isSharedArrayBuffer(value)) {
+        return true;
+    }
+    else if (seen.has(value)) {
+        return false;
+    }
+    seen.add(value);
+    if (ArrayBuffer.isView(value)) {
+        return isSharedArrayBuffer(value.buffer);
+    }
+    else if (isMap(value)) {
+        for (const [key, entry] of value) {
+            if (containsSharedMemory(key, seen) || containsSharedMemory(entry, seen)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    else if (isSet(value)) {
+        for (const entry of value) {
+            if (containsSharedMemory(entry, seen)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    return Reflect.ownKeys(value).some((key) => containsSharedMemory(Reflect.get(value, key), seen));
+}
+function effectiveExpiryEpochMs(now, ttlMs) {
+    try {
+        const nowEpochMs = currentEpochMs(now);
+        const expiresAtEpochMs = nowEpochMs + ttlMs;
+        if (typeof nowEpochMs !== "number"
+            || !Number.isFinite(nowEpochMs)
+            || !Number.isFinite(expiresAtEpochMs)
+            || !Number.isFinite(new Date(expiresAtEpochMs).getTime())) {
+            throw new validation_error_js_1.ValidationError("Contract cache expiry must be a finite valid date.");
+        }
+        return expiresAtEpochMs;
+    }
+    catch (error) {
+        if (isValidationError(error)) {
+            throw error;
+        }
+        throw new validation_error_js_1.ValidationError("Contract cache expiry must be a finite valid date.");
+    }
+}
+function currentEpochMs(now) {
+    try {
+        const nowEpochMs = now();
+        if (typeof nowEpochMs !== "number"
+            || !Number.isFinite(nowEpochMs)
+            || !Number.isFinite(new Date(nowEpochMs).getTime())) {
+            throw new validation_error_js_1.ValidationError("Contract cache clock must return a finite valid date.");
+        }
+        return nowEpochMs;
+    }
+    catch (error) {
+        if (isValidationError(error)) {
+            throw error;
+        }
+        throw new validation_error_js_1.ValidationError("Contract cache clock must return a finite valid date.");
+    }
+}
+function isValidationError(value) {
+    try {
+        return value instanceof validation_error_js_1.ValidationError;
+    }
+    catch {
+        return false;
+    }
+}
+function isError(value) {
+    try {
+        return value instanceof Error;
+    }
+    catch {
+        return false;
+    }
+}
+function isUint8Array(value) {
+    try {
+        return value instanceof Uint8Array;
+    }
+    catch {
+        return false;
+    }
+}
+function isDate(value) {
+    try {
+        return value instanceof Date;
+    }
+    catch {
+        return false;
+    }
+}
+function isSharedArrayBuffer(value) {
+    try {
+        return typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer;
+    }
+    catch {
+        return false;
+    }
+}
+function isMap(value) {
+    try {
+        return value instanceof Map;
+    }
+    catch {
+        return false;
+    }
+}
+function isSet(value) {
+    try {
+        return value instanceof Set;
+    }
+    catch {
+        return false;
+    }
+}