@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

package/dist/cjs/daml-lf/model/module-reference.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleReference = void 0;
+class ModuleReference {
+    packageId;
+    moduleName;
+    constructor(init) {
+        this.packageId = init.packageId;
+        this.moduleName = init.moduleName;
+    }
+}
+exports.ModuleReference = ModuleReference;

package/dist/cjs/daml-lf/model/type-con-reference.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeConReference = void 0;
+class TypeConReference {
+    packageId;
+    moduleName;
+    name;
+    constructor(init) {
+        this.packageId = init.packageId;
+        this.moduleName = init.moduleName;
+        this.name = init.name;
+    }
+}
+exports.TypeConReference = TypeConReference;

package/dist/cjs/daml-lf/semantics/daml-lf-semantic-model.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfSemanticModel = void 0;
+class DamlLfSemanticModel {
+    compilation;
+    constructor(compilation) {
+        this.compilation = compilation;
+        void this.compilation;
+    }
+    /** Returns the templates exposed by the compiled workspace. */
+    getTemplates() {
+        return this.compilation.getTemplates();
+    }
+    /** Returns the choices declared on a template identity. */
+    getTemplateChoicesOrThrow(templateId) {
+        return this.compilation.getTemplateChoicesOrThrow(templateId);
+    }
+    /** Returns the record fields for a resolved type constructor reference. */
+    getRecordFieldsOrThrow(reference) {
+        return this.getDataTypeOrThrow(reference).fields;
+    }
+    /** Returns the complete resolved data type for a type constructor reference. */
+    getDataTypeOrThrow(reference) {
+        return this.compilation.getTypeSymbolOrThrow(reference).definition;
+    }
+}
+exports.DamlLfSemanticModel = DamlLfSemanticModel;

package/dist/cjs/daml-lf/symbols/daml-lf-symbol.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfSymbol = void 0;
+class DamlLfSymbol {
+    name;
+    constructor(init) {
+        this.name = init.name;
+    }
+}
+exports.DamlLfSymbol = DamlLfSymbol;

package/dist/cjs/daml-lf/symbols/module-symbol.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleSymbol = void 0;
+const daml_lf_symbol_js_1 = require("./daml-lf-symbol.js");
+class ModuleSymbol extends daml_lf_symbol_js_1.DamlLfSymbol {
+    module;
+    constructor(init) {
+        super({
+            name: init.name,
+        });
+        this.module = init.module;
+    }
+}
+exports.ModuleSymbol = ModuleSymbol;

package/dist/cjs/daml-lf/symbols/type-symbol.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeSymbol = void 0;
+const daml_lf_symbol_js_1 = require("./daml-lf-symbol.js");
+class TypeSymbol extends daml_lf_symbol_js_1.DamlLfSymbol {
+    definition;
+    constructor(init) {
+        super({
+            name: init.name,
+        });
+        this.definition = init.definition;
+    }
+}
+exports.TypeSymbol = TypeSymbol;

package/dist/cjs/debugger/errors/replay-determinism.exception.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayDeterminismException = void 0;
+const canton_error_js_1 = require("../../core/errors/canton-error.js");
+class ReplayDeterminismException extends canton_error_js_1.CantonError {
+}
+exports.ReplayDeterminismException = ReplayDeterminismException;

package/dist/cjs/debugger/errors/replay-missing-package.exception.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayMissingPackageException = void 0;
+const canton_error_js_1 = require("../../core/errors/canton-error.js");
+class ReplayMissingPackageException extends canton_error_js_1.CantonError {
+}
+exports.ReplayMissingPackageException = ReplayMissingPackageException;

package/dist/cjs/debugger/errors/replay-missing-source.exception.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayMissingSourceException = void 0;
+const canton_error_js_1 = require("../../core/errors/canton-error.js");
+class ReplayMissingSourceException extends canton_error_js_1.CantonError {
+}
+exports.ReplayMissingSourceException = ReplayMissingSourceException;

