@hazbase/simplicity 0.0.2 → 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.
 
@@ -72,6 +74,13 @@ What that means:
 - 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
@@ -92,6 +101,7 @@ const compiled = await sdk.compileFromFile({
     id: definition.definitionId,
     schemaVersion: definition.schemaVersion,
     jsonPath: definition.sourcePath,
+    anchorMode: "on-chain-constant-committed",
   },
   artifactPath: "./bond.artifact.json",
 });
@@ -104,6 +114,7 @@ const verification = await sdk.verifyDefinitionAgainstArtifact({
 });
 
 console.log(verification.ok);
+console.log(verification.trust.effectiveMode);
 ```
 
 CLI equivalents:
@@ -828,6 +839,7 @@ When you compile with `definition: { ... }`, the artifact also carries:
 - `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.
 

package/dist/cli.js

@@ -72,7 +72,8 @@ function parseDefinitionInput() {
     const jsonPath = getArg("definition-json");
     const valueJson = getArg("definition-value");
     const schemaVersion = getArg("definition-schema-version");
-    if (!type && !id && !jsonPath && !valueJson && !schemaVersion) {
+    const anchorMode = getArg("definition-anchor-mode");
+    if (!type && !id && !jsonPath && !valueJson && !schemaVersion && !anchorMode) {
         return undefined;
     }
     return {
@@ -81,6 +82,7 @@ function parseDefinitionInput() {
         schemaVersion: schemaVersion ?? undefined,
         jsonPath,
         value: valueJson ? JSON.parse(valueJson) : undefined,
+        anchorMode,
     };
 }
 function resolveConfig() {
@@ -382,6 +384,9 @@ function formatArtifactHelp(artifact, preset, utxos) {
             `  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)";
@@ -466,7 +471,10 @@ async function main() {
             value: getArg("value") ? JSON.parse(getArg("value")) : undefined,
             schemaVersion: getArg("schema-version"),
         });
-        printJson(definition);
+        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") {
@@ -485,6 +493,7 @@ async function main() {
             reason: verification.reason,
             definition: verification.definition,
             artifactDefinition: verification.artifactDefinition ?? null,
+            trust: verification.trust,
         });
         return;
     }

package/dist/client/DeployedContract.d.ts

@@ -21,5 +21,6 @@ export declare class DeployedContract {
         definition: Awaited<ReturnType<typeof verifyDefinitionAgainstArtifact>>["definition"];
         artifactDefinition: ArtifactDefinitionMetadata | null;
         reason?: string;
+        trust: Awaited<ReturnType<typeof verifyDefinitionAgainstArtifact>>["trust"];
     }>;
 }

package/dist/client/DeployedContract.js

@@ -58,6 +58,7 @@ class DeployedContract {
             definition: verification.definition,
             artifactDefinition: verification.artifactDefinition ?? null,
             reason: verification.reason,
+            trust: verification.trust,
         };
     }
 }

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);

package/dist/core/compiler.js

@@ -68,7 +68,12 @@ async function buildArtifact(input) {
             sdkVersion: artifact_1.SDK_PACKAGE_VERSION,
             notes: null,
         },
-        definition: input.definition ? (0, definition_1.buildArtifactDefinitionMetadata)(input.definition) : undefined,
+        definition: input.definition
+            ? (0, definition_1.buildArtifactDefinitionMetadata)(input.definition, {
+                anchorMode: input.definition.anchorMode,
+                onChainAnchor: input.definition.onChainAnchor,
+            })
+            : undefined,
         legacy: {
             simfTemplatePath: input.sourceSimfPath,
             params: {
@@ -80,7 +85,31 @@ async function buildArtifact(input) {
 }
 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");
+    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 } : {}),
@@ -96,7 +125,13 @@ async function compileFromFile(config, input) {
         sourceMode: "file",
         sourceSimfPath: input.simfPath,
         templateVars,
-        definition,
+        definition: definition
+            ? {
+                ...definition,
+                anchorMode: input.definition?.anchorMode ?? "artifact-hash-anchor",
+                onChainAnchor,
+            }
+            : undefined,
     });
     if (input.artifactPath) {
         await (0, artifact_1.saveArtifact)(input.artifactPath, artifact);
@@ -105,7 +140,16 @@ async function compileFromFile(config, input) {
 }
 async function compileFromPreset(config, input) {
     const preset = (0, presets_1.getPresetOrThrow)(input.preset);
+    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 } : {}),
@@ -123,7 +167,12 @@ async function compileFromPreset(config, input) {
         sourceSimfPath: preset.simfTemplatePath,
         preset: preset.id,
         templateVars: params,
-        definition,
+        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

@@ -1,6 +1,14 @@
-import { ArtifactDefinitionMetadata, DefinitionDescriptor, DefinitionInput, DefinitionVerificationResult, SimplicityArtifact } from "./types";
+import { ArtifactDefinitionMetadata, DefinitionAnchorMode, DefinitionDescriptor, DefinitionInput, DefinitionVerificationResult, SimplicityArtifact } from "./types";
 export declare function loadDefinitionInput(input: DefinitionInput): Promise<DefinitionDescriptor>;
-export declare function buildArtifactDefinitionMetadata(definition: DefinitionDescriptor): ArtifactDefinitionMetadata;
+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;

package/dist/core/definition.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadDefinitionInput = loadDefinitionInput;
+exports.detectOnChainDefinitionAnchor = detectOnChainDefinitionAnchor;
 exports.buildArtifactDefinitionMetadata = buildArtifactDefinitionMetadata;
 exports.verifyDefinitionDescriptorAgainstArtifact = verifyDefinitionDescriptorAgainstArtifact;
 exports.verifyDefinitionAgainstArtifact = verifyDefinitionAgainstArtifact;
@@ -12,6 +13,35 @@ 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`);
@@ -77,22 +107,58 @@ async function loadDefinitionInput(input) {
         sourcePath,
     };
 }
-function buildArtifactDefinitionMetadata(definition) {
+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) {
@@ -101,6 +167,7 @@ function verifyDefinitionDescriptorAgainstArtifact(definition, artifactDefinitio
             reason: `Definition id mismatch: expected=${expectedId} actual=${definition.definitionId}`,
             definition,
             artifactDefinition,
+            trust: noDefinitionTrust,
         };
     }
     if (!artifactDefinition) {
@@ -108,14 +175,22 @@ function verifyDefinitionDescriptorAgainstArtifact(definition, artifactDefinitio
             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) {
@@ -124,6 +199,7 @@ function verifyDefinitionDescriptorAgainstArtifact(definition, artifactDefinitio
             reason: `Definition id mismatch: artifact=${artifactDefinition.definitionId} actual=${definition.definitionId}`,
             definition,
             artifactDefinition,
+            trust,
         };
     }
     if (artifactDefinition.schemaVersion !== definition.schemaVersion) {
@@ -132,6 +208,7 @@ function verifyDefinitionDescriptorAgainstArtifact(definition, artifactDefinitio
             reason: `Definition schemaVersion mismatch: artifact=${artifactDefinition.schemaVersion} actual=${definition.schemaVersion}`,
             definition,
             artifactDefinition,
+            trust,
         };
     }
     if (artifactDefinition.hash !== definition.hash) {
@@ -140,11 +217,63 @@ function verifyDefinitionDescriptorAgainstArtifact(definition, artifactDefinitio
             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",
         };
     }
-    return { ok: true, definition, artifactDefinition };
 }
 async function verifyDefinitionAgainstArtifact(input) {
     const definition = await loadDefinitionInput(input.definition);
-    return verifyDefinitionDescriptorAgainstArtifact(definition, input.artifact.definition, input.expectedType, input.expectedId);
+    const result = verifyDefinitionDescriptorAgainstArtifact(definition, input.artifact.definition, input.expectedType, input.expectedId);
+    return {
+        ...result,
+        trust: await resolveDefinitionTrust(input.artifact, result.trust),
+    };
 }

package/dist/core/executor.js

@@ -211,6 +211,7 @@ function buildPsetSummary(decoded, meta) {
             id: meta.definitionId ?? null,
             hash: meta.definitionHash ?? null,
             trustMode: meta.definitionTrustMode ?? null,
+            anchorMode: meta.definitionAnchorMode ?? null,
         },
         contract: {
             address: meta.contractAddress,
@@ -302,6 +303,7 @@ async function buildExecutionState(config, artifact, input) {
         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,
@@ -457,6 +459,7 @@ async function executeGaslessContractCall(config, artifact, input) {
         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,
@@ -648,6 +651,7 @@ async function executeRelayedGaslessContractCall(config, artifact, input, relaye
                 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,

package/dist/core/types.d.ts

@@ -1,6 +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;
@@ -97,6 +98,7 @@ export interface DefinitionInput {
     schemaVersion?: string;
     jsonPath?: string;
     value?: unknown;
+    anchorMode?: DefinitionAnchorMode;
 }
 export interface DefinitionDescriptor {
     definitionType: string;
@@ -112,6 +114,12 @@ export interface ArtifactDefinitionMetadata {
     schemaVersion: string;
     hash: string;
     trustMode: DefinitionTrustMode;
+    anchorMode: DefinitionAnchorMode;
+    onChainAnchor?: {
+        helper: "nonzero-eq_256";
+        templateVar: "DEFINITION_HASH";
+        sourceVerified: boolean;
+    };
 }
 export interface DeploymentInfo {
     contractAddress: string;
@@ -182,6 +190,7 @@ export interface PsetSummary {
         id: string | null;
         hash: string | null;
         trustMode: DefinitionTrustMode | null;
+        anchorMode: DefinitionAnchorMode | null;
     };
     contract: {
         address: string;
@@ -255,6 +264,12 @@ export interface DefinitionVerificationResult {
     reason?: string;
     definition: DefinitionDescriptor;
     artifactDefinition?: ArtifactDefinitionMetadata;
+    trust: {
+        artifactMatch: boolean;
+        onChainAnchorPresent: boolean;
+        onChainAnchorVerified: boolean;
+        effectiveMode: "none" | DefinitionAnchorMode;
+    };
 }
 export interface WaitForFundingInput {
     minAmountSat?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazbase/simplicity",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "An SDK for Simplicity on Liquid",
   "author": "IndieSquare Inc <info@hazbase.com>",
   "keywords": [