@hazbase/simplicity 0.0.1 → 0.0.3

package/README.md

@@ -1,4 +1,6 @@
 # @hazbase/simplicity
+[![npm version](https://badge.fury.io/js/@hazbase%2Fsimplicity.svg)](https://badge.fury.io/js/@hazbase%2Fsimplicity)
+[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 
 `@hazbase/simplicity` is a Node.js / TypeScript SDK for working with Simplicity contracts on Liquid with an EVM-like developer workflow. It lets you compile SimplicityHL (`.simf`) contracts, derive the contract address, fund that address, inspect the spend you are about to make, execute the contract, and optionally run fee-sponsored flows through a sponsor wallet or relayer. It also ships with built-in presets so you can start from known-good contract templates before moving to custom `.simf` code.
 
@@ -7,6 +9,22 @@ This SDK is designed to help Node developers get productive quickly, but it is s
 - This SDK currently optimizes for explicit / unblinded success paths first.
 - Gasless support exists, but it comes in multiple modes with different tradeoffs.
 
+Consumer validation note:
+- The published npm package has been validated from a fresh external Node.js project using `npm install @hazbase/simplicity`.
+- Verified flows include preset-based contract execution, custom `.simf` execution, and relayer-backed gasless execution on `liquidtestnet`.
+
+## Validated Scenarios
+
+The published package has been exercised from a blank external consumer project. For the full reproducible fixture, see [docs/consumer-validation/README.md](./docs/consumer-validation/README.md).
+
+| Scenario | Status | Notes |
+| --- | --- | --- |
+| Fresh install + JS import | Success | `npm install @hazbase/simplicity` and `import { createSimplicityClient } from "@hazbase/simplicity"` both worked |
+| CLI smoke | Success | `npx simplicity-cli presets list` worked from the external project |
+| Preset flow (`p2pkLockHeight`) | Success | compile -> fund -> inspect -> execute(`broadcast=true`) |
+| Custom `.simf` flow | Success | `compileFromFile(...)` -> fund -> inspect -> execute(`broadcast=true`) |
+| Relayer-backed gasless flow | Success | `executeGasless(...)` succeeded from the external project |
+
 ## Who This Is For
 
 This README is for you if:
@@ -45,6 +63,77 @@ With the current SDK you can build and test flows such as:
 
 You can also design more advanced systems such as ERC20-like token behavior, but the model is different from Ethereum. On Liquid/Simplicity, you usually represent state transitions as UTXO transitions instead of account storage updates. So the SDK can support that kind of application, but it does not mean you port Solidity account logic 1:1.
 
+## Trusted Definition JSON
+
+When your contract depends on off-chain business metadata such as a bond definition, coupon schedule, note terms, or asset terms, you usually do not want to trust a plain JSON file by itself. This SDK now supports a **hash-anchor** model for definition JSON.
+
+What that means:
+- the SDK canonicalizes the JSON using stable key ordering,
+- computes `sha256(canonicalJson)`,
+- stores that hash in the artifact as a definition anchor,
+- injects `DEFINITION_HASH` and `DEFINITION_ID` into compile-time template vars when a definition is provided,
+- lets you verify later that the JSON you are reading still matches the contract/artifact it was compiled against.
+
+There are now two anchor modes:
+- `artifact-hash-anchor`: the JSON hash is anchored in the artifact and verified later against that artifact.
+- `on-chain-constant-committed`: the JSON hash is anchored in the artifact and also committed into executed contract logic, so it materially affects the compiled program, CMR, and contract address.
+
+Today, `on-chain-constant-committed` is guaranteed for custom `.simf` contracts that include the blessed `require_definition_anchor()` helper pattern. Built-in presets still default to artifact-only anchors for now.
+The SDK does **not** trust artifact JSON alone for this verdict. `trust.onChainAnchorVerified` only becomes `true` when the SDK can read the source file again and re-detect the blessed helper pattern. If the source file is unavailable, the claimed mode may still be `on-chain-constant-committed`, but `onChainAnchorVerified` will remain `false`.
+
+Minimal TypeScript flow:
+
+```ts
+const definition = await sdk.loadDefinition({
+  type: "bond",
+  id: "BOND-2026-001",
+  jsonPath: "./docs/definitions/bond-definition.json",
+});
+
+const compiled = await sdk.compileFromFile({
+  simfPath: "./docs/definitions/bond-anchor.simf",
+  templateVars: {
+    MIN_HEIGHT: 2344430,
+    SIGNER_XONLY: "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
+  },
+  definition: {
+    type: definition.definitionType,
+    id: definition.definitionId,
+    schemaVersion: definition.schemaVersion,
+    jsonPath: definition.sourcePath,
+    anchorMode: "on-chain-constant-committed",
+  },
+  artifactPath: "./bond.artifact.json",
+});
+
+const verification = await sdk.verifyDefinitionAgainstArtifact({
+  artifactPath: "./bond.artifact.json",
+  jsonPath: "./docs/definitions/bond-definition.json",
+  type: "bond",
+  id: "BOND-2026-001",
+});
+
+console.log(verification.ok);
+console.log(verification.trust.effectiveMode);
+```
+
+CLI equivalents:
+
+```bash
+simplicity-cli definition show \
+  --type bond \
+  --id BOND-2026-001 \
+  --json-path ./docs/definitions/bond-definition.json
+
+simplicity-cli definition verify \
+  --artifact ./bond.artifact.json \
+  --type bond \
+  --id BOND-2026-001 \
+  --json-path ./docs/definitions/bond-definition.json
+```
+
+For a bond-oriented walkthrough, see [docs/definitions/README.md](./docs/definitions/README.md).
+
 ## Install
 
 You need three things:
@@ -467,6 +556,12 @@ Use custom `.simf` when:
 - you need your own parameterization,
 - you want to build app-specific wrappers on top of the generic SDK.
 
+A real external-consumer validation of this path has been completed with:
+- a fresh project created outside this repo,
+- a local `contract.simf` file owned by that project,
+- `compileFromFile(...)`,
+- funding + inspect + `broadcast: true` execution.
+
 Recommended path:
 - learn the lifecycle with a preset first,
 - then move to `compileFromFile(...)` once the model is clear.
@@ -714,6 +809,15 @@ These examples are included to help you jump to the right workflow quickly.
 - [execute-htlc.ts](./examples/execute-htlc.ts): HTLC preset with custom witness values.
 - [execute-transfer-with-timeout-cooperative.ts](./examples/execute-transfer-with-timeout-cooperative.ts): cooperative multi-witness timeout flow.
 - [gasless-transfer.ts](./examples/gasless-transfer.ts): standard relayer-backed gasless L-BTC transfer.
+- [define-bond.ts](./examples/define-bond.ts): compile a bond example with a trusted definition hash anchor.
+- [show-bond-definition.ts](./examples/show-bond-definition.ts): verify and retrieve a trusted bond definition from JSON + artifact.
+
+In addition to the in-repo examples, the package has also been validated from a blank external consumer project with:
+- `npm install @hazbase/simplicity`
+- JS/TS import of `createSimplicityClient`
+- preset compile -> fund -> inspect -> execute
+- custom `.simf` compile -> fund -> inspect -> execute
+- relayer-backed gasless execution
 
 ## FAQ / Practical Notes
 
@@ -729,6 +833,16 @@ It means: compile the contract, derive its address, then fund that address with
 
 An artifact is the contract's compile output plus the metadata needed to reload, inspect, and execute it later. Think of it as the bridge between compilation time and on-chain execution time.
 
+When you compile with `definition: { ... }`, the artifact also carries:
+- `definitionType`
+- `definitionId`
+- `schemaVersion`
+- `hash`
+- `trustMode`
+- `anchorMode`
+
+That is what allows the SDK and CLI to verify that an off-chain JSON definition still matches the contract you compiled.
+
 ### When should I use a preset instead of a custom `.simf` file?
 
 Use a preset first when you are learning the lifecycle or your use case already matches a built-in contract. Move to custom `.simf` when your business rules are app-specific.

package/dist/cli.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
 const artifact_1 = require("./core/artifact");
+const definition_1 = require("./core/definition");
 const presets_1 = require("./core/presets");
 const errors_1 = require("./core/errors");
 const SimplicityClient_1 = require("./client/SimplicityClient");
@@ -65,6 +66,25 @@ function parseWitnessSigners(values) {
         return [name, { type: "schnorrPrivkeyHex", privkeyHex }];
     }));
 }
+function parseDefinitionInput() {
+    const type = getArg("definition-type");
+    const id = getArg("definition-id");
+    const jsonPath = getArg("definition-json");
+    const valueJson = getArg("definition-value");
+    const schemaVersion = getArg("definition-schema-version");
+    const anchorMode = getArg("definition-anchor-mode");
+    if (!type && !id && !jsonPath && !valueJson && !schemaVersion && !anchorMode) {
+        return undefined;
+    }
+    return {
+        type: type ?? "",
+        id: id ?? "",
+        schemaVersion: schemaVersion ?? undefined,
+        jsonPath,
+        value: valueJson ? JSON.parse(valueJson) : undefined,
+        anchorMode,
+    };
+}
 function resolveConfig() {
     return {
         network: getArg("network", "liquidtestnet"),
@@ -357,6 +377,18 @@ function formatArtifactHelp(artifact, preset, utxos) {
         `  status: ${status}`,
         `  ready: ${ready ? "yes" : "no"}`,
     ].join("\n");
+    const definition = artifact.definition
+        ? [
+            `  type: ${artifact.definition.definitionType}`,
+            `  id: ${artifact.definition.definitionId}`,
+            `  schema version: ${artifact.definition.schemaVersion}`,
+            `  hash: ${artifact.definition.hash}`,
+            `  trust mode: ${artifact.definition.trustMode}`,
+            `  anchor mode: ${artifact.definition.anchorMode}`,
+            `  on-chain helper: ${artifact.definition.onChainAnchor?.helper ?? "(none)"}`,
+            `  source verified: ${artifact.definition.onChainAnchor?.sourceVerified === true ? "yes" : "no"}`,
+        ].join("\n")
+        : "  (none)";
     const compileSource = artifact.source.simfPath ?? artifact.legacy?.simfTemplatePath ?? "(unknown)";
     const templateVars = artifact.source.templateVars ?? {};
     const inspectCommand = `simplicity-cli contract inspect --artifact ./artifact.json --wallet simplicity-test --privkey <privkey-hex> --to-address tex1...`;
@@ -375,6 +407,9 @@ function formatArtifactHelp(artifact, preset, utxos) {
         "Template Vars:",
         indent(JSON.stringify(templateVars, null, 2)),
         "",
+        "Definition Anchor:",
+        definition,
+        "",
         "Suggested Commands:",
         `  ${inspectCommand}`,
         `  ${executeCommand}`,
@@ -416,17 +451,52 @@ async function main() {
     const subcommand = process.argv[3];
     const sdk = (0, SimplicityClient_1.createSimplicityClient)(resolveConfig());
     if (!command) {
-        throw new Error("Usage: simplicity-cli <compile|presets|preset|contract|artifact|gasless> ...");
+        throw new Error("Usage: simplicity-cli <compile|presets|preset|contract|artifact|definition|gasless> ...");
     }
     if (command === "compile") {
         const result = await sdk.compileFromFile({
             simfPath: requireArg("simf"),
             templateVars: parseAssignments(getMultiArgs("template-var")),
             artifactPath: getArg("artifact"),
+            definition: parseDefinitionInput(),
         });
         printJson({ artifact: result.artifact, deployment: result.deployment() });
         return;
     }
+    if (command === "definition" && subcommand === "show") {
+        const definition = await (0, definition_1.loadDefinitionInput)({
+            type: requireArg("type"),
+            id: requireArg("id"),
+            jsonPath: getArg("json-path"),
+            value: getArg("value") ? JSON.parse(getArg("value")) : undefined,
+            schemaVersion: getArg("schema-version"),
+        });
+        printJson({
+            ...definition,
+            anchorRecommendation: "Use --definition-anchor-mode on-chain-constant-committed with a blessed custom .simf helper for on-chain enforcement",
+        });
+        return;
+    }
+    if (command === "definition" && subcommand === "verify") {
+        const verification = await sdk.verifyDefinitionAgainstArtifact({
+            artifactPath: requireArg("artifact"),
+            type: getArg("type"),
+            id: getArg("id"),
+            expectedType: getArg("expected-type"),
+            expectedId: getArg("expected-id"),
+            jsonPath: getArg("json-path"),
+            value: getArg("value") ? JSON.parse(getArg("value")) : undefined,
+            schemaVersion: getArg("schema-version"),
+        });
+        printJson({
+            verified: verification.ok,
+            reason: verification.reason,
+            definition: verification.definition,
+            artifactDefinition: verification.artifactDefinition ?? null,
+            trust: verification.trust,
+        });
+        return;
+    }
     if (command === "presets" && subcommand === "list") {
         printJson((0, presets_1.listPresets)().map((preset) => (0, presets_1.describePreset)(preset)));
         return;
@@ -472,6 +542,7 @@ async function main() {
             preset: requireArg("preset"),
             params,
             artifactPath: getArg("artifact"),
+            definition: parseDefinitionInput(),
         });
         printJson({ artifact: result.artifact, deployment: result.deployment() });
         return;

package/dist/client/ContractFactory.d.ts

@@ -1,4 +1,4 @@
-import { DeploymentInfo, SimplicityArtifact, SimplicityClientConfig } from "../core/types";
+import { ArtifactDefinitionMetadata, DeploymentInfo, SimplicityArtifact, SimplicityClientConfig } from "../core/types";
 import { DeployedContract } from "./DeployedContract";
 export declare class CompiledContract {
     private readonly config;
@@ -7,6 +7,7 @@ export declare class CompiledContract {
     get contractAddress(): string;
     get cmr(): string;
     get program(): string;
+    definition(): ArtifactDefinitionMetadata | null;
     deployment(): DeploymentInfo;
     saveArtifact(path: string): Promise<void>;
     at(addressOverride?: string): DeployedContract;

package/dist/client/ContractFactory.js

@@ -19,6 +19,9 @@ class CompiledContract {
     get program() {
         return this.artifact.compiled.program;
     }
+    definition() {
+        return this.artifact.definition ?? null;
+    }
     deployment() {
         return {
             contractAddress: this.artifact.compiled.contractAddress,

package/dist/client/DeployedContract.d.ts

@@ -1,4 +1,5 @@
-import { ContractUtxo, ExecuteCallInput, ExecuteResult, GaslessExecuteInput, GaslessExecuteResult, InspectCallInput, InspectResult, SimplicityArtifact, SimplicityClientConfig, WaitForFundingInput } from "../core/types";
+import { verifyDefinitionAgainstArtifact } from "../core/definition";
+import { ArtifactDefinitionMetadata, ContractUtxo, ExecuteCallInput, ExecuteResult, GaslessExecuteInput, GaslessExecuteResult, InspectCallInput, InspectResult, SimplicityArtifact, SimplicityClientConfig, WaitForFundingInput } from "../core/types";
 export declare class DeployedContract {
     private readonly config;
     readonly artifact: SimplicityArtifact;
@@ -9,4 +10,17 @@ export declare class DeployedContract {
     inspectCall(input: InspectCallInput): Promise<InspectResult>;
     execute(input: ExecuteCallInput): Promise<ExecuteResult>;
     executeGasless(input: GaslessExecuteInput): Promise<GaslessExecuteResult>;
+    getTrustedDefinition(input: {
+        jsonPath?: string;
+        value?: unknown;
+        type?: string;
+        id?: string;
+        schemaVersion?: string;
+    }): Promise<{
+        verified: boolean;
+        definition: Awaited<ReturnType<typeof verifyDefinitionAgainstArtifact>>["definition"];
+        artifactDefinition: ArtifactDefinitionMetadata | null;
+        reason?: string;
+        trust: Awaited<ReturnType<typeof verifyDefinitionAgainstArtifact>>["trust"];
+    }>;
 }

package/dist/client/DeployedContract.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeployedContract = void 0;
 const executor_1 = require("../core/executor");
+const definition_1 = require("../core/definition");
 const executor_2 = require("../core/executor");
 class DeployedContract {
     config;
@@ -39,5 +40,26 @@ class DeployedContract {
     async executeGasless(input) {
         return (0, executor_2.executeGaslessContractCall)(this.config, this.artifact, input);
     }
+    async getTrustedDefinition(input) {
+        const verification = await (0, definition_1.verifyDefinitionAgainstArtifact)({
+            artifact: this.artifact,
+            definition: {
+                type: input.type ?? this.artifact.definition?.definitionType ?? "",
+                id: input.id ?? this.artifact.definition?.definitionId ?? "",
+                schemaVersion: input.schemaVersion,
+                jsonPath: input.jsonPath,
+                value: input.value,
+            },
+            expectedType: this.artifact.definition?.definitionType,
+            expectedId: this.artifact.definition?.definitionId,
+        });
+        return {
+            verified: verification.ok,
+            definition: verification.definition,
+            artifactDefinition: verification.artifactDefinition ?? null,
+            reason: verification.reason,
+            trust: verification.trust,
+        };
+    }
 }
 exports.DeployedContract = DeployedContract;

package/dist/client/SimplicityClient.d.ts

@@ -1,5 +1,5 @@
 import { ElementsRpcClient } from "../core/rpc";
-import { CompileFromFileInput, CompileFromPresetInput, SimplicityArtifact, SimplicityClientConfig } from "../core/types";
+import { DefinitionInput, DefinitionVerificationResult, CompileFromFileInput, CompileFromPresetInput, DefinitionDescriptor, SimplicityArtifact, SimplicityClientConfig } from "../core/types";
 import { RelayerClient } from "../gasless/RelayerClient";
 import { GaslessTransferInput, GaslessTransferResult, RelayerClientConfig } from "../gasless/types";
 import { CompiledContract } from "./ContractFactory";
@@ -14,6 +14,19 @@ export declare class SimplicityClient {
     compileFromFile(input: CompileFromFileInput): Promise<CompiledContract>;
     compileFromPreset(input: CompileFromPresetInput): Promise<CompiledContract>;
     loadArtifact(path: string): Promise<CompiledContract>;
+    define(input: DefinitionInput): Promise<DefinitionDescriptor>;
+    loadDefinition(input: DefinitionInput): Promise<DefinitionDescriptor>;
+    verifyDefinitionAgainstArtifact(input: {
+        artifactPath?: string;
+        artifact?: SimplicityArtifact;
+        jsonPath?: string;
+        value?: unknown;
+        expectedType?: string;
+        expectedId?: string;
+        type?: string;
+        id?: string;
+        schemaVersion?: string;
+    }): Promise<DefinitionVerificationResult>;
     fromArtifact(artifact: SimplicityArtifact): DeployedContract;
     relayer(config: RelayerClientConfig): RelayerClient;
     private gaslessTransfer;

package/dist/client/SimplicityClient.js

@@ -4,6 +4,8 @@ exports.SimplicityClient = void 0;
 exports.createSimplicityClient = createSimplicityClient;
 const artifact_1 = require("../core/artifact");
 const compiler_1 = require("../core/compiler");
+const definition_1 = require("../core/definition");
+const errors_1 = require("../core/errors");
 const rpc_1 = require("../core/rpc");
 const RelayerClient_1 = require("../gasless/RelayerClient");
 const ContractFactory_1 = require("./ContractFactory");
@@ -31,6 +33,30 @@ class SimplicityClient {
         const artifact = await (0, artifact_1.loadArtifact)(path, this.config.network);
         return new ContractFactory_1.CompiledContract(this.config, artifact);
     }
+    async define(input) {
+        return (0, definition_1.loadDefinitionInput)(input);
+    }
+    async loadDefinition(input) {
+        return (0, definition_1.loadDefinitionInput)(input);
+    }
+    async verifyDefinitionAgainstArtifact(input) {
+        const artifact = input.artifact ?? (input.artifactPath ? await (0, artifact_1.loadArtifact)(input.artifactPath, this.config.network) : undefined);
+        if (!artifact) {
+            throw new errors_1.ValidationError("artifactPath or artifact is required");
+        }
+        return (0, definition_1.verifyDefinitionAgainstArtifact)({
+            artifact,
+            definition: {
+                type: input.type ?? input.expectedType ?? artifact.definition?.definitionType ?? "",
+                id: input.id ?? input.expectedId ?? artifact.definition?.definitionId ?? "",
+                schemaVersion: input.schemaVersion,
+                jsonPath: input.jsonPath,
+                value: input.value,
+            },
+            expectedType: input.expectedType,
+            expectedId: input.expectedId,
+        });
+    }
     fromArtifact(artifact) {
         return new DeployedContract_1.DeployedContract(this.config, artifact);
     }

package/dist/core/artifact.js

@@ -17,7 +17,16 @@ function isArtifactV5(value) {
 }
 function normalizeArtifact(artifact, networkDefault = "liquidtestnet") {
     if (artifact.version === exports.SDK_ARTIFACT_VERSION) {
-        return artifact;
+        const current = artifact;
+        return {
+            ...current,
+            definition: current.definition
+                ? {
+                    ...current.definition,
+                    anchorMode: current.definition.anchorMode ?? "artifact-hash-anchor",
+                }
+                : undefined,
+        };
     }
     if (!isArtifactV5(artifact)) {
         throw new errors_1.ArtifactError("Unsupported artifact version", artifact);
@@ -55,6 +64,7 @@ function normalizeArtifact(artifact, networkDefault = "liquidtestnet") {
             sdkVersion: exports.SDK_PACKAGE_VERSION,
             notes: null,
         },
+        definition: undefined,
         legacy: {
             simfTemplatePath: artifact.simfTemplatePath,
             params: artifact.params,
@@ -90,6 +100,7 @@ async function loadArtifact(artifactPath, networkDefault = "liquidtestnet") {
                 simfTemplatePath: legacySimfTemplatePath,
             }
             : undefined,
+        definition: normalized.definition,
     };
 }
 async function saveArtifact(artifactPath, artifact) {

package/dist/core/compiler.js

@@ -9,6 +9,7 @@ const promises_1 = require("node:fs/promises");
 const node_os_1 = require("node:os");
 const node_path_1 = __importDefault(require("node:path"));
 const artifact_1 = require("./artifact");
+const definition_1 = require("./definition");
 const errors_1 = require("./errors");
 const presets_1 = require("./presets");
 const templating_1 = require("./templating");
@@ -67,6 +68,12 @@ async function buildArtifact(input) {
             sdkVersion: artifact_1.SDK_PACKAGE_VERSION,
             notes: null,
         },
+        definition: input.definition
+            ? (0, definition_1.buildArtifactDefinitionMetadata)(input.definition, {
+                anchorMode: input.definition.anchorMode,
+                onChainAnchor: input.definition.onChainAnchor,
+            })
+            : undefined,
         legacy: {
             simfTemplatePath: input.sourceSimfPath,
             params: {
@@ -77,8 +84,38 @@ async function buildArtifact(input) {
     }, input.config.network);
 }
 async function compileFromFile(config, input) {
+    const definition = input.definition ? await (0, definition_1.loadDefinitionInput)(input.definition) : undefined;
+    if (definition && input.templateVars?.DEFINITION_HASH !== undefined) {
+        throw new errors_1.ValidationError("DEFINITION_HASH must not be provided explicitly when definition metadata is supplied", { code: "DEFINITION_HASH_OVERRIDE_FORBIDDEN" });
+    }
+    if (definition && input.templateVars?.DEFINITION_ID !== undefined) {
+        throw new errors_1.ValidationError("DEFINITION_ID must not be provided explicitly when definition metadata is supplied", { code: "DEFINITION_ID_OVERRIDE_FORBIDDEN" });
+    }
     const rawSource = await (0, promises_1.readFile)(input.simfPath, "utf8");
-    const rendered = (0, templating_1.renderTemplate)(rawSource, input.templateVars ?? {});
+    let onChainAnchor;
+    if (input.definition?.anchorMode === "on-chain-constant-committed") {
+        const detection = (0, definition_1.detectOnChainDefinitionAnchor)(rawSource);
+        if (!rawSource.includes("{{DEFINITION_HASH}}")) {
+            throw new errors_1.ValidationError("Requested on-chain constant-committed definition anchor, but the .simf source does not contain {{DEFINITION_HASH}}", { code: "DEFINITION_HASH_PLACEHOLDER_MISSING" });
+        }
+        if (!detection.sourceVerified || !detection.helper) {
+            const code = detection.reason?.includes("called")
+                ? "DEFINITION_ONCHAIN_HELPER_NOT_CALLED"
+                : "DEFINITION_ONCHAIN_HELPER_MISSING";
+            throw new errors_1.ValidationError(`Requested on-chain constant-committed definition anchor, but the .simf source does not contain the required anchor helper pattern: ${detection.reason ?? "unknown reason"}`, { code });
+        }
+        onChainAnchor = {
+            helper: detection.helper,
+            templateVar: "DEFINITION_HASH",
+            sourceVerified: true,
+        };
+    }
+    const templateVars = {
+        ...(input.templateVars ?? {}),
+        ...(definition && input.templateVars?.DEFINITION_HASH === undefined ? { DEFINITION_HASH: definition.hash } : {}),
+        ...(definition && input.templateVars?.DEFINITION_ID === undefined ? { DEFINITION_ID: definition.definitionId } : {}),
+    };
+    const rendered = (0, templating_1.renderTemplate)(rawSource, templateVars);
     const workDir = await (0, promises_1.mkdtemp)(node_path_1.default.join((0, node_os_1.tmpdir)(), "simplicity-sdk-compile-"));
     const renderedPath = node_path_1.default.join(workDir, node_path_1.default.basename(input.simfPath));
     await (0, promises_1.writeFile)(renderedPath, rendered, "utf8");
@@ -87,7 +124,14 @@ async function compileFromFile(config, input) {
         renderedSimfPath: renderedPath,
         sourceMode: "file",
         sourceSimfPath: input.simfPath,
-        templateVars: input.templateVars,
+        templateVars,
+        definition: definition
+            ? {
+                ...definition,
+                anchorMode: input.definition?.anchorMode ?? "artifact-hash-anchor",
+                onChainAnchor,
+            }
+            : undefined,
     });
     if (input.artifactPath) {
         await (0, artifact_1.saveArtifact)(input.artifactPath, artifact);
@@ -96,7 +140,21 @@ async function compileFromFile(config, input) {
 }
 async function compileFromPreset(config, input) {
     const preset = (0, presets_1.getPresetOrThrow)(input.preset);
-    const params = (0, presets_1.validatePresetParams)(preset, input.params);
+    if (input.definition?.anchorMode === "on-chain-constant-committed") {
+        throw new errors_1.UnsupportedFeatureError(`Preset '${preset.id}' does not yet support on-chain constant-committed definition anchors`, { code: "DEFINITION_ANCHOR_MODE_UNSUPPORTED_FOR_PRESET", preset: preset.id });
+    }
+    const definition = input.definition ? await (0, definition_1.loadDefinitionInput)(input.definition) : undefined;
+    if (definition && input.params.DEFINITION_HASH !== undefined) {
+        throw new errors_1.ValidationError("DEFINITION_HASH must not be provided explicitly when definition metadata is supplied", { code: "DEFINITION_HASH_OVERRIDE_FORBIDDEN" });
+    }
+    if (definition && input.params.DEFINITION_ID !== undefined) {
+        throw new errors_1.ValidationError("DEFINITION_ID must not be provided explicitly when definition metadata is supplied", { code: "DEFINITION_ID_OVERRIDE_FORBIDDEN" });
+    }
+    const params = {
+        ...(0, presets_1.validatePresetParams)(preset, input.params),
+        ...(definition && input.params.DEFINITION_HASH === undefined ? { DEFINITION_HASH: definition.hash } : {}),
+        ...(definition && input.params.DEFINITION_ID === undefined ? { DEFINITION_ID: definition.definitionId } : {}),
+    };
     const rawSource = await (0, promises_1.readFile)(preset.simfTemplatePath, "utf8");
     const rendered = (0, templating_1.renderTemplate)(rawSource, params);
     const workDir = await (0, promises_1.mkdtemp)(node_path_1.default.join((0, node_os_1.tmpdir)(), "simplicity-sdk-preset-"));
@@ -109,6 +167,12 @@ async function compileFromPreset(config, input) {
         sourceSimfPath: preset.simfTemplatePath,
         preset: preset.id,
         templateVars: params,
+        definition: definition
+            ? {
+                ...definition,
+                anchorMode: input.definition?.anchorMode ?? "artifact-hash-anchor",
+            }
+            : undefined,
     });
     if (input.artifactPath) {
         await (0, artifact_1.saveArtifact)(input.artifactPath, artifact);

package/dist/core/definition.d.ts

@@ -0,0 +1,18 @@
+import { ArtifactDefinitionMetadata, DefinitionAnchorMode, DefinitionDescriptor, DefinitionInput, DefinitionVerificationResult, SimplicityArtifact } from "./types";
+export declare function loadDefinitionInput(input: DefinitionInput): Promise<DefinitionDescriptor>;
+export declare function detectOnChainDefinitionAnchor(simfSource: string): {
+    sourceVerified: boolean;
+    helper?: "nonzero-eq_256";
+    reason?: string;
+};
+export declare function buildArtifactDefinitionMetadata(definition: DefinitionDescriptor, options?: {
+    anchorMode?: DefinitionAnchorMode;
+    onChainAnchor?: ArtifactDefinitionMetadata["onChainAnchor"];
+}): ArtifactDefinitionMetadata;
+export declare function verifyDefinitionDescriptorAgainstArtifact(definition: DefinitionDescriptor, artifactDefinition?: ArtifactDefinitionMetadata, expectedType?: string, expectedId?: string): DefinitionVerificationResult;
+export declare function verifyDefinitionAgainstArtifact(input: {
+    artifact: SimplicityArtifact;
+    definition: DefinitionInput;
+    expectedType?: string;
+    expectedId?: string;
+}): Promise<DefinitionVerificationResult>;

package/dist/core/definition.js

@@ -0,0 +1,279 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadDefinitionInput = loadDefinitionInput;
+exports.detectOnChainDefinitionAnchor = detectOnChainDefinitionAnchor;
+exports.buildArtifactDefinitionMetadata = buildArtifactDefinitionMetadata;
+exports.verifyDefinitionDescriptorAgainstArtifact = verifyDefinitionDescriptorAgainstArtifact;
+exports.verifyDefinitionAgainstArtifact = verifyDefinitionAgainstArtifact;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("./errors");
+const summary_1 = require("./summary");
+const DEFAULT_SCHEMA_VERSION = "1";
+const DEFAULT_ANCHOR_MODE = "artifact-hash-anchor";
+const ZERO_HASH_256 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+function stripComments(source) {
+    return source
+        .replace(/\/\*[\s\S]*?\*\//g, "")
+        .replace(/(^|[^:])\/\/.*$/gm, "$1");
+}
+function extractFunctionBody(source, functionName) {
+    const marker = `fn ${functionName}()`;
+    const start = source.indexOf(marker);
+    if (start === -1)
+        return null;
+    const braceStart = source.indexOf("{", start);
+    if (braceStart === -1)
+        return null;
+    let depth = 0;
+    for (let i = braceStart; i < source.length; i += 1) {
+        const char = source[i];
+        if (char === "{")
+            depth += 1;
+        if (char === "}") {
+            depth -= 1;
+            if (depth === 0) {
+                return source.slice(braceStart + 1, i);
+            }
+        }
+    }
+    return null;
+}
+function assertNonEmpty(value, fieldName) {
+    if (!value || value.trim().length === 0) {
+        throw new errors_1.DefinitionError(`${fieldName} must not be empty`);
+    }
+    return value;
+}
+function ensureSerializable(value, seen = new WeakSet()) {
+    if (value === undefined) {
+        throw new errors_1.DefinitionError("Definition JSON must not contain undefined values");
+    }
+    if (value === null)
+        return;
+    if (typeof value === "bigint") {
+        throw new errors_1.DefinitionError("Definition JSON must not contain bigint values");
+    }
+    if (value instanceof Date) {
+        throw new errors_1.DefinitionError("Definition JSON must not contain Date objects; normalize them first");
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value)
+            ensureSerializable(entry, seen);
+        return;
+    }
+    if (typeof value === "object") {
+        const objectValue = value;
+        if (seen.has(objectValue)) {
+            throw new errors_1.DefinitionError("Definition JSON must not contain circular references");
+        }
+        seen.add(objectValue);
+        for (const entry of Object.values(objectValue))
+            ensureSerializable(entry, seen);
+    }
+}
+async function resolveDefinitionValue(input) {
+    if ((input.jsonPath ? 1 : 0) + (input.value !== undefined ? 1 : 0) !== 1) {
+        throw new errors_1.DefinitionError("Exactly one of jsonPath or value must be provided");
+    }
+    if (input.jsonPath) {
+        const sourcePath = node_path_1.default.resolve(input.jsonPath);
+        const raw = await (0, promises_1.readFile)(sourcePath, "utf8");
+        try {
+            return { value: JSON.parse(raw), sourcePath };
+        }
+        catch (error) {
+            throw new errors_1.DefinitionError(`Failed to parse definition JSON at ${sourcePath}`, error);
+        }
+    }
+    return { value: input.value };
+}
+async function loadDefinitionInput(input) {
+    const definitionType = assertNonEmpty(input.type, "definition.type");
+    const definitionId = assertNonEmpty(input.id, "definition.id");
+    const schemaVersion = assertNonEmpty(input.schemaVersion ?? DEFAULT_SCHEMA_VERSION, "definition.schemaVersion");
+    const { value, sourcePath } = await resolveDefinitionValue(input);
+    ensureSerializable(value);
+    const canonicalJson = (0, summary_1.stableStringify)(value);
+    return {
+        definitionType,
+        definitionId,
+        schemaVersion,
+        canonicalJson,
+        hash: (0, summary_1.sha256HexUtf8)(canonicalJson),
+        sourcePath,
+    };
+}
+function detectOnChainDefinitionAnchor(simfSource) {
+    const source = stripComments(simfSource.replace(/\r\n/g, "\n"));
+    if (!source.includes("{{DEFINITION_HASH}}")) {
+        return { sourceVerified: false, reason: "DEFINITION_HASH placeholder is missing" };
+    }
+    const helperBody = extractFunctionBody(source, "require_definition_anchor");
+    if (!helperBody) {
+        return { sourceVerified: false, reason: "Required anchor helper function is missing" };
+    }
+    if (!helperBody.includes("let anchored_definition_hash: u256 = 0x{{DEFINITION_HASH}};")) {
+        return { sourceVerified: false, reason: "Required anchored_definition_hash assignment is missing" };
+    }
+    if (!helperBody.includes(`let zero_hash: u256 = ${ZERO_HASH_256};`)) {
+        return { sourceVerified: false, reason: "Required zero_hash assignment is missing" };
+    }
+    if (!helperBody.includes("assert!(not(jet::eq_256(anchored_definition_hash, zero_hash)));")) {
+        return { sourceVerified: false, reason: "Required eq_256 assertion is missing" };
+    }
+    const mainBody = extractFunctionBody(source, "main");
+    if (!mainBody) {
+        return { sourceVerified: false, reason: "main function is missing" };
+    }
+    if (!mainBody.includes("require_definition_anchor();")) {
+        return { sourceVerified: false, reason: "require_definition_anchor() is not called from main" };
+    }
+    return { sourceVerified: true, helper: "nonzero-eq_256" };
+}
+function buildArtifactDefinitionMetadata(definition, options) {
+    return {
+        definitionType: definition.definitionType,
+        definitionId: definition.definitionId,
+        schemaVersion: definition.schemaVersion,
+        hash: definition.hash,
+        trustMode: "hash-anchor",
+        anchorMode: options?.anchorMode ?? DEFAULT_ANCHOR_MODE,
+        onChainAnchor: options?.onChainAnchor,
+    };
+}
+function verifyDefinitionDescriptorAgainstArtifact(definition, artifactDefinition, expectedType, expectedId) {
+    const noDefinitionTrust = {
+        artifactMatch: false,
+        onChainAnchorPresent: false,
+        onChainAnchorVerified: false,
+        effectiveMode: "none",
+    };
+    if (expectedType && expectedType !== definition.definitionType) {
+        return {
+            ok: false,
+            reason: `Definition type mismatch: expected=${expectedType} actual=${definition.definitionType}`,
+            definition,
+            artifactDefinition,
+            trust: noDefinitionTrust,
+        };
+    }
+    if (expectedId && expectedId !== definition.definitionId) {
+        return {
+            ok: false,
+            reason: `Definition id mismatch: expected=${expectedId} actual=${definition.definitionId}`,
+            definition,
+            artifactDefinition,
+            trust: noDefinitionTrust,
+        };
+    }
+    if (!artifactDefinition) {
+        return {
+            ok: false,
+            reason: "Artifact does not contain definition metadata",
+            definition,
+            trust: noDefinitionTrust,
+        };
+    }
+    const trust = {
+        artifactMatch: false,
+        onChainAnchorPresent: artifactDefinition.anchorMode === "on-chain-constant-committed",
+        onChainAnchorVerified: false,
+        effectiveMode: artifactDefinition.anchorMode,
+    };
+    if (artifactDefinition.definitionType !== definition.definitionType) {
+        return {
+            ok: false,
+            reason: `Definition type mismatch: artifact=${artifactDefinition.definitionType} actual=${definition.definitionType}`,
+            definition,
+            artifactDefinition,
+            trust,
+        };
+    }
+    if (artifactDefinition.definitionId !== definition.definitionId) {
+        return {
+            ok: false,
+            reason: `Definition id mismatch: artifact=${artifactDefinition.definitionId} actual=${definition.definitionId}`,
+            definition,
+            artifactDefinition,
+            trust,
+        };
+    }
+    if (artifactDefinition.schemaVersion !== definition.schemaVersion) {
+        return {
+            ok: false,
+            reason: `Definition schemaVersion mismatch: artifact=${artifactDefinition.schemaVersion} actual=${definition.schemaVersion}`,
+            definition,
+            artifactDefinition,
+            trust,
+        };
+    }
+    if (artifactDefinition.hash !== definition.hash) {
+        return {
+            ok: false,
+            reason: `Definition hash mismatch: artifact=${artifactDefinition.hash} actual=${definition.hash}`,
+            definition,
+            artifactDefinition,
+            trust,
+        };
+    }
+    return {
+        ok: true,
+        definition,
+        artifactDefinition,
+        trust: {
+            ...trust,
+            artifactMatch: true,
+        },
+    };
+}
+async function resolveDefinitionTrust(artifact, baseTrust) {
+    if (!artifact.definition) {
+        return {
+            artifactMatch: false,
+            onChainAnchorPresent: false,
+            onChainAnchorVerified: false,
+            effectiveMode: "none",
+        };
+    }
+    if (artifact.definition.anchorMode !== "on-chain-constant-committed") {
+        return baseTrust;
+    }
+    if (artifact.source.mode !== "file" || !artifact.source.simfPath) {
+        return {
+            ...baseTrust,
+            onChainAnchorPresent: true,
+            onChainAnchorVerified: false,
+            effectiveMode: "on-chain-constant-committed",
+        };
+    }
+    try {
+        const source = await (0, promises_1.readFile)(artifact.source.simfPath, "utf8");
+        const detection = detectOnChainDefinitionAnchor(source);
+        return {
+            ...baseTrust,
+            onChainAnchorPresent: true,
+            onChainAnchorVerified: detection.sourceVerified === true,
+            effectiveMode: "on-chain-constant-committed",
+        };
+    }
+    catch {
+        return {
+            ...baseTrust,
+            onChainAnchorPresent: true,
+            onChainAnchorVerified: false,
+            effectiveMode: "on-chain-constant-committed",
+        };
+    }
+}
+async function verifyDefinitionAgainstArtifact(input) {
+    const definition = await loadDefinitionInput(input.definition);
+    const result = verifyDefinitionDescriptorAgainstArtifact(definition, input.artifact.definition, input.expectedType, input.expectedId);
+    return {
+        ...result,
+        trust: await resolveDefinitionTrust(input.artifact, result.trust),
+    };
+}

package/dist/core/errors.d.ts

@@ -31,3 +31,9 @@ export declare class ValidationError extends SimplicitySdkError {
 export declare class PresetExecutionError extends SimplicitySdkError {
     constructor(message: string, details?: unknown);
 }
+export declare class DefinitionError extends SimplicitySdkError {
+    constructor(message: string, details?: unknown);
+}
+export declare class DefinitionVerificationError extends SimplicitySdkError {
+    constructor(message: string, details?: unknown);
+}

package/dist/core/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PresetExecutionError = exports.ValidationError = exports.UnsupportedFeatureError = exports.RelayerError = exports.UtxoNotFoundError = exports.ExecutionError = exports.ArtifactError = exports.CompilerError = exports.ToolchainError = exports.SimplicitySdkError = void 0;
+exports.DefinitionVerificationError = exports.DefinitionError = exports.PresetExecutionError = exports.ValidationError = exports.UnsupportedFeatureError = exports.RelayerError = exports.UtxoNotFoundError = exports.ExecutionError = exports.ArtifactError = exports.CompilerError = exports.ToolchainError = exports.SimplicitySdkError = void 0;
 class SimplicitySdkError extends Error {
     code;
     details;
@@ -68,3 +68,15 @@ class PresetExecutionError extends SimplicitySdkError {
     }
 }
 exports.PresetExecutionError = PresetExecutionError;
+class DefinitionError extends SimplicitySdkError {
+    constructor(message, details) {
+        super("DEFINITION_ERROR", message, details);
+    }
+}
+exports.DefinitionError = DefinitionError;
+class DefinitionVerificationError extends SimplicitySdkError {
+    constructor(message, details) {
+        super("DEFINITION_VERIFICATION_ERROR", message, details);
+    }
+}
+exports.DefinitionVerificationError = DefinitionVerificationError;

package/dist/core/executor.js

@@ -202,8 +202,17 @@ function buildPsetSummary(decoded, meta) {
     return {
         network: meta.network,
         purpose: meta.purpose,
-        bondDefinitionId: meta.bondDefinitionId ?? null,
+        bondDefinitionId: meta.definitionType === "bond"
+            ? (meta.definitionId ?? meta.bondDefinitionId ?? null)
+            : (meta.bondDefinitionId ?? null),
         periodId: meta.periodId ?? null,
+        definition: {
+            type: meta.definitionType ?? null,
+            id: meta.definitionId ?? null,
+            hash: meta.definitionHash ?? null,
+            trustMode: meta.definitionTrustMode ?? null,
+            anchorMode: meta.definitionAnchorMode ?? null,
+        },
         contract: {
             address: meta.contractAddress,
             cmr: meta.cmr,
@@ -290,6 +299,11 @@ async function buildExecutionState(config, artifact, input) {
         purpose: input.purpose ?? "sdk_execute",
         bondDefinitionId: input.bondDefinitionId,
         periodId: input.periodId,
+        definitionType: artifact.definition?.definitionType,
+        definitionId: artifact.definition?.definitionId,
+        definitionHash: artifact.definition?.hash,
+        definitionTrustMode: artifact.definition?.trustMode,
+        definitionAnchorMode: artifact.definition?.anchorMode,
         expectedLiquidReceiver: input.expectedLiquidReceiver ?? recipientAddress,
         contractAddress: artifact.compiled.contractAddress,
         cmr: artifact.compiled.cmr,
@@ -440,6 +454,12 @@ async function executeGaslessContractCall(config, artifact, input) {
     const summary = buildPsetSummary(decoded, {
         network: artifact.network,
         purpose: "sdk_gasless_execute",
+        bondDefinitionId: null,
+        definitionType: artifact.definition?.definitionType,
+        definitionId: artifact.definition?.definitionId,
+        definitionHash: artifact.definition?.hash,
+        definitionTrustMode: artifact.definition?.trustMode,
+        definitionAnchorMode: artifact.definition?.anchorMode,
         contractAddress: artifact.compiled.contractAddress,
         cmr: artifact.compiled.cmr,
         internalKey: artifact.compiled.internalKey,
@@ -624,8 +644,15 @@ async function executeRelayedGaslessContractCall(config, artifact, input, relaye
         summary: {
             network: artifact.network,
             purpose: "sdk_gasless_execute_relayer",
-            bondDefinitionId: null,
+            bondDefinitionId: artifact.definition?.definitionType === "bond" ? artifact.definition.definitionId : null,
             periodId: null,
+            definition: {
+                type: artifact.definition?.definitionType ?? null,
+                id: artifact.definition?.definitionId ?? null,
+                hash: artifact.definition?.hash ?? null,
+                trustMode: artifact.definition?.trustMode ?? null,
+                anchorMode: artifact.definition?.anchorMode ?? null,
+            },
             contract: {
                 address: request.detailedSummary.contract.contractAddress,
                 cmr: request.detailedSummary.contract.cmr,

package/dist/core/types.d.ts

@@ -1,5 +1,7 @@
 export type NetworkName = "liquidtestnet" | "liquidv1" | "regtest";
 export type UtxoPolicy = "smallest_over" | "largest" | "newest";
+export type DefinitionTrustMode = "hash-anchor";
+export type DefinitionAnchorMode = "artifact-hash-anchor" | "on-chain-constant-committed";
 export interface RpcConfig {
     url: string;
     username: string;
@@ -68,6 +70,7 @@ export interface SimplicityArtifact {
         sdkVersion: string;
         notes: string | null;
     };
+    definition?: ArtifactDefinitionMetadata;
     legacy?: {
         simfTemplatePath?: string;
         params?: {
@@ -81,11 +84,42 @@ export interface CompileFromFileInput {
     simfPath: string;
     templateVars?: Record<string, string | number>;
     artifactPath?: string;
+    definition?: DefinitionInput;
 }
 export interface CompileFromPresetInput {
     preset: string;
     params: Record<string, string | number>;
     artifactPath?: string;
+    definition?: DefinitionInput;
+}
+export interface DefinitionInput {
+    type: string;
+    id: string;
+    schemaVersion?: string;
+    jsonPath?: string;
+    value?: unknown;
+    anchorMode?: DefinitionAnchorMode;
+}
+export interface DefinitionDescriptor {
+    definitionType: string;
+    definitionId: string;
+    schemaVersion: string;
+    canonicalJson: string;
+    hash: string;
+    sourcePath?: string;
+}
+export interface ArtifactDefinitionMetadata {
+    definitionType: string;
+    definitionId: string;
+    schemaVersion: string;
+    hash: string;
+    trustMode: DefinitionTrustMode;
+    anchorMode: DefinitionAnchorMode;
+    onChainAnchor?: {
+        helper: "nonzero-eq_256";
+        templateVar: "DEFINITION_HASH";
+        sourceVerified: boolean;
+    };
 }
 export interface DeploymentInfo {
     contractAddress: string;
@@ -151,6 +185,13 @@ export interface PsetSummary {
     purpose?: string;
     bondDefinitionId?: string | null;
     periodId?: string | null;
+    definition?: {
+        type: string | null;
+        id: string | null;
+        hash: string | null;
+        trustMode: DefinitionTrustMode | null;
+        anchorMode: DefinitionAnchorMode | null;
+    };
     contract: {
         address: string;
         cmr: string;
@@ -218,6 +259,18 @@ export interface GaslessExecuteResult {
         amountSat: number;
     };
 }
+export interface DefinitionVerificationResult {
+    ok: boolean;
+    reason?: string;
+    definition: DefinitionDescriptor;
+    artifactDefinition?: ArtifactDefinitionMetadata;
+    trust: {
+        artifactMatch: boolean;
+        onChainAnchorPresent: boolean;
+        onChainAnchorVerified: boolean;
+        effectiveMode: "none" | DefinitionAnchorMode;
+    };
+}
 export interface WaitForFundingInput {
     minAmountSat?: number;
     pollIntervalMs?: number;

package/dist/index.d.ts

@@ -6,3 +6,4 @@ export * from "./core/types";
 export * from "./core/errors";
 export { listPresets, getPresetOrThrow } from "./core/presets";
 export { loadArtifact, saveArtifact, normalizeArtifact } from "./core/artifact";
+export { loadDefinitionInput, buildArtifactDefinitionMetadata, verifyDefinitionAgainstArtifact, verifyDefinitionDescriptorAgainstArtifact, } from "./core/definition";

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeArtifact = exports.saveArtifact = exports.loadArtifact = exports.getPresetOrThrow = exports.listPresets = exports.RelayerClient = exports.DeployedContract = exports.CompiledContract = exports.SimplicityClient = exports.createSimplicityClient = void 0;
+exports.verifyDefinitionDescriptorAgainstArtifact = exports.verifyDefinitionAgainstArtifact = exports.buildArtifactDefinitionMetadata = exports.loadDefinitionInput = exports.normalizeArtifact = exports.saveArtifact = exports.loadArtifact = exports.getPresetOrThrow = exports.listPresets = exports.RelayerClient = exports.DeployedContract = exports.CompiledContract = exports.SimplicityClient = exports.createSimplicityClient = void 0;
 var SimplicityClient_1 = require("./client/SimplicityClient");
 Object.defineProperty(exports, "createSimplicityClient", { enumerable: true, get: function () { return SimplicityClient_1.createSimplicityClient; } });
 Object.defineProperty(exports, "SimplicityClient", { enumerable: true, get: function () { return SimplicityClient_1.SimplicityClient; } });
@@ -33,3 +33,8 @@ var artifact_1 = require("./core/artifact");
 Object.defineProperty(exports, "loadArtifact", { enumerable: true, get: function () { return artifact_1.loadArtifact; } });
 Object.defineProperty(exports, "saveArtifact", { enumerable: true, get: function () { return artifact_1.saveArtifact; } });
 Object.defineProperty(exports, "normalizeArtifact", { enumerable: true, get: function () { return artifact_1.normalizeArtifact; } });
+var definition_1 = require("./core/definition");
+Object.defineProperty(exports, "loadDefinitionInput", { enumerable: true, get: function () { return definition_1.loadDefinitionInput; } });
+Object.defineProperty(exports, "buildArtifactDefinitionMetadata", { enumerable: true, get: function () { return definition_1.buildArtifactDefinitionMetadata; } });
+Object.defineProperty(exports, "verifyDefinitionAgainstArtifact", { enumerable: true, get: function () { return definition_1.verifyDefinitionAgainstArtifact; } });
+Object.defineProperty(exports, "verifyDefinitionDescriptorAgainstArtifact", { enumerable: true, get: function () { return definition_1.verifyDefinitionDescriptorAgainstArtifact; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazbase/simplicity",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "An SDK for Simplicity on Liquid",
   "author": "IndieSquare Inc <info@hazbase.com>",
   "keywords": [
@@ -36,7 +36,8 @@
     "build": "tsc && node scripts/copy-presets.mjs",
     "start": "node dist/cli.js",
     "test": "npm run build && node --test dist/test",
-    "e2e:simplicity-relayer": "npm run build && node scripts/e2e-simplicity-relayer.mjs"
+    "e2e:simplicity-relayer": "npm run build && node scripts/e2e-simplicity-relayer.mjs",
+    "prepublishOnly": "npm run build"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",