@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

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

@@ -0,0 +1,341 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayEntrypointDefinitionResolver = void 0;
+const daml_lf_expression_js_1 = require("../../daml-lf/model/daml-lf-expression.js");
+const daml_lf_type_js_1 = require("../../daml-lf/model/daml-lf-type.js");
+const daml_lf_value_definition_js_1 = require("../../daml-lf/model/daml-lf-value-definition.js");
+const daml_lf_template_id_js_1 = require("../../daml-lf/model/daml-lf-template-id.js");
+const replay_source_map_exception_js_1 = require("../errors/replay-source-map.exception.js");
+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 replay_source_map_exception_js_1.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 daml_lf_template_id_js_1.DamlLfTemplateId({
+                packageId,
+                moduleName,
+                templateName,
+            }), entrypoint.choice);
+        if (source === undefined) {
+            throw new replay_source_map_exception_js_1.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 daml_lf_template_id_js_1.DamlLfTemplateId({
+                    packageId,
+                    moduleName,
+                    templateName,
+                }), entrypoint.choice),
+            ...this.resolveReplayStrategy(definition.expression, source, entrypoint.kind, entrypoint.kind === "exercise"
+                ? new daml_lf_template_id_js_1.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 replay_source_map_exception_js_1.ReplaySourceMapException(`missing executable metadata for choice '${templateId.packageId}::${templateId.moduleName}::${templateId.templateName}::${choiceName}'`);
+            }
+            return {
+                packageId: templateId.packageId,
+                moduleName: templateId.moduleName,
+                definition: new daml_lf_value_definition_js_1.DamlLfValueDefinition({
+                    name: `${templateId.templateName}$${choiceName}`,
+                    type: new daml_lf_type_js_1.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 daml_lf_expression_js_1.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 replay_source_map_exception_js_1.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 daml_lf_expression_js_1.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 daml_lf_expression_js_1.DamlLfExpression({
+            lambda: {
+                parameters: [
+                    expression.lambda.parameters[0],
+                    expression.lambda.parameters[1],
+                    envelopeParameterName,
+                ],
+                body: new daml_lf_expression_js_1.DamlLfExpression({
+                    letExpression: {
+                        bindings: [
+                            {
+                                name: argumentParameterName,
+                                value: new daml_lf_expression_js_1.DamlLfExpression({
+                                    recordProjection: {
+                                        fieldName: choiceArgumentFieldName,
+                                        record: new daml_lf_expression_js_1.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 daml_lf_expression_js_1.DamlLfExpression({
+                    letExpression: {
+                        bindings: expression.letExpression.bindings,
+                        body: trailingLambda.body,
+                    },
+                    sourceLocation: expression.sourceLocation,
+                }),
+            };
+        }
+        return undefined;
+    }
+}
+exports.ReplayEntrypointDefinitionResolver = ReplayEntrypointDefinitionResolver;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayEntrypoint = void 0;
+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;
+    }
+}
+exports.ReplayEntrypoint = ReplayEntrypoint;

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

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeReplayLedgerValue = normalizeReplayLedgerValue;
+exports.collectReplayLedgerContractIds = collectReplayLedgerContractIds;
+exports.attachReplayRecordId = attachReplayRecordId;
+const daml_lf_runtime_value_js_1 = require("../../daml-lf/interpreter/daml-lf-runtime-value.js");
+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_runtime_value_js_1.DAML_LF_RECORD_ID_MARKER_KEY]: recordId,
+            };
+    }
+    return Object.fromEntries(Object.entries(value)
+        .filter(([, child]) => child !== undefined)
+        .map(([key, child]) => [key, normalizeReplayLedgerValue(child)]));
+}
+function collectReplayLedgerContractIds(value) {
+    const contractIds = new Set();
+    collectContractIdsInto(value, contractIds);
+    return [...contractIds];
+}
+function attachReplayRecordId(value, recordId) {
+    if (recordId === undefined
+        || value === null
+        || value === undefined
+        || typeof value !== "object"
+        || Array.isArray(value)
+        || daml_lf_runtime_value_js_1.DAML_LF_RECORD_ID_MARKER_KEY in value) {
+        return value;
+    }
+    return {
+        ...value,
+        [daml_lf_runtime_value_js_1.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_runtime_value_js_1.DAML_LF_NUMERIC_MARKER_KEY]: value.numeric,
+            };
+        case "party":
+            return {
+                [daml_lf_runtime_value_js_1.DAML_LF_PARTY_MARKER_KEY]: value.party,
+            };
+        case "contractId":
+            return {
+                [daml_lf_runtime_value_js_1.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_runtime_value_js_1.DAML_LF_CONTRACT_ID_MARKER_KEY in value
+        && typeof value[daml_lf_runtime_value_js_1.DAML_LF_CONTRACT_ID_MARKER_KEY] === "string") {
+        contractIds.add(value[daml_lf_runtime_value_js_1.DAML_LF_CONTRACT_ID_MARKER_KEY]);
+        return;
+    }
+    for (const child of Object.values(value)) {
+        collectContractIdsInto(child, contractIds);
+    }
+}

package/dist/cjs/debugger/replay/replay-update-loader.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayUpdateLoader = void 0;
+const update_service_js_1 = require("../../transports/grpc/generated/canton/com/daml/ledger/api/v2/update_service.js");
+const replay_unsupported_update_exception_js_1 = require("../errors/replay-unsupported-update.exception.js");
+const replay_entrypoint_js_1 = require("./replay-entrypoint.js");
+const replay_update_visibility_validator_js_1 = require("./replay-update-visibility-validator.js");
+const transaction_filter_js_1 = require("../../transports/grpc/generated/canton/com/daml/ledger/api/v2/transaction_filter.js");
+class ReplayUpdateLoader {
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    async loadOrThrowAsync(offset) {
+        const response = await this.dependencies.updateService.getUpdateByOffsetAsync(update_service_js_1.GetUpdateByOffsetRequest.create({
+            offset,
+            updateFormat: createReplayUpdateFormat(this.dependencies.visibleParties),
+        }));
+        const transaction = response.update.oneofKind === "transaction"
+            ? response.update.transaction
+            : undefined;
+        if (transaction === undefined ||
+            !Array.isArray(transaction.events) ||
+            transaction.offset === undefined) {
+            throw new replay_unsupported_update_exception_js_1.ReplayUnsupportedUpdateException("update is not a replayable transaction payload");
+        }
+        (0, replay_update_visibility_validator_js_1.validateReplayVisibilityOrThrow)(transaction);
+        return {
+            kind: "transaction",
+            offset: transaction.offset,
+            updateId: transaction.updateId,
+            actAs: transaction.actAs,
+            readAs: transaction.readAs,
+            events: transaction.events,
+            entrypoint: this.deriveEntrypointOrThrow(transaction.events),
+        };
+    }
+    deriveEntrypointOrThrow(events) {
+        const firstEvent = events[0]?.event;
+        if (firstEvent?.oneofKind === "created" &&
+            firstEvent.created?.templateId !== undefined &&
+            firstEvent.created.createArguments !== undefined) {
+            return new replay_entrypoint_js_1.ReplayEntrypoint({
+                kind: "create",
+                templateId: firstEvent.created.templateId,
+                argument: firstEvent.created.createArguments,
+            });
+        }
+        if (firstEvent?.oneofKind === "exercised" &&
+            firstEvent.exercised?.templateId !== undefined &&
+            firstEvent.exercised.contractId !== undefined &&
+            firstEvent.exercised.choice !== undefined &&
+            firstEvent.exercised.choiceArgument !== undefined) {
+            return new replay_entrypoint_js_1.ReplayEntrypoint({
+                kind: "exercise",
+                templateId: firstEvent.exercised.templateId,
+                contractId: firstEvent.exercised.contractId,
+                choice: firstEvent.exercised.choice,
+                argument: firstEvent.exercised.choiceArgument,
+            });
+        }
+        throw new replay_unsupported_update_exception_js_1.ReplayUnsupportedUpdateException("could not derive a replay entrypoint from the visible update payload");
+    }
+}
+exports.ReplayUpdateLoader = ReplayUpdateLoader;
+function createReplayUpdateFormat(visibleParties) {
+    return {
+        includeTransactions: {
+            eventFormat: createReplayEventFormat(visibleParties),
+            transactionShape: transaction_filter_js_1.TransactionShape.LEDGER_EFFECTS,
+        },
+    };
+}
+function createReplayEventFormat(visibleParties) {
+    const wildcardFilter = {
+        cumulative: [
+            {
+                identifierFilter: {
+                    oneofKind: "wildcardFilter",
+                    wildcardFilter: {
+                        includeCreatedEventBlob: true,
+                    },
+                },
+            },
+        ],
+    };
+    if (Array.isArray(visibleParties) && visibleParties.length > 0) {
+        return {
+            filtersByParty: Object.fromEntries([...new Set(visibleParties)]
+                .filter((party) => typeof party === "string" && party.length > 0)
+                .map((party) => [party, wildcardFilter])),
+            verbose: true,
+        };
+    }
+    return {
+        filtersByParty: {},
+        filtersForAnyParty: wildcardFilter,
+        verbose: true,
+    };
+}

package/dist/cjs/debugger/replay/replay-update-visibility-validator.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateReplayVisibilityOrThrow = validateReplayVisibilityOrThrow;
+const replay_unsupported_update_exception_js_1 = require("../errors/replay-unsupported-update.exception.js");
+function validateReplayVisibilityOrThrow(update) {
+    for (const event of update.events ?? []) {
+        if (event.event?.oneofKind === "created") {
+            if (event.event.created?.templateId === undefined ||
+                event.event.created.createArguments === undefined) {
+                throw new replay_unsupported_update_exception_js_1.ReplayUnsupportedUpdateException("created events must include template id and create arguments for replay");
+            }
+        }
+        if (event.event?.oneofKind === "exercised") {
+            if (event.event.exercised?.templateId === undefined ||
+                event.event.exercised.contractId === undefined ||
+                event.event.exercised.choice === undefined ||
+                event.event.exercised.choiceArgument === undefined) {
+                throw new replay_unsupported_update_exception_js_1.ReplayUnsupportedUpdateException("exercised events must include template id, contract id, choice, and choice argument for replay");
+            }
+        }
+    }
+}