@distrohelena/canton-typescript-sdk 0.1.4 → 0.1.6

package/dist/debugger/replay/replay-entrypoint-definition-resolver.js

@@ -0,0 +1,337 @@
+import { DamlLfExpression } from "../../daml-lf/model/daml-lf-expression.js";
+import { DamlLfType } from "../../daml-lf/model/daml-lf-type.js";
+import { DamlLfValueDefinition } from "../../daml-lf/model/daml-lf-value-definition.js";
+import { DamlLfTemplateId } from "../../daml-lf/model/daml-lf-template-id.js";
+import { ReplaySourceMapException } from "../errors/replay-source-map.exception.js";
+export class ReplayEntrypointDefinitionResolver {
+    indexedCompilation;
+    constructor(indexedCompilation) {
+        this.indexedCompilation = indexedCompilation;
+    }
+    resolveEntrypointDefinitionOrThrow(entrypoint) {
+        const templateId = entrypoint.templateId;
+        if (templateId?.packageId === undefined
+            || templateId.moduleName === undefined
+            || templateId.entityName === undefined) {
+            throw new ReplaySourceMapException("replay entrypoint is missing template identity for source resolution");
+        }
+        const packageId = templateId.packageId;
+        const moduleName = templateId.moduleName;
+        const templateName = templateId.entityName;
+        const source = entrypoint.kind === "create"
+            ? this.indexedCompilation
+                .getExecutableSources()
+                .find((candidate) => this.matchesTemplate(candidate, {
+                packageId,
+                moduleName,
+                templateName,
+            })
+                && candidate.entrypointKind === "create")
+            : this.findExerciseSourceOrThrow(new DamlLfTemplateId({
+                packageId,
+                moduleName,
+                templateName,
+            }), entrypoint.choice);
+        if (source === undefined) {
+            throw new ReplaySourceMapException(`missing executable metadata for replay entrypoint '${packageId}::${moduleName}::${templateName}'`);
+        }
+        const definition = this.indexedCompilation.compilation.getValueDefinitionOrThrow(source.packageId, source.moduleName, source.definitionName);
+        return {
+            packageId: source.packageId,
+            moduleName: source.moduleName,
+            definition,
+            entrypointArgumentRecordId: entrypoint.kind === "create"
+                ? {
+                    packageId,
+                    moduleName,
+                    entityName: templateName,
+                }
+                : this.resolveChoiceArgumentRecordId(new DamlLfTemplateId({
+                    packageId,
+                    moduleName,
+                    templateName,
+                }), entrypoint.choice),
+            ...this.resolveReplayStrategy(definition.expression, source, entrypoint.kind, entrypoint.kind === "exercise"
+                ? new DamlLfTemplateId({
+                    packageId,
+                    moduleName,
+                    templateName,
+                })
+                : undefined, entrypoint.choice),
+        };
+    }
+    resolveChoiceArgumentRecordId(templateId, choiceName) {
+        if (choiceName === undefined) {
+            return undefined;
+        }
+        try {
+            const template = this.indexedCompilation.compilation
+                .getTemplates()
+                .find((candidate) => candidate.templateId.packageId === templateId.packageId
+                && candidate.templateId.moduleName === templateId.moduleName
+                && candidate.templateId.templateName === templateId.templateName);
+            const choice = template?.choices.find((candidate) => candidate.name === choiceName);
+            const typeConReference = choice?.parameter.type.typeConReference;
+            return typeConReference === undefined
+                ? undefined
+                : {
+                    packageId: typeConReference.packageId,
+                    moduleName: typeConReference.moduleName,
+                    entityName: typeConReference.name,
+                };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    resolveChoiceDefinitionOrThrow(templateId, choiceName) {
+        const choiceReplayExpression = this.resolveChoiceReplayExpression(templateId, choiceName);
+        const source = this.findExerciseSource(templateId, choiceName);
+        if (source === undefined) {
+            if (choiceReplayExpression === undefined) {
+                throw new ReplaySourceMapException(`missing executable metadata for choice '${templateId.packageId}::${templateId.moduleName}::${templateId.templateName}::${choiceName}'`);
+            }
+            return {
+                packageId: templateId.packageId,
+                moduleName: templateId.moduleName,
+                definition: new DamlLfValueDefinition({
+                    name: `${templateId.templateName}$${choiceName}`,
+                    type: new DamlLfType({}),
+                    expression: choiceReplayExpression,
+                }),
+                frameIdentity: {
+                    packageId: templateId.packageId,
+                    moduleName: templateId.moduleName,
+                },
+                replayExpression: choiceReplayExpression,
+                replayBindingMode: "templateChoice",
+            };
+        }
+        const definition = this.indexedCompilation.compilation.getValueDefinitionOrThrow(source.packageId, source.moduleName, source.definitionName);
+        return {
+            packageId: source.packageId,
+            moduleName: source.moduleName,
+            definition,
+            ...this.resolveChoiceReplayStrategy(definition.expression, choiceReplayExpression, source),
+        };
+    }
+    resolveReplayStrategy(expression, source, entrypointKind, templateId, choiceName) {
+        if (entrypointKind === "exercise"
+            && templateId !== undefined
+            && choiceName !== undefined) {
+            const normalizedCurriedChoiceExpression = this.wrapChoiceArgumentEnvelope(this.normalizeCurriedChoiceExpression(expression), source.choiceArgumentFieldName);
+            if (normalizedCurriedChoiceExpression !== undefined) {
+                return {
+                    replayExpression: normalizedCurriedChoiceExpression,
+                    replayBindingMode: "templateChoice",
+                };
+            }
+            const choiceReplayExpression = this.resolveChoiceReplayExpression(templateId, choiceName);
+            if (choiceReplayExpression !== undefined
+                && this.shouldPreferTemplateChoiceExpression(expression, source)) {
+                const replayExpression = this.wrapChoiceArgumentEnvelope(choiceReplayExpression, source.choiceArgumentFieldName);
+                return {
+                    replayExpression: replayExpression ?? choiceReplayExpression,
+                    replayBindingMode: "templateChoice",
+                };
+            }
+        }
+        return {
+            replayExpression: this.unwrapReplayExpression(expression, entrypointKind),
+            replayBindingMode: this.resolveReplayBindingMode(expression, entrypointKind),
+        };
+    }
+    resolveChoiceReplayExpression(templateId, choiceName) {
+        let choices;
+        let templateParameterName;
+        try {
+            const template = this.indexedCompilation.compilation
+                .getTemplates()
+                .find((candidate) => candidate.templateId.packageId === templateId.packageId
+                && candidate.templateId.moduleName === templateId.moduleName
+                && candidate.templateId.templateName === templateId.templateName);
+            if (template === undefined) {
+                return undefined;
+            }
+            choices = template.choices;
+            templateParameterName = template.parameterName;
+        }
+        catch {
+            return undefined;
+        }
+        const choice = choices.find((candidate) => candidate.name === choiceName);
+        if (choice?.updateExpression === undefined) {
+            return undefined;
+        }
+        return new DamlLfExpression({
+            lambda: {
+                parameters: [
+                    choice.selfBinderName,
+                    templateParameterName,
+                    choice.parameter.name,
+                ],
+                body: choice.updateExpression,
+            },
+        });
+    }
+    resolveChoiceReplayStrategy(expression, choiceReplayExpression, source) {
+        const normalizedCurriedChoiceExpression = this.wrapChoiceArgumentEnvelope(this.normalizeCurriedChoiceExpression(expression), source.choiceArgumentFieldName);
+        if (normalizedCurriedChoiceExpression !== undefined) {
+            return {
+                replayExpression: normalizedCurriedChoiceExpression,
+                replayBindingMode: "templateChoice",
+            };
+        }
+        if (choiceReplayExpression !== undefined
+            && this.shouldPreferTemplateChoiceExpression(expression, source)) {
+            const replayExpression = this.wrapChoiceArgumentEnvelope(choiceReplayExpression, source.choiceArgumentFieldName);
+            return {
+                replayExpression: replayExpression ?? choiceReplayExpression,
+                replayBindingMode: "templateChoice",
+            };
+        }
+        return {
+            replayExpression: this.unwrapReplayExpression(expression, "exercise"),
+            replayBindingMode: this.resolveReplayBindingMode(expression, "exercise"),
+        };
+    }
+    findExerciseSource(templateId, choiceName) {
+        return this.indexedCompilation
+            .getExecutableSources()
+            .find((candidate) => this.matchesTemplate(candidate, templateId)
+            && candidate.entrypointKind === "exercise"
+            && candidate.choiceName === choiceName);
+    }
+    findExerciseSourceOrThrow(templateId, choiceName) {
+        const source = this.findExerciseSource(templateId, choiceName);
+        if (source !== undefined) {
+            return source;
+        }
+        throw new ReplaySourceMapException(`missing executable metadata for choice '${templateId.packageId}::${templateId.moduleName}::${templateId.templateName}::${choiceName ?? "<unknown>"}'`);
+    }
+    matchesTemplate(candidate, templateId) {
+        return (candidate.packageId === templateId.packageId
+            && candidate.moduleName === templateId.moduleName
+            && candidate.templateName === templateId.templateName);
+    }
+    unwrapReplayExpression(expression, entrypointKind) {
+        if (expression.recordConstruction === undefined) {
+            return expression;
+        }
+        const wrapperFieldName = entrypointKind === "create" ? "m_create" : "m_exercise";
+        const wrapperField = expression.recordConstruction.fields.find((field) => field.name === wrapperFieldName);
+        return wrapperField?.value ?? expression;
+    }
+    resolveReplayBindingMode(expression, entrypointKind) {
+        if (expression.recordConstruction === undefined) {
+            return "standard";
+        }
+        const wrapperFieldName = entrypointKind === "create" ? "m_create" : "m_exercise";
+        const wrapperField = expression.recordConstruction.fields.find((field) => field.name === wrapperFieldName);
+        const parameters = wrapperField?.value.lambda?.parameters ?? [];
+        if (entrypointKind === "exercise"
+            && parameters.length >= 3
+            && parameters.at(-2) === "this"
+            && parameters.at(-1) === "arg") {
+            return "exerciseWrapper";
+        }
+        if (entrypointKind === "create"
+            && parameters.length >= 2
+            && parameters.at(-1) === "arg") {
+            return "createWrapper";
+        }
+        return "standard";
+    }
+    shouldPreferTemplateChoiceExpression(expression, source) {
+        return (expression.recordConstruction !== undefined
+            && source?.choiceName !== "Archive");
+    }
+    normalizeCurriedChoiceExpression(expression) {
+        const outerParameterName = expression.lambda?.parameters[0];
+        const trailingLambda = this.extractTrailingLambda(expression.lambda?.body);
+        if (outerParameterName === undefined
+            || expression.lambda?.parameters.length !== 1
+            || trailingLambda === undefined
+            || trailingLambda.parameters.length < 2) {
+            return undefined;
+        }
+        return new DamlLfExpression({
+            lambda: {
+                parameters: [
+                    trailingLambda.parameters[0],
+                    outerParameterName,
+                    trailingLambda.parameters[1],
+                ],
+                body: trailingLambda.body,
+            },
+            sourceLocation: expression.sourceLocation,
+        });
+    }
+    wrapChoiceArgumentEnvelope(expression, choiceArgumentFieldName) {
+        if (expression === undefined
+            || choiceArgumentFieldName === undefined
+            || expression.lambda === undefined
+            || expression.lambda.parameters.length < 3) {
+            return expression;
+        }
+        const argumentParameterName = expression.lambda.parameters[2];
+        const envelopeParameterName = `__${argumentParameterName}Envelope`;
+        return new DamlLfExpression({
+            lambda: {
+                parameters: [
+                    expression.lambda.parameters[0],
+                    expression.lambda.parameters[1],
+                    envelopeParameterName,
+                ],
+                body: new DamlLfExpression({
+                    letExpression: {
+                        bindings: [
+                            {
+                                name: argumentParameterName,
+                                value: new DamlLfExpression({
+                                    recordProjection: {
+                                        fieldName: choiceArgumentFieldName,
+                                        record: new DamlLfExpression({
+                                            variableName: envelopeParameterName,
+                                        }),
+                                    },
+                                }),
+                            },
+                        ],
+                        body: expression.lambda.body,
+                    },
+                    sourceLocation: expression.lambda.body.sourceLocation,
+                }),
+            },
+            sourceLocation: expression.sourceLocation,
+        });
+    }
+    extractTrailingLambda(expression) {
+        if (expression === undefined) {
+            return undefined;
+        }
+        if (expression.lambda !== undefined) {
+            return {
+                parameters: expression.lambda.parameters,
+                body: expression.lambda.body,
+            };
+        }
+        if (expression.letExpression !== undefined) {
+            const trailingLambda = this.extractTrailingLambda(expression.letExpression.body);
+            if (trailingLambda === undefined) {
+                return undefined;
+            }
+            return {
+                parameters: trailingLambda.parameters,
+                body: new DamlLfExpression({
+                    letExpression: {
+                        bindings: expression.letExpression.bindings,
+                        body: trailingLambda.body,
+                    },
+                    sourceLocation: expression.sourceLocation,
+                }),
+            };
+        }
+        return undefined;
+    }
+}

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

@@ -0,0 +1,22 @@
+export declare class ReplayEntrypoint {
+    readonly kind: "create" | "exercise";
+    readonly templateId?: {
+        packageId?: string;
+        moduleName?: string;
+        entityName?: string;
+    };
+    readonly contractId?: string;
+    readonly choice?: string;
+    readonly argument?: unknown;
+    constructor(init: {
+        kind: "create" | "exercise";
+        templateId?: {
+            packageId?: string;
+            moduleName?: string;
+            entityName?: string;
+        };
+        contractId?: string;
+        choice?: string;
+        argument?: unknown;
+    });
+}

package/dist/debugger/replay/replay-entrypoint.js

@@ -0,0 +1,14 @@
+export class ReplayEntrypoint {
+    kind;
+    templateId;
+    contractId;
+    choice;
+    argument;
+    constructor(init) {
+        this.kind = init.kind;
+        this.templateId = init.templateId;
+        this.contractId = init.contractId;
+        this.choice = init.choice;
+        this.argument = init.argument;
+    }
+}

package/dist/debugger/replay/replay-ledger-value-normalizer.d.ts

@@ -0,0 +1,7 @@
+export declare function normalizeReplayLedgerValue(value: unknown): unknown;
+export declare function collectReplayLedgerContractIds(value: unknown): readonly string[];
+export declare function attachReplayRecordId(value: unknown, recordId: {
+    packageId?: string;
+    moduleName?: string;
+    entityName?: string;
+} | undefined): unknown;

package/dist/debugger/replay/replay-ledger-value-normalizer.js

@@ -0,0 +1,194 @@
+import { DAML_LF_CONTRACT_ID_MARKER_KEY, 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";
+export function normalizeReplayLedgerValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => normalizeReplayLedgerValue(item));
+    }
+    if (value === null || value === undefined || typeof value !== "object") {
+        return value;
+    }
+    if ("sum" in value && isOneofValue(value.sum)) {
+        return normalizeOneofValue(value.sum);
+    }
+    if ("fields" in value
+        && Array.isArray(value.fields)
+        && value.fields.every((field) => field !== null
+            && typeof field === "object"
+            && "value" in field)) {
+        const normalizedRecord = Object.fromEntries(value.fields.map((field, index) => [
+            getRecordFieldKey(field, index),
+            normalizeReplayLedgerValue(field.value),
+        ]));
+        const recordId = readRecordId(value);
+        return recordId === undefined
+            ? normalizedRecord
+            : {
+                ...normalizedRecord,
+                [DAML_LF_RECORD_ID_MARKER_KEY]: recordId,
+            };
+    }
+    return Object.fromEntries(Object.entries(value)
+        .filter(([, child]) => child !== undefined)
+        .map(([key, child]) => [key, normalizeReplayLedgerValue(child)]));
+}
+export function collectReplayLedgerContractIds(value) {
+    const contractIds = new Set();
+    collectContractIdsInto(value, contractIds);
+    return [...contractIds];
+}
+export function attachReplayRecordId(value, recordId) {
+    if (recordId === undefined
+        || value === null
+        || value === undefined
+        || typeof value !== "object"
+        || Array.isArray(value)
+        || DAML_LF_RECORD_ID_MARKER_KEY in value) {
+        return value;
+    }
+    return {
+        ...value,
+        [DAML_LF_RECORD_ID_MARKER_KEY]: recordId,
+    };
+}
+function isOneofValue(value) {
+    return value !== null && typeof value === "object";
+}
+function normalizeOneofValue(value) {
+    switch (value.oneofKind) {
+        case "unit":
+            return null;
+        case "bool":
+        case "int64":
+        case "date":
+        case "timestamp":
+        case "text":
+            return value[value.oneofKind];
+        case "numeric":
+            return {
+                [DAML_LF_NUMERIC_MARKER_KEY]: value.numeric,
+            };
+        case "party":
+            return {
+                [DAML_LF_PARTY_MARKER_KEY]: value.party,
+            };
+        case "contractId":
+            return {
+                [DAML_LF_CONTRACT_ID_MARKER_KEY]: value.contractId,
+            };
+        case "optional":
+            return normalizeOptionalValue(value.optional);
+        case "list":
+            return normalizeListValue(value.list);
+        case "textMap":
+            return normalizeTextMapValue(value.textMap);
+        case "genMap":
+            return normalizeGenMapValue(value.genMap);
+        case "record":
+            return normalizeReplayLedgerValue(value.record);
+        case "variant":
+            return {
+                constructor: readObjectString(value.variant, "constructor"),
+                value: normalizeReplayLedgerValue(readObjectProperty(value.variant, "value")),
+            };
+        case "enum":
+            return readObjectString(value.enum, "constructor");
+        default:
+            return value;
+    }
+}
+function normalizeOptionalValue(value) {
+    if (value === null || value === undefined || typeof value !== "object") {
+        return undefined;
+    }
+    return normalizeReplayLedgerValue(readObjectProperty(value, "value"));
+}
+function normalizeListValue(value) {
+    if (value === null || value === undefined || typeof value !== "object") {
+        return [];
+    }
+    const elements = readObjectProperty(value, "elements");
+    return Array.isArray(elements)
+        ? elements.map((element) => normalizeReplayLedgerValue(element))
+        : [];
+}
+function normalizeTextMapValue(value) {
+    if (value === null || value === undefined || typeof value !== "object") {
+        return {};
+    }
+    const entries = readObjectProperty(value, "entries");
+    if (!Array.isArray(entries)) {
+        return {};
+    }
+    return Object.fromEntries(entries.map((entry) => [
+        readObjectString(entry, "key"),
+        normalizeReplayLedgerValue(readObjectProperty(entry, "value")),
+    ]));
+}
+function normalizeGenMapValue(value) {
+    if (value === null || value === undefined || typeof value !== "object") {
+        return [];
+    }
+    const entries = readObjectProperty(value, "entries");
+    if (!Array.isArray(entries)) {
+        return [];
+    }
+    return entries.map((entry) => ({
+        key: normalizeReplayLedgerValue(readObjectProperty(entry, "key")),
+        value: normalizeReplayLedgerValue(readObjectProperty(entry, "value")),
+    }));
+}
+function getRecordFieldKey(field, index) {
+    if (field !== null
+        && typeof field === "object"
+        && "label" in field
+        && typeof field.label === "string"
+        && field.label.length > 0) {
+        return field.label;
+    }
+    return index.toString();
+}
+function readObjectProperty(value, propertyName) {
+    if (value === null || value === undefined || typeof value !== "object") {
+        return undefined;
+    }
+    return value[propertyName];
+}
+function readObjectString(value, propertyName) {
+    const property = readObjectProperty(value, propertyName);
+    return typeof property === "string" ? property : "";
+}
+function readRecordId(value) {
+    const recordId = readObjectProperty(value, "recordId");
+    if (recordId === undefined || recordId === null || typeof recordId !== "object") {
+        return undefined;
+    }
+    return {
+        packageId: readOptionalObjectString(recordId, "packageId"),
+        moduleName: readOptionalObjectString(recordId, "moduleName"),
+        entityName: readOptionalObjectString(recordId, "entityName"),
+    };
+}
+function readOptionalObjectString(value, propertyName) {
+    const property = readObjectProperty(value, propertyName);
+    return typeof property === "string" && property.length > 0
+        ? property
+        : undefined;
+}
+function collectContractIdsInto(value, contractIds) {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            collectContractIdsInto(item, contractIds);
+        }
+        return;
+    }
+    if (value === null || value === undefined || typeof value !== "object") {
+        return;
+    }
+    if (DAML_LF_CONTRACT_ID_MARKER_KEY in value
+        && typeof value[DAML_LF_CONTRACT_ID_MARKER_KEY] === "string") {
+        contractIds.add(value[DAML_LF_CONTRACT_ID_MARKER_KEY]);
+        return;
+    }
+    for (const child of Object.values(value)) {
+        collectContractIdsInto(child, contractIds);
+    }
+}

package/dist/debugger/replay/replay-update-loader.d.ts

@@ -0,0 +1,24 @@
+import { GetUpdateByOffsetRequest } from "../../core/types/requests/get-update-by-offset-request.js";
+import { GetUpdateByOffsetResponse } from "../../core/types/responses/get-update-by-offset-response.js";
+import { ReplayEntrypoint } from "./replay-entrypoint.js";
+interface IReplayUpdateService {
+    getUpdateByOffsetAsync(request: GetUpdateByOffsetRequest): Promise<GetUpdateByOffsetResponse>;
+}
+export declare class ReplayUpdateLoader {
+    private readonly dependencies;
+    constructor(dependencies: {
+        updateService: IReplayUpdateService;
+        visibleParties?: readonly string[];
+    });
+    loadOrThrowAsync(offset: string): Promise<{
+        kind: "transaction";
+        offset: string;
+        updateId?: string;
+        actAs?: readonly string[];
+        readAs?: readonly string[];
+        events: readonly unknown[];
+        entrypoint: ReplayEntrypoint;
+    }>;
+    private deriveEntrypointOrThrow;
+}
+export {};