@distrohelena/canton-typescript-sdk 0.1.4 → 0.1.6

package/dist/debugger/replay/replay-artifact-resolver.js

@@ -0,0 +1,210 @@
+import { createHash } from "node:crypto";
+import { GetDarRequest } from "../../core/types/requests/get-dar-request.js";
+import { GetPackageReferencesRequest } from "../../core/types/requests/get-package-references-request.js";
+import { DarArchiveLoader } from "../../daml-lf/container/dar-archive-loader.js";
+import { DamlLfPackageLoader } from "../../daml-lf/daml-lf-package-loader.js";
+import { DarSourceBundleLoader } from "../../daml-lf/container/dar-source-bundle-loader.js";
+import { DamlLfArchiveException } from "../../daml-lf/errors/daml-lf-archive.exception.js";
+import { DarSourceMapMetadata } from "../source/dar-source-map-metadata.js";
+import { ReplayMissingSourceException } from "../errors/replay-missing-source.exception.js";
+export class ReplayArtifactResolver {
+    dependencies;
+    archiveLoader = new DarArchiveLoader();
+    packageLoader = new DamlLfPackageLoader();
+    sourceBundleLoader = new DarSourceBundleLoader();
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    async resolveAsync(requiredPackageIds) {
+        const pending = [...requiredPackageIds];
+        const replayPackageIds = new Set();
+        const seenPackageIds = new Set();
+        const resolvedDars = new Map();
+        const packageFingerprints = new Map();
+        const candidateByDarMainPackageId = new Map();
+        const darMainPackageIdByContainedPackageId = new Map();
+        while (pending.length > 0) {
+            const packageId = pending.shift();
+            if (packageId === undefined || seenPackageIds.has(packageId)) {
+                continue;
+            }
+            seenPackageIds.add(packageId);
+            let candidate;
+            const knownDarMainPackageId = darMainPackageIdByContainedPackageId.get(packageId);
+            if (knownDarMainPackageId !== undefined) {
+                candidate =
+                    candidateByDarMainPackageId.get(knownDarMainPackageId);
+            }
+            if (candidate === undefined) {
+                const references = await this.dependencies.participantPackageService.getPackageReferencesAsync(new GetPackageReferencesRequest({
+                    packageId,
+                }));
+                candidate =
+                    await this.resolveSourceMappedDarCandidateOrThrowAsync(packageId, references.dars, packageFingerprints, candidateByDarMainPackageId);
+            }
+            resolvedDars.set(candidate.dar.main, candidate.dar);
+            for (const containedPackageId of candidate.containedPackageIds) {
+                replayPackageIds.add(containedPackageId);
+                darMainPackageIdByContainedPackageId.set(containedPackageId, candidate.dar.main);
+            }
+            for (const importedPackageId of candidate.importedPackageIds) {
+                if (!seenPackageIds.has(importedPackageId)) {
+                    pending.push(importedPackageId);
+                }
+            }
+        }
+        return {
+            dars: [...resolvedDars.values()],
+            packageIds: [...replayPackageIds.values()],
+        };
+    }
+    static createFingerprint(sourceFiles, executables) {
+        return createHash("sha256")
+            .update(JSON.stringify({
+            sourceFiles,
+            executables,
+        }))
+            .digest("hex");
+    }
+    async resolveSourceMappedDarCandidateOrThrowAsync(packageId, dars, packageFingerprints, candidateByDarMainPackageId) {
+        let selectedCandidate;
+        let missingSourceMapError;
+        for (const dar of dars) {
+            const cachedCandidate = candidateByDarMainPackageId.get(dar.main);
+            if (cachedCandidate !== undefined) {
+                if (selectedCandidate === undefined) {
+                    selectedCandidate = cachedCandidate;
+                }
+                continue;
+            }
+            const response = await this.dependencies.participantPackageService.getDarAsync(new GetDarRequest({
+                mainPackageId: dar.main,
+            }));
+            try {
+                const archive = await this.archiveLoader.loadDarOrThrowAsync(response.payload);
+                const bundle = await this.sourceBundleLoader.loadSourceBundleOrThrowAsync(response.payload);
+                const metadata = new DarSourceMapMetadata(bundle.metadata);
+                const metadataPackageId = metadata.packageId ?? packageId;
+                const fingerprint = ReplayArtifactResolver.createFingerprint(bundle.sourceFiles.map((file) => ({
+                    path: file.path,
+                    content: file.content,
+                })), metadata.executables);
+                const previousFingerprint = packageFingerprints.get(metadataPackageId);
+                if (previousFingerprint !== undefined &&
+                    previousFingerprint !== fingerprint) {
+                    throw new ReplayMissingSourceException(`conflicting dar provenance for package '${metadataPackageId}'`);
+                }
+                packageFingerprints.set(metadataPackageId, fingerprint);
+                if (selectedCandidate === undefined) {
+                    const debugPackageIds = new Set(archive.packageEntries
+                        .filter((entry) => entry.path.endsWith("/data/debug-locations.dalf"))
+                        .flatMap((entry) => {
+                        try {
+                            return [
+                                this.packageLoader.loadRawPackageOrThrow(entry.bytes).packageId,
+                            ];
+                        }
+                        catch {
+                            return [];
+                        }
+                    }));
+                    const packageGraph = this.readPackageGraph(archive.packageEntries.map((entry) => entry.bytes), metadataPackageId);
+                    selectedCandidate = {
+                        dar,
+                        metadata,
+                        containedPackageIds: packageGraph.containedPackageIds.filter((containedPackageId) => !debugPackageIds.has(containedPackageId)),
+                        importedPackageIds: [
+                            ...new Set([
+                                ...metadata.importedPackages,
+                                ...packageGraph.importedPackageIds.filter((importedPackageId) => !debugPackageIds.has(importedPackageId)),
+                            ]),
+                        ],
+                    };
+                    candidateByDarMainPackageId.set(dar.main, selectedCandidate);
+                }
+            }
+            catch (error) {
+                if (error instanceof DamlLfArchiveException &&
+                    error.message.includes("debug/source-map.json")) {
+                    missingSourceMapError ??= error;
+                    continue;
+                }
+                throw error;
+            }
+        }
+        if (selectedCandidate !== undefined) {
+            return selectedCandidate;
+        }
+        if (missingSourceMapError !== undefined) {
+            throw missingSourceMapError;
+        }
+        throw new ReplayMissingSourceException(`missing source-mapped dar for package '${packageId}'`);
+    }
+    readPackageGraph(packageArchives, fallbackPackageId) {
+        const containedPackageIds = new Set([fallbackPackageId]);
+        const importedPackageIds = new Set();
+        for (const packageArchive of packageArchives) {
+            try {
+                const packageLoadResult = this.packageLoader.loadRawPackageOrThrow(packageArchive);
+                containedPackageIds.add(packageLoadResult.packageId);
+                for (const importedPackageId of this.readImportedPackageIds(packageLoadResult.rawPackage)) {
+                    if (importedPackageId !== packageLoadResult.packageId) {
+                        importedPackageIds.add(importedPackageId);
+                    }
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return {
+            containedPackageIds: [...containedPackageIds.values()],
+            importedPackageIds: [...importedPackageIds.values()],
+        };
+    }
+    readImportedPackageIds(rawPackage) {
+        const importedPackageIds = new Set();
+        const visited = new Set();
+        const visit = (value) => {
+            if (value === null || typeof value !== "object") {
+                return;
+            }
+            if (visited.has(value)) {
+                return;
+            }
+            visited.add(value);
+            const importedPackageId = this.tryResolveImportedPackageId(rawPackage, value);
+            if (importedPackageId !== undefined) {
+                importedPackageIds.add(importedPackageId);
+            }
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    visit(item);
+                }
+                return;
+            }
+            for (const child of Object.values(value)) {
+                visit(child);
+            }
+        };
+        visit(rawPackage);
+        return [...importedPackageIds.values()];
+    }
+    tryResolveImportedPackageId(rawPackage, value) {
+        const candidate = value;
+        if (candidate.sum?.oneofKind === "importedPackageIdInternedStr") {
+            const index = candidate.sum.importedPackageIdInternedStr;
+            return index === undefined
+                ? undefined
+                : rawPackage.internedStrings[index];
+        }
+        if (candidate.sum?.oneofKind === "packageImportId" &&
+            rawPackage.importsSum?.oneofKind === "packageImports") {
+            const index = candidate.sum.packageImportId;
+            return index === undefined
+                ? undefined
+                : rawPackage.importsSum.packageImports?.importedPackages[index];
+        }
+        return undefined;
+    }
+}

package/dist/debugger/replay/replay-determinism-validator.d.ts

@@ -0,0 +1,12 @@
+import { IDamlLfReplayEffect } from "../../daml-lf/interpreter/daml-lf-trace-sink.interface.js";
+import { IReplayTransactionSnapshot } from "./ledger-replay-environment-builder.js";
+export declare class ReplayDeterminismValidator {
+    validateOrThrow(snapshot: IReplayTransactionSnapshot, replayedEffects: readonly IDamlLfReplayEffect[]): void;
+    private collectObservedEffects;
+    private collectComparableReplayedEffects;
+    private serializeEffect;
+    private effectsEqual;
+    private normalizeComparableContractId;
+    private valuesEqual;
+    private normalizeComparableValue;
+}

package/dist/debugger/replay/replay-determinism-validator.js

@@ -0,0 +1,161 @@
+import { DAML_LF_NUMERIC_MARKER_KEY, DAML_LF_PARTY_MARKER_KEY, DAML_LF_RECORD_ID_MARKER_KEY, } from "../../daml-lf/interpreter/daml-lf-runtime-value.js";
+import { ReplayDeterminismException } from "../errors/replay-determinism.exception.js";
+import { normalizeReplayLedgerValue } from "./replay-ledger-value-normalizer.js";
+export class ReplayDeterminismValidator {
+    validateOrThrow(snapshot, replayedEffects) {
+        const observedEffects = this.collectObservedEffects(snapshot);
+        const comparableReplayedEffects = this.collectComparableReplayedEffects(replayedEffects);
+        const syntheticCreateContractIds = new Map();
+        let createIndex = 0;
+        if (observedEffects.length !== comparableReplayedEffects.length) {
+            throw new ReplayDeterminismException(`replay produced ${comparableReplayedEffects.length} effects, but the ledger update exposed ${observedEffects.length}`);
+        }
+        for (const [index, observedEffect] of observedEffects.entries()) {
+            const replayedEffect = comparableReplayedEffects[index];
+            if (replayedEffect === undefined
+                || !this.effectsEqual(observedEffect, replayedEffect, syntheticCreateContractIds)) {
+                throw new ReplayDeterminismException(`replay diverged from the observed ledger effects at index ${index}: observed=${this.serializeEffect(observedEffect)} replayed=${replayedEffect === undefined ? "undefined" : this.serializeEffect(replayedEffect)}`);
+            }
+            if (observedEffect.kind === "create"
+                && observedEffect.contractId !== undefined) {
+                createIndex += 1;
+                syntheticCreateContractIds.set(`created-${createIndex}`, observedEffect.contractId);
+            }
+        }
+    }
+    collectObservedEffects(snapshot) {
+        return snapshot.events.flatMap((event) => {
+            switch (event.event?.oneofKind) {
+                case "created":
+                    return [
+                        {
+                            kind: "create",
+                            contractId: event.event.created?.contractId,
+                            templateId: event.event.created?.templateId,
+                            payload: normalizeReplayLedgerValue(event.event.created?.createArguments),
+                        },
+                    ];
+                case "exercised":
+                    return [
+                        {
+                            kind: "exercise",
+                            contractId: event.event.exercised?.contractId,
+                            templateId: event.event.exercised?.templateId,
+                            choice: event.event.exercised?.choice,
+                            argument: normalizeReplayLedgerValue(event.event.exercised?.choiceArgument),
+                        },
+                    ];
+                case "archived":
+                    return [
+                        {
+                            kind: "archive",
+                            contractId: event.event.archived?.contractId,
+                            templateId: event.event.archived?.templateId,
+                        },
+                    ];
+                default:
+                    return [];
+            }
+        });
+    }
+    collectComparableReplayedEffects(replayedEffects) {
+        return replayedEffects.filter((effect) => effect.kind === "create"
+            || effect.kind === "exercise"
+            || effect.kind === "archive");
+    }
+    serializeEffect(effect) {
+        return JSON.stringify({
+            kind: effect.kind,
+            contractId: effect.kind === "create" ? undefined : effect.contractId,
+            templateId: effect.templateId,
+            choice: effect.choice,
+            argument: this.normalizeComparableValue(effect.argument),
+            payload: this.normalizeComparableValue(effect.payload),
+        });
+    }
+    effectsEqual(left, right, syntheticCreateContractIds) {
+        return (left.kind === right.kind
+            && this.normalizeComparableContractId(left.kind, left.contractId, syntheticCreateContractIds)
+                === this.normalizeComparableContractId(right.kind, right.contractId, syntheticCreateContractIds)
+            && this.valuesEqual(left.templateId, right.templateId)
+            && left.choice === right.choice
+            && this.valuesEqual(this.normalizeComparableValue(left.argument), this.normalizeComparableValue(right.argument))
+            && this.valuesEqual(this.normalizeComparableValue(left.payload), this.normalizeComparableValue(right.payload)));
+    }
+    normalizeComparableContractId(kind, contractId, syntheticCreateContractIds) {
+        if (kind === "create") {
+            return undefined;
+        }
+        return contractId === undefined
+            ? undefined
+            : syntheticCreateContractIds.get(contractId) ?? contractId;
+    }
+    valuesEqual(left, right) {
+        if (Array.isArray(left) || Array.isArray(right)) {
+            return (Array.isArray(left)
+                && Array.isArray(right)
+                && left.length === right.length
+                && left.every((item, index) => this.valuesEqual(item, right[index])));
+        }
+        if (left !== null
+            && right !== null
+            && typeof left === "object"
+            && typeof right === "object") {
+            const leftEntries = Object.entries(left);
+            const rightEntries = Object.entries(right);
+            const leftKeys = leftEntries.map(([key]) => key);
+            const rightKeys = rightEntries.map(([key]) => key);
+            const leftIsPositional = leftKeys.every((key) => /^\d+$/.test(key));
+            const rightIsPositional = rightKeys.every((key) => /^\d+$/.test(key));
+            if (leftIsPositional !== rightIsPositional) {
+                const positionalEntries = leftIsPositional ? leftEntries : rightEntries;
+                const namedEntries = leftIsPositional ? rightEntries : leftEntries;
+                return (positionalEntries.length === namedEntries.length
+                    && positionalEntries
+                        .sort(([leftKey], [rightKey]) => Number(leftKey) - Number(rightKey))
+                        .every(([, value], index) => this.valuesEqual(value, namedEntries[index]?.[1])));
+            }
+            const leftSortedKeys = [...leftKeys].sort();
+            const rightSortedKeys = [...rightKeys].sort();
+            return (leftSortedKeys.length === rightSortedKeys.length
+                && leftSortedKeys.every((key, index) => key === rightSortedKeys[index])
+                && leftSortedKeys.every((key) => this.valuesEqual(left[key], right[key])));
+        }
+        return Object.is(left, right);
+    }
+    normalizeComparableValue(value) {
+        if (typeof value === "string"
+            && /^-?\d+\.\d+$/.test(value)) {
+            const normalizedValue = value
+                .replace(/(\.\d*?[1-9])0+$/, "$1")
+                .replace(/\.0+$/, "");
+            return normalizedValue === "-0" ? "0" : normalizedValue;
+        }
+        if (Array.isArray(value)) {
+            return value.map((item) => this.normalizeComparableValue(item));
+        }
+        if (value !== null
+            && typeof value === "object"
+            && DAML_LF_NUMERIC_MARKER_KEY in value
+            && typeof value[DAML_LF_NUMERIC_MARKER_KEY] === "string") {
+            return this.normalizeComparableValue(value[DAML_LF_NUMERIC_MARKER_KEY]);
+        }
+        if (value !== null
+            && typeof value === "object"
+            && DAML_LF_PARTY_MARKER_KEY in value
+            && typeof value[DAML_LF_PARTY_MARKER_KEY] === "string") {
+            return value[DAML_LF_PARTY_MARKER_KEY];
+        }
+        if (value !== null && typeof value === "object") {
+            return Object.fromEntries(Object.entries(value)
+                .filter(([key, item]) => key !== DAML_LF_RECORD_ID_MARKER_KEY
+                && item !== null
+                && item !== undefined)
+                .map(([key, item]) => [
+                key,
+                this.normalizeComparableValue(item),
+            ]));
+        }
+        return value;
+    }
+}

package/dist/debugger/replay/replay-entrypoint-definition-resolver.d.ts

@@ -0,0 +1,40 @@
+import { DamlLfExpression } from "../../daml-lf/model/daml-lf-expression.js";
+import { DamlLfValueDefinition } from "../../daml-lf/model/daml-lf-value-definition.js";
+import { DamlLfTemplateId } from "../../daml-lf/model/daml-lf-template-id.js";
+import { SourceIndexedCompilation } from "../source/source-indexed-compilation.js";
+import { ReplayEntrypoint } from "./replay-entrypoint.js";
+export interface ResolvedReplayEntrypointDefinition {
+    packageId: string;
+    moduleName: string;
+    definition: DamlLfValueDefinition;
+    entrypointArgumentRecordId?: {
+        packageId: string;
+        moduleName: string;
+        entityName: string;
+    };
+    frameIdentity?: {
+        packageId: string;
+        moduleName: string;
+    };
+    replayExpression: DamlLfExpression;
+    replayBindingMode: "standard" | "createWrapper" | "exerciseWrapper" | "templateChoice";
+}
+export declare class ReplayEntrypointDefinitionResolver {
+    private readonly indexedCompilation;
+    constructor(indexedCompilation: SourceIndexedCompilation);
+    resolveEntrypointDefinitionOrThrow(entrypoint: ReplayEntrypoint): ResolvedReplayEntrypointDefinition;
+    private resolveChoiceArgumentRecordId;
+    resolveChoiceDefinitionOrThrow(templateId: DamlLfTemplateId, choiceName: string): ResolvedReplayEntrypointDefinition;
+    private resolveReplayStrategy;
+    private resolveChoiceReplayExpression;
+    private resolveChoiceReplayStrategy;
+    private findExerciseSource;
+    private findExerciseSourceOrThrow;
+    private matchesTemplate;
+    private unwrapReplayExpression;
+    private resolveReplayBindingMode;
+    private shouldPreferTemplateChoiceExpression;
+    private normalizeCurriedChoiceExpression;
+    private wrapChoiceArgumentEnvelope;
+    private extractTrailingLambda;
+}