package/dist/cjs/debugger/errors/replay-source-map.exception.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplaySourceMapException = void 0;
+const canton_error_js_1 = require("../../core/errors/canton-error.js");
+class ReplaySourceMapException extends canton_error_js_1.CantonError {
+}
+exports.ReplaySourceMapException = ReplaySourceMapException;

package/dist/cjs/debugger/errors/replay-state-hydration.exception.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayStateHydrationException = void 0;
+const canton_error_js_1 = require("../../core/errors/canton-error.js");
+class ReplayStateHydrationException extends canton_error_js_1.CantonError {
+}
+exports.ReplayStateHydrationException = ReplayStateHydrationException;

package/dist/cjs/debugger/errors/replay-unsupported-lf-construct.exception.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayUnsupportedLfConstructException = void 0;
+const canton_error_js_1 = require("../../core/errors/canton-error.js");
+class ReplayUnsupportedLfConstructException extends canton_error_js_1.CantonError {
+}
+exports.ReplayUnsupportedLfConstructException = ReplayUnsupportedLfConstructException;

package/dist/cjs/debugger/errors/replay-unsupported-update.exception.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayUnsupportedUpdateException = void 0;
+const canton_error_js_1 = require("../../core/errors/canton-error.js");
+class ReplayUnsupportedUpdateException extends canton_error_js_1.CantonError {
+}
+exports.ReplayUnsupportedUpdateException = ReplayUnsupportedUpdateException;

package/dist/cjs/debugger/index.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceIndexedCompilation = exports.SourceMappingPrecision = exports.DarSourceMapMetadata = exports.DamlSourceMapper = exports.ReplayValuePreview = exports.ReplayStepAdvanceResult = exports.ReplayStep = exports.ReplayStateDelta = exports.ReplayStackFrame = exports.ReplayScope = exports.ReplaySourceLocation = exports.ReplaySessionRequest = exports.ReplaySessionMetadata = exports.ReplaySession = exports.InMemoryReplaySessionStore = exports.ReplayPhase = exports.ReplayUpdateLoader = exports.ReplayEntrypoint = exports.ReplayEntrypointDefinitionResolver = exports.ReplayDeterminismValidator = exports.ReplayArtifactResolver = exports.LedgerReplayEnvironmentBuilder = exports.LedgerReplaySessionLoader = exports.ReplayUnsupportedUpdateException = exports.ReplayUnsupportedLfConstructException = exports.ReplayStateHydrationException = exports.ReplaySourceMapException = exports.ReplayMissingSourceException = exports.ReplayMissingPackageException = exports.ReplayDeterminismException = exports.LedgerReplayDebuggerClient = void 0;
+var ledger_replay_debugger_client_js_1 = require("./ledger-replay-debugger-client.js");
+Object.defineProperty(exports, "LedgerReplayDebuggerClient", { enumerable: true, get: function () { return ledger_replay_debugger_client_js_1.LedgerReplayDebuggerClient; } });
+var replay_determinism_exception_js_1 = require("./errors/replay-determinism.exception.js");
+Object.defineProperty(exports, "ReplayDeterminismException", { enumerable: true, get: function () { return replay_determinism_exception_js_1.ReplayDeterminismException; } });
+var replay_missing_package_exception_js_1 = require("./errors/replay-missing-package.exception.js");
+Object.defineProperty(exports, "ReplayMissingPackageException", { enumerable: true, get: function () { return replay_missing_package_exception_js_1.ReplayMissingPackageException; } });
+var replay_missing_source_exception_js_1 = require("./errors/replay-missing-source.exception.js");
+Object.defineProperty(exports, "ReplayMissingSourceException", { enumerable: true, get: function () { return replay_missing_source_exception_js_1.ReplayMissingSourceException; } });
+var replay_source_map_exception_js_1 = require("./errors/replay-source-map.exception.js");
+Object.defineProperty(exports, "ReplaySourceMapException", { enumerable: true, get: function () { return replay_source_map_exception_js_1.ReplaySourceMapException; } });
+var replay_state_hydration_exception_js_1 = require("./errors/replay-state-hydration.exception.js");
+Object.defineProperty(exports, "ReplayStateHydrationException", { enumerable: true, get: function () { return replay_state_hydration_exception_js_1.ReplayStateHydrationException; } });
+var replay_unsupported_lf_construct_exception_js_1 = require("./errors/replay-unsupported-lf-construct.exception.js");
+Object.defineProperty(exports, "ReplayUnsupportedLfConstructException", { enumerable: true, get: function () { return replay_unsupported_lf_construct_exception_js_1.ReplayUnsupportedLfConstructException; } });
+var replay_unsupported_update_exception_js_1 = require("./errors/replay-unsupported-update.exception.js");
+Object.defineProperty(exports, "ReplayUnsupportedUpdateException", { enumerable: true, get: function () { return replay_unsupported_update_exception_js_1.ReplayUnsupportedUpdateException; } });
+var ledger_replay_session_loader_js_1 = require("./replay/ledger-replay-session-loader.js");
+Object.defineProperty(exports, "LedgerReplaySessionLoader", { enumerable: true, get: function () { return ledger_replay_session_loader_js_1.LedgerReplaySessionLoader; } });
+var ledger_replay_environment_builder_js_1 = require("./replay/ledger-replay-environment-builder.js");
+Object.defineProperty(exports, "LedgerReplayEnvironmentBuilder", { enumerable: true, get: function () { return ledger_replay_environment_builder_js_1.LedgerReplayEnvironmentBuilder; } });
+var replay_artifact_resolver_js_1 = require("./replay/replay-artifact-resolver.js");
+Object.defineProperty(exports, "ReplayArtifactResolver", { enumerable: true, get: function () { return replay_artifact_resolver_js_1.ReplayArtifactResolver; } });
+var replay_determinism_validator_js_1 = require("./replay/replay-determinism-validator.js");
+Object.defineProperty(exports, "ReplayDeterminismValidator", { enumerable: true, get: function () { return replay_determinism_validator_js_1.ReplayDeterminismValidator; } });
+var replay_entrypoint_definition_resolver_js_1 = require("./replay/replay-entrypoint-definition-resolver.js");
+Object.defineProperty(exports, "ReplayEntrypointDefinitionResolver", { enumerable: true, get: function () { return replay_entrypoint_definition_resolver_js_1.ReplayEntrypointDefinitionResolver; } });
+var replay_entrypoint_js_1 = require("./replay/replay-entrypoint.js");
+Object.defineProperty(exports, "ReplayEntrypoint", { enumerable: true, get: function () { return replay_entrypoint_js_1.ReplayEntrypoint; } });
+var replay_update_loader_js_1 = require("./replay/replay-update-loader.js");
+Object.defineProperty(exports, "ReplayUpdateLoader", { enumerable: true, get: function () { return replay_update_loader_js_1.ReplayUpdateLoader; } });
+var replay_phase_js_1 = require("./session/replay-phase.js");
+Object.defineProperty(exports, "ReplayPhase", { enumerable: true, get: function () { return replay_phase_js_1.ReplayPhase; } });
+var in_memory_replay_session_store_js_1 = require("./session/in-memory-replay-session-store.js");
+Object.defineProperty(exports, "InMemoryReplaySessionStore", { enumerable: true, get: function () { return in_memory_replay_session_store_js_1.InMemoryReplaySessionStore; } });
+var replay_session_js_1 = require("./session/replay-session.js");
+Object.defineProperty(exports, "ReplaySession", { enumerable: true, get: function () { return replay_session_js_1.ReplaySession; } });
+var replay_session_metadata_js_1 = require("./session/replay-session-metadata.js");
+Object.defineProperty(exports, "ReplaySessionMetadata", { enumerable: true, get: function () { return replay_session_metadata_js_1.ReplaySessionMetadata; } });
+var replay_session_request_js_1 = require("./session/replay-session-request.js");
+Object.defineProperty(exports, "ReplaySessionRequest", { enumerable: true, get: function () { return replay_session_request_js_1.ReplaySessionRequest; } });
+var replay_source_location_js_1 = require("./session/replay-source-location.js");
+Object.defineProperty(exports, "ReplaySourceLocation", { enumerable: true, get: function () { return replay_source_location_js_1.ReplaySourceLocation; } });
+var replay_scope_js_1 = require("./session/replay-scope.js");
+Object.defineProperty(exports, "ReplayScope", { enumerable: true, get: function () { return replay_scope_js_1.ReplayScope; } });
+var replay_stack_frame_js_1 = require("./session/replay-stack-frame.js");
+Object.defineProperty(exports, "ReplayStackFrame", { enumerable: true, get: function () { return replay_stack_frame_js_1.ReplayStackFrame; } });
+var replay_state_delta_js_1 = require("./session/replay-state-delta.js");
+Object.defineProperty(exports, "ReplayStateDelta", { enumerable: true, get: function () { return replay_state_delta_js_1.ReplayStateDelta; } });
+var replay_step_js_1 = require("./session/replay-step.js");
+Object.defineProperty(exports, "ReplayStep", { enumerable: true, get: function () { return replay_step_js_1.ReplayStep; } });
+var replay_step_advance_result_js_1 = require("./session/replay-step-advance-result.js");
+Object.defineProperty(exports, "ReplayStepAdvanceResult", { enumerable: true, get: function () { return replay_step_advance_result_js_1.ReplayStepAdvanceResult; } });
+var replay_value_preview_js_1 = require("./session/replay-value-preview.js");
+Object.defineProperty(exports, "ReplayValuePreview", { enumerable: true, get: function () { return replay_value_preview_js_1.ReplayValuePreview; } });
+var daml_source_mapper_js_1 = require("./source/daml-source-mapper.js");
+Object.defineProperty(exports, "DamlSourceMapper", { enumerable: true, get: function () { return daml_source_mapper_js_1.DamlSourceMapper; } });
+var dar_source_map_metadata_js_1 = require("./source/dar-source-map-metadata.js");
+Object.defineProperty(exports, "DarSourceMapMetadata", { enumerable: true, get: function () { return dar_source_map_metadata_js_1.DarSourceMapMetadata; } });
+var source_mapping_precision_js_1 = require("./source/source-mapping-precision.js");
+Object.defineProperty(exports, "SourceMappingPrecision", { enumerable: true, get: function () { return source_mapping_precision_js_1.SourceMappingPrecision; } });
+var source_indexed_compilation_js_1 = require("./source/source-indexed-compilation.js");
+Object.defineProperty(exports, "SourceIndexedCompilation", { enumerable: true, get: function () { return source_indexed_compilation_js_1.SourceIndexedCompilation; } });

package/dist/cjs/debugger/ledger-replay-debugger-client.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LedgerReplayDebuggerClient = void 0;
+const in_memory_replay_session_store_js_1 = require("./session/in-memory-replay-session-store.js");
+class LedgerReplayDebuggerClient {
+    dependencies;
+    sessionStore;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+        this.sessionStore =
+            this.dependencies.sessionStore ?? new in_memory_replay_session_store_js_1.InMemoryReplaySessionStore();
+    }
+    async loadSessionAsync(request) {
+        const loadedSession = await this.dependencies.sessionLoader.loadOrThrowAsync(request);
+        return this.getStore().put(loadedSession);
+    }
+    async getSessionMetadataAsync(sessionId) {
+        return this.getStore().getSessionMetadataOrThrow(sessionId);
+    }
+    async getCurrentStepAsync(sessionId) {
+        return this.getStore().getCurrentStepOrThrow(sessionId);
+    }
+    async stepIntoAsync(sessionId) {
+        return this.getStore().advanceIntoOrThrow(sessionId);
+    }
+    async stepBackAsync(sessionId) {
+        return this.getStore().advanceBackOrThrow(sessionId);
+    }
+    async stepOverAsync(sessionId) {
+        return this.getStore().advanceOverOrThrow(sessionId);
+    }
+    async stepOutAsync(sessionId) {
+        return this.getStore().advanceOutOrThrow(sessionId);
+    }
+    async continueAsync(sessionId) {
+        return this.getStore().continueOrThrow(sessionId);
+    }
+    async jumpToStepAsync(sessionId, stepId) {
+        return this.getStore().setCurrentStepByIdOrThrow(sessionId, stepId);
+    }
+    async getStackAsync(sessionId) {
+        return this.getStore().getStackOrThrow(sessionId);
+    }
+    async getScopesAsync(sessionId, frameId) {
+        return this.getStore().getScopesOrThrow(sessionId, frameId);
+    }
+    async getTraceSliceAsync(sessionId, startIndex, endIndex) {
+        return this.getStore().getTraceSliceOrThrow(sessionId, startIndex, endIndex);
+    }
+    async disposeSessionAsync(sessionId) {
+        this.getStore().dispose(sessionId);
+    }
+    getStore() {
+        return this.sessionStore;
+    }
+}
+exports.LedgerReplayDebuggerClient = LedgerReplayDebuggerClient;

package/dist/cjs/debugger/replay/ledger-replay-environment-builder.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LedgerReplayEnvironmentBuilder = void 0;
+const contract_service_js_1 = require("../../transports/grpc/generated/canton/com/daml/ledger/api/v2/contract_service.js");
+const event_query_service_js_1 = require("../../transports/grpc/generated/canton/com/daml/ledger/api/v2/event_query_service.js");
+const replay_state_hydration_exception_js_1 = require("../errors/replay-state-hydration.exception.js");
+const replay_ledger_value_normalizer_js_1 = require("./replay-ledger-value-normalizer.js");
+const replay_entrypoint_js_1 = require("./replay-entrypoint.js");
+class LedgerReplayEnvironmentBuilder {
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    async buildOrThrowAsync(snapshot) {
+        const packageIds = new Set();
+        const contracts = new Map();
+        const pendingContractIds = new Set(this.getRequiredContractIds(snapshot));
+        const normalizedEntrypointArgument = (0, replay_ledger_value_normalizer_js_1.normalizeReplayLedgerValue)(snapshot.entrypoint.argument);
+        for (const visibleContract of this.getVisibleCreatedContracts(snapshot)) {
+            this.addPackageId(packageIds, visibleContract.templateId?.packageId);
+            contracts.set(visibleContract.contractId, visibleContract);
+            this.addReferencedContractIds(pendingContractIds, visibleContract.payload);
+        }
+        this.addReferencedContractIds(pendingContractIds, normalizedEntrypointArgument);
+        while (pendingContractIds.size > 0) {
+            const contractId = pendingContractIds.values().next().value;
+            if (contractId === undefined) {
+                break;
+            }
+            pendingContractIds.delete(contractId);
+            if (contracts.has(contractId)) {
+                continue;
+            }
+            const hydratedContract = await this.hydrateContractOrThrowAsync(contractId, snapshot);
+            this.addPackageId(packageIds, hydratedContract.templateId?.packageId);
+            contracts.set(contractId, hydratedContract);
+            this.addReferencedContractIds(pendingContractIds, hydratedContract.payload);
+        }
+        this.addPackageId(packageIds, snapshot.entrypoint.templateId?.packageId);
+        return {
+            kind: snapshot.kind,
+            offset: snapshot.offset,
+            updateId: snapshot.updateId,
+            actAs: [...(snapshot.actAs ?? [])],
+            readAs: [...(snapshot.readAs ?? [])],
+            entrypoint: new replay_entrypoint_js_1.ReplayEntrypoint({
+                kind: snapshot.entrypoint.kind,
+                templateId: snapshot.entrypoint.templateId,
+                contractId: snapshot.entrypoint.contractId,
+                choice: snapshot.entrypoint.choice,
+                argument: normalizedEntrypointArgument,
+            }),
+            contracts,
+            packageIds: [...packageIds].sort(),
+        };
+    }
+    getVisibleCreatedContracts(snapshot) {
+        return snapshot.events.flatMap((event) => {
+            if (event.event?.oneofKind !== "created"
+                || event.event.created?.contractId === undefined) {
+                return [];
+            }
+            return [
+                {
+                    contractId: event.event.created.contractId,
+                    templateId: event.event.created.templateId,
+                    payload: (0, replay_ledger_value_normalizer_js_1.attachReplayRecordId)((0, replay_ledger_value_normalizer_js_1.normalizeReplayLedgerValue)(event.event.created.createArguments), event.event.created.templateId === undefined
+                        ? undefined
+                        : {
+                            packageId: event.event.created.templateId.packageId,
+                            moduleName: event.event.created.templateId.moduleName,
+                            entityName: event.event.created.templateId.entityName,
+                        }),
+                    rawCreatedEvent: event.event.created,
+                    history: {
+                        created: {
+                            contractId: event.event.created.contractId,
+                            templateId: event.event.created.templateId,
+                            payload: (0, replay_ledger_value_normalizer_js_1.attachReplayRecordId)((0, replay_ledger_value_normalizer_js_1.normalizeReplayLedgerValue)(event.event.created.createArguments), event.event.created.templateId === undefined
+                                ? undefined
+                                : {
+                                    packageId: event.event.created.templateId.packageId,
+                                    moduleName: event.event.created.templateId.moduleName,
+                                    entityName: event.event.created.templateId.entityName,
+                                }),
+                            rawEvent: event.event.created,
+                        },
+                    },
+                },
+            ];
+        });
+    }
+    getRequiredContractIds(snapshot) {
+        const contractIds = new Set();
+        if (snapshot.entrypoint.kind === "exercise"
+            && snapshot.entrypoint.contractId !== undefined) {
+            contractIds.add(snapshot.entrypoint.contractId);
+        }
+        for (const event of snapshot.events) {
+            const contractId = event.event?.exercised?.contractId;
+            if (contractId !== undefined) {
+                contractIds.add(contractId);
+            }
+        }
+        return [...contractIds];
+    }
+    addReferencedContractIds(contractIds, value) {
+        for (const contractId of (0, replay_ledger_value_normalizer_js_1.collectReplayLedgerContractIds)(value)) {
+            if (contractId.length > 0) {
+                contractIds.add(contractId);
+            }
+        }
+    }
+    async hydrateContractOrThrowAsync(contractId, snapshot) {
+        const queryingParties = this.getQueryingParties(snapshot);
+        let contractResponse;
+        try {
+            contractResponse =
+                await this.dependencies.contractService.getContractAsync(contract_service_js_1.GetContractRequest.create({
+                    contractId,
+                    queryingParties: [...queryingParties],
+                }));
+        }
+        catch {
+            contractResponse = undefined;
+        }
+        const eventHistory = await this.dependencies.eventQueryService.getEventsByContractIdAsync(event_query_service_js_1.GetEventsByContractIdRequest.create({
+            contractId,
+            eventFormat: createReplayEventFormat(queryingParties),
+        }));
+        const createdEvent = this.asCreatedEvent(contractResponse?.createdEvent);
+        const createdHistory = this.asCreatedEvent(eventHistory.created?.createdEvent);
+        const archivedHistory = this.asArchivedEvent(eventHistory.archived?.archivedEvent);
+        const materializedCreatedEvent = [
+            createdEvent,
+            createdHistory,
+        ].find((event) => event?.contractId !== undefined
+            && event.createArguments !== undefined);
+        if (materializedCreatedEvent?.contractId === undefined) {
+            throw new replay_state_hydration_exception_js_1.ReplayStateHydrationException(`could not hydrate contract '${contractId}' from the ledger`);
+        }
+        if (materializedCreatedEvent.createArguments === undefined) {
+            throw new replay_state_hydration_exception_js_1.ReplayStateHydrationException(`contract '${contractId}' did not expose a visible payload`);
+        }
+        return {
+            contractId,
+            templateId: materializedCreatedEvent.templateId,
+            payload: (0, replay_ledger_value_normalizer_js_1.attachReplayRecordId)((0, replay_ledger_value_normalizer_js_1.normalizeReplayLedgerValue)(materializedCreatedEvent.createArguments), materializedCreatedEvent.templateId === undefined
+                ? undefined
+                : {
+                    packageId: materializedCreatedEvent.templateId.packageId,
+                    moduleName: materializedCreatedEvent.templateId.moduleName,
+                    entityName: materializedCreatedEvent.templateId.entityName,
+                }),
+            rawCreatedEvent: materializedCreatedEvent,
+            synchronizerId: eventHistory.created?.synchronizerId,
+            history: {
+                created: (createdHistory ?? materializedCreatedEvent) === undefined
+                    ? undefined
+                    : {
+                        contractId: (createdHistory ?? materializedCreatedEvent)
+                            .contractId,
+                        templateId: (createdHistory ?? materializedCreatedEvent)
+                            .templateId,
+                        payload: (0, replay_ledger_value_normalizer_js_1.attachReplayRecordId)((0, replay_ledger_value_normalizer_js_1.normalizeReplayLedgerValue)((createdHistory ?? materializedCreatedEvent)
+                            .createArguments), (createdHistory ?? materializedCreatedEvent)
+                            .templateId === undefined
+                            ? undefined
+                            : {
+                                packageId: (createdHistory
+                                    ?? materializedCreatedEvent).templateId?.packageId,
+                                moduleName: (createdHistory
+                                    ?? materializedCreatedEvent).templateId?.moduleName,
+                                entityName: (createdHistory
+                                    ?? materializedCreatedEvent).templateId?.entityName,
+                            }),
+                        rawEvent: createdHistory ?? materializedCreatedEvent,
+                    },
+                archived: archivedHistory === undefined
+                    ? undefined
+                    : {
+                        contractId: archivedHistory.contractId,
+                        templateId: archivedHistory.templateId,
+                        rawEvent: archivedHistory,
+                    },
+            },
+        };
+    }
+    getQueryingParties(snapshot) {
+        const configuredParties = this.dependencies.queryingParties ?? [];
+        if (configuredParties.length > 0) {
+            return [...new Set(configuredParties)];
+        }
+        return [
+            ...new Set([...(snapshot.actAs ?? []), ...(snapshot.readAs ?? [])]),
+        ];
+    }
+    addPackageId(packageIds, packageId) {
+        if (packageId !== undefined && packageId.length > 0) {
+            packageIds.add(packageId);
+        }
+    }
+    asCreatedEvent(value) {
+        if (value === undefined || value === null || typeof value !== "object") {
+            return undefined;
+        }
+        return value;
+    }
+    asArchivedEvent(value) {
+        if (value === undefined || value === null || typeof value !== "object") {
+            return undefined;
+        }
+        return value;
+    }
+    readObjectProperty(value, propertyName) {
+        if (value === null || value === undefined || typeof value !== "object") {
+            return undefined;
+        }
+        return value[propertyName];
+    }
+    readObjectString(value, propertyName) {
+        const property = this.readObjectProperty(value, propertyName);
+        return typeof property === "string" ? property : "";
+    }
+}
+exports.LedgerReplayEnvironmentBuilder = LedgerReplayEnvironmentBuilder;
+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,
+    };
+}