@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

package/dist/cjs/testing/campaign/campaign-model.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCampaignModel = createCampaignModel;
+exports.reconcileCampaignModel = reconcileCampaignModel;
+exports.applyAcceptedGhostTransition = applyAcceptedGhostTransition;
+function createCampaignModel(init) {
+    return Object.freeze({
+        ledger: init.ledger,
+        ghost: init.ghost,
+    });
+}
+function reconcileCampaignModel(model, ledger) {
+    return Object.freeze({
+        ledger,
+        ghost: model.ghost,
+    });
+}
+function applyAcceptedGhostTransition(model, outcome, transition) {
+    if (outcome.kind !== "accepted") {
+        return model;
+    }
+    return Object.freeze({
+        ledger: model.ledger,
+        ghost: transition(model.ghost),
+    });
+}

package/dist/cjs/testing/campaign/campaign-runner.js

@@ -0,0 +1,233 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateCampaignInvariantsAsync = evaluateCampaignInvariantsAsync;
+exports.runCampaignCheckAsync = runCampaignCheckAsync;
+exports.runCampaignLifecycleCheckAsync = runCampaignLifecycleCheckAsync;
+exports.runInvariantCampaignCheckAsync = runInvariantCampaignCheckAsync;
+const fc = __importStar(require("fast-check"));
+const campaign_metrics_js_1 = require("./campaign-metrics.js");
+async function evaluateCampaignInvariantsAsync(init) {
+    const failures = [];
+    for (const invariant of init) {
+        try {
+            const failure = await invariant.check();
+            if (failure !== undefined) {
+                failures.push({ invariant: invariant.name, ...failure });
+            }
+        }
+        catch (error) {
+            failures.push({
+                invariant: invariant.name,
+                code: "thrown",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return failures;
+}
+async function runCampaignCheckAsync(init) {
+    const traces = new Map();
+    const details = await fc.check(fc.asyncProperty(init.arbitrary, async (input) => {
+        const result = await init.executeAsync(input);
+        traces.set(init.key(input), result.trace);
+        return result.passed;
+    }), {
+        numRuns: init.numRuns,
+        ...(init.seed === undefined ? {} : { seed: init.seed }),
+        ...(init.path === undefined ? {} : { path: init.path }),
+        ...(init.timeoutMs === undefined
+            ? {}
+            : { interruptAfterTimeLimit: init.timeoutMs }),
+    });
+    const counterexample = details.counterexample?.[0];
+    return {
+        details,
+        ...(counterexample === undefined
+            ? {}
+            : { counterexampleTrace: traces.get(init.key(counterexample)) }),
+    };
+}
+/**
+ * Runs generated fixed-depth action sequences with Foundry-style revert
+ * handling. Runtime-specific setup, reconciliation, and cleanup stay in
+ * caller-provided hooks so this remains usable with any ledger adapter.
+ */
+async function runCampaignLifecycleCheckAsync(init) {
+    return runCampaignCheckAsync({
+        arbitrary: init.arbitrary,
+        key: init.key,
+        numRuns: init.numRuns,
+        path: init.path,
+        seed: init.seed,
+        timeoutMs: init.timeoutMs,
+        executeAsync: async (actions) => runCampaignCandidateAsync(init, actions),
+    });
+}
+/**
+ * Runs a declared invariant campaign and evaluates its invariant functions at
+ * every lifecycle checkpoint. The caller supplies the ledger-specific action
+ * executor and model hydration hooks; the campaign supplies runs, depth,
+ * seed, revert policy, and declared invariants.
+ */
+async function runInvariantCampaignCheckAsync(init) {
+    return runCampaignLifecycleCheckAsync({
+        arbitrary: init.arbitrary,
+        depth: init.campaign.config.depth,
+        failOnRevert: init.campaign.config.failOnRevert,
+        key: init.key,
+        numRuns: init.campaign.config.runs,
+        path: init.campaign.config.path,
+        seed: init.campaign.config.seed,
+        timeoutMs: init.campaign.config.timeoutMs,
+        setupAsync: init.setupAsync,
+        executeAsync: init.executeAsync,
+        cleanupAsync: init.cleanupAsync,
+        reconcileAsync: init.reconcileAsync,
+        checkInvariantsAsync: async (context, phase) => {
+            const declaredFailures = await evaluateCampaignInvariantsAsync(init.campaign.invariants.map((invariant, index) => ({
+                name: invariant.label ?? (invariant.name || `invariant-${index + 1}`),
+                check: async () => {
+                    await invariant({
+                        model: context.model,
+                        ghost: context.ghost,
+                    });
+                    return undefined;
+                },
+            })));
+            const additionalFailures = await init.checkInvariantsAsync?.(context, phase) ?? [];
+            return [...declaredFailures, ...additionalFailures];
+        },
+    });
+}
+async function runCampaignCandidateAsync(init, actions) {
+    const metrics = (0, campaign_metrics_js_1.createCampaignMetrics)();
+    const executed = [];
+    const failures = [];
+    let context;
+    let failureKind;
+    let passed = true;
+    if (actions.length !== init.depth) {
+        return {
+            passed: false,
+            trace: {
+                actions: [],
+                failures: [],
+                metrics,
+                failureKind: "invalid-depth",
+            },
+        };
+    }
+    const checkInvariantsAsync = async (phase) => {
+        if (context === undefined || init.checkInvariantsAsync === undefined) {
+            return;
+        }
+        const phaseFailures = await init.checkInvariantsAsync(context, phase);
+        failures.push(...phaseFailures);
+        if (phaseFailures.length > 0) {
+            passed = false;
+        }
+    };
+    try {
+        context = await init.setupAsync(actions);
+        const beforeRun = { kind: "before-run" };
+        await init.reconcileAsync?.(context, beforeRun);
+        await checkInvariantsAsync(beforeRun);
+        for (const action of actions) {
+            if (!passed) {
+                break;
+            }
+            let outcome;
+            try {
+                outcome = await init.executeAsync(context, action);
+            }
+            catch {
+                outcome = {
+                    kind: "transport-error",
+                    reason: "Campaign action execution threw an error.",
+                };
+            }
+            executed.push({ action, outcome });
+            (0, campaign_metrics_js_1.recordCampaignAction)(metrics, {
+                actor: action.actor,
+                targetKey: action.targetKey,
+                outcome,
+            });
+            const afterAction = { kind: "after-action", action };
+            if (outcome.kind === "accepted") {
+                await init.reconcileAsync?.(context, afterAction);
+            }
+            await checkInvariantsAsync(afterAction);
+            if (outcome.kind !== "accepted"
+                && (outcome.kind !== "protocol-revert" || init.failOnRevert)) {
+                passed = false;
+            }
+        }
+        if (passed) {
+            await checkInvariantsAsync({ kind: "after-run" });
+        }
+    }
+    catch {
+        passed = false;
+        failureKind = "execution-error";
+    }
+    finally {
+        if (context !== undefined) {
+            try {
+                await init.cleanupAsync?.(context);
+            }
+            catch {
+                passed = false;
+                failureKind ??= "execution-error";
+            }
+            try {
+                await checkInvariantsAsync({ kind: "post-cleanup" });
+            }
+            catch {
+                passed = false;
+                failureKind ??= "execution-error";
+            }
+        }
+    }
+    return {
+        passed,
+        trace: {
+            actions: Object.freeze(executed.map((entry) => Object.freeze(entry))),
+            failures: Object.freeze(failures.map((failure) => Object.freeze({ ...failure }))),
+            metrics,
+            ...(failureKind === undefined ? {} : { failureKind }),
+        },
+    };
+}

package/dist/cjs/testing/campaign/campaign-scheduler.js

@@ -0,0 +1,113 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCampaignScheduleArbitrary = createCampaignScheduleArbitrary;
+exports.createInvariantCampaignScheduleArbitrary = createInvariantCampaignScheduleArbitrary;
+exports.scheduleCampaignSlots = scheduleCampaignSlots;
+const fc = __importStar(require("fast-check"));
+/**
+ * Generates exact-depth scheduling inputs with fast-check's seed and shrink
+ * support while delegating all eligibility decisions to the pure scheduler.
+ */
+function createCampaignScheduleArbitrary(init) {
+    if (!Number.isSafeInteger(init.depth) || init.depth < 1) {
+        throw new Error("Campaign schedule depth must be a positive safe integer.");
+    }
+    const roll = fc.integer({ min: 0, max: Number.MAX_SAFE_INTEGER });
+    return fc.tuple(fc.array(roll, { minLength: init.depth, maxLength: init.depth }), fc.array(roll, { minLength: init.depth, maxLength: init.depth })).map(([targetRolls, actorRolls]) => scheduleCampaignSlots({
+        ...init,
+        targetRolls,
+        actorRolls,
+    }));
+}
+/**
+ * Projects a public invariant campaign definition onto generated scheduling
+ * slots. Targets without explicit actors use every configured actor in stable
+ * name order, allowing lightweight read/probe targets to share the campaign
+ * actor matrix.
+ */
+function createInvariantCampaignScheduleArbitrary(campaign, options = {}) {
+    const defaultActors = Object.keys(campaign.runtime.actors).sort();
+    return createCampaignScheduleArbitrary({
+        depth: campaign.config.depth,
+        hasActiveContract: options.hasActiveContract ?? true,
+        targets: campaign.targets.map((target) => ({
+            key: target.key,
+            weight: 1,
+            actors: target.actors ?? defaultActors,
+        })),
+    });
+}
+function scheduleCampaignSlots(init) {
+    if (!Number.isSafeInteger(init.depth) || init.depth < 1) {
+        throw new Error("Campaign schedule depth must be a positive safe integer.");
+    }
+    const eligibleTargets = init.targets.filter((target) => target.weight > 0
+        && target.actors.length > 0
+        && (init.hasActiveContract || target.requiresActiveContract !== true));
+    const totalWeight = eligibleTargets.reduce((sum, target) => sum + target.weight, 0);
+    if (!Number.isSafeInteger(totalWeight)) {
+        throw new Error("Campaign target weights must sum to a safe integer.");
+    }
+    return Array.from({ length: init.depth }, (_, index) => {
+        if (totalWeight === 0) {
+            return { kind: "probe" };
+        }
+        const target = selectByWeight(eligibleTargets, rollAt(init.targetRolls, index), totalWeight);
+        const actor = target.actors[rollAt(init.actorRolls, index) % target.actors.length];
+        return {
+            kind: "target",
+            targetKey: target.key,
+            actor,
+        };
+    });
+}
+function rollAt(rolls, index) {
+    if (rolls.length === 0) {
+        return 0;
+    }
+    const roll = rolls[index % rolls.length];
+    return Number.isSafeInteger(roll) && roll >= 0 ? roll : 0;
+}
+function selectByWeight(targets, roll, totalWeight) {
+    let remaining = roll % totalWeight;
+    for (const target of targets) {
+        if (remaining < target.weight) {
+            return target;
+        }
+        remaining -= target.weight;
+    }
+    throw new Error("Campaign scheduler could not select an eligible target.");
+}

package/dist/cjs/testing/campaign/campaign-types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invariant = invariant;
+function invariant(label, check) {
+    if (label.length === 0) {
+        throw new Error("Invariant campaign invariant names must not be empty.");
+    }
+    const named = (context) => check(context);
+    Object.defineProperty(named, "label", {
+        value: label,
+        enumerable: true,
+    });
+    return Object.freeze(named);
+}

package/dist/cjs/testing/daml/daml-action-arbitrary.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeclarativeActionArbitrary = createDeclarativeActionArbitrary;
+const fc = __importStar(require("fast-check"));
+const daml_choice_action_arbitrary_js_1 = require("./daml-choice-action-arbitrary.js");
+const daml_create_action_arbitrary_js_1 = require("./daml-create-action-arbitrary.js");
+const testing_configuration_error_js_1 = require("../errors/testing-configuration-error.js");
+/**
+ * Combines resolved template-create and template-choice targets into one
+ * shrinkable campaign action arbitrary. Runtime adapters can discriminate the
+ * result by `payload` (create) or `argument` (choice) before submission.
+ */
+function createDeclarativeActionArbitrary(catalog, targets, options = {}) {
+    if (targets.length === 0) {
+        throw new testing_configuration_error_js_1.TestingConfigurationError("Automatic declarative action generation requires at least one target.");
+    }
+    return fc.oneof(...targets.map((target) => {
+        if ("choice" in target) {
+            return (0, daml_choice_action_arbitrary_js_1.createDeclarativeChoiceActionArbitrary)(catalog, target, {
+                ...(options.valueParties === undefined
+                    ? {}
+                    : { valueParties: options.valueParties }),
+            });
+        }
+        return (0, daml_create_action_arbitrary_js_1.createDeclarativeCreateActionArbitrary)(catalog, target, options);
+    }));
+}

package/dist/cjs/testing/daml/daml-choice-action-arbitrary.js

@@ -0,0 +1,66 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeclarativeChoiceActionArbitrary = createDeclarativeChoiceActionArbitrary;
+const fc = __importStar(require("fast-check"));
+const testing_configuration_error_js_1 = require("../errors/testing-configuration-error.js");
+const daml_value_arbitrary_js_1 = require("./daml-value-arbitrary.js");
+/**
+ * Builds a well-typed, actor-routed automatic choice input from declarative
+ * DAML target metadata. Command submission and active-contract selection stay
+ * in the runtime adapter.
+ */
+function createDeclarativeChoiceActionArbitrary(catalog, target, options = {}) {
+    const choice = catalog.getChoice(formatTemplateId(target.templateId), target.choice);
+    if (choice === undefined) {
+        throw new testing_configuration_error_js_1.TestingConfigurationError(`Declarative target '${target.key}' does not exist in the DAML catalog.`);
+    }
+    else if (choice.argumentType === undefined) {
+        throw new testing_configuration_error_js_1.TestingConfigurationError(`Declarative target '${target.key}' has no argument type metadata.`);
+    }
+    else if (target.actors.length === 0) {
+        throw new testing_configuration_error_js_1.TestingConfigurationError(`Declarative target '${target.key}' requires at least one actor.`);
+    }
+    return fc.tuple(fc.constantFrom(...target.actors), (0, daml_value_arbitrary_js_1.createDamlValueArbitrary)(choice.argumentType, options)).map(([actor, argument]) => Object.freeze({
+        actor,
+        argument,
+        choice: target.choice,
+        targetKey: target.key,
+        templateId: target.templateId,
+    }));
+}
+function formatTemplateId(templateId) {
+    return `${templateId.packageId}:${templateId.moduleName}:${templateId.entityName}`;
+}

package/dist/cjs/testing/daml/daml-create-action-arbitrary.js

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeclarativeCreateActionArbitrary = createDeclarativeCreateActionArbitrary;
+const fc = __importStar(require("fast-check"));
+const testing_configuration_error_js_1 = require("../errors/testing-configuration-error.js");
+const daml_value_arbitrary_js_1 = require("./daml-value-arbitrary.js");
+/**
+ * Builds a well-typed, actor-routed automatic create input from declarative
+ * DAML template metadata. Ledger command construction stays in the runtime
+ * adapter.
+ */
+function createDeclarativeCreateActionArbitrary(catalog, target, options = {}) {
+    const template = catalog.getTemplate(formatTemplateId(target.templateId));
+    if (template === undefined) {
+        throw new testing_configuration_error_js_1.TestingConfigurationError(`Declarative target '${target.key}' does not exist in the DAML catalog.`);
+    }
+    else if (target.actors.length === 0) {
+        throw new testing_configuration_error_js_1.TestingConfigurationError(`Declarative target '${target.key}' requires at least one actor.`);
+    }
+    const templateFieldNames = new Set(template.fields.map((field) => field.name));
+    const unknownField = Object.keys(options.fieldArbitraries ?? {})
+        .find((name) => !templateFieldNames.has(name));
+    if (unknownField !== undefined) {
+        throw new testing_configuration_error_js_1.TestingConfigurationError(`Declarative target '${target.key}' has no field generator '${unknownField}'.`);
+    }
+    const payload = fc.record(Object.fromEntries(template.fields.map((field) => [
+        field.name,
+        options.fieldArbitraries?.[field.name]
+            ?? (0, daml_value_arbitrary_js_1.createDamlValueArbitrary)(field.type, options),
+    ])));
+    return fc.tuple(fc.constantFrom(...target.actors), payload).map(([actor, value]) => Object.freeze({
+        actor,
+        payload: Object.freeze(value),
+        targetKey: target.key,
+        templateId: target.templateId,
+    }));
+}
+function formatTemplateId(templateId) {
+    return `${templateId.packageId}:${templateId.moduleName}:${templateId.entityName}`;
+}

package/dist/cjs/testing/daml/daml-testing-catalog.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDamlTestingCatalog = createDamlTestingCatalog;
+function createDamlTestingCatalog(init) {
+    const choices = new Map();
+    const templates = init.getTemplates()
+        .map((template) => {
+        const templateId = formatTemplateId(template.templateId);
+        for (const choice of template.choices) {
+            choices.set(createChoiceKey(templateId, choice.name), Object.freeze({
+                templateId,
+                choice: choice.name,
+                ...(choice.parameter === undefined
+                    ? {}
+                    : { argumentType: choice.parameter.type }),
+            }));
+        }
+        return Object.freeze({
+            templateId,
+            choices: Object.freeze(template.choices.map(({ name }) => name)),
+            fields: Object.freeze((template.fields ?? []).map((field) => Object.freeze({
+                name: field.name,
+                type: field.type,
+            }))),
+        });
+    })
+        .sort((left, right) => left.templateId.localeCompare(right.templateId));
+    return Object.freeze({
+        templates: Object.freeze(templates),
+        getChoice(templateId, choice) {
+            return choices.get(createChoiceKey(templateId, choice));
+        },
+        getTemplate(templateId) {
+            return templates.find((template) => template.templateId === templateId);
+        },
+    });
+}
+function formatTemplateId(value) {
+    return `${value.packageId}:${value.moduleName}:${value.templateName}`;
+}
+function createChoiceKey(templateId, choice) {
+    return `${templateId}:${choice}`;
+}