@hazbase/simplicity 0.0.2 → 0.0.4

package/dist/core/compiler.js

@@ -12,6 +12,7 @@ const artifact_1 = require("./artifact");
 const definition_1 = require("./definition");
 const errors_1 = require("./errors");
 const presets_1 = require("./presets");
+const state_1 = require("./state");
 const templating_1 = require("./templating");
 const toolchain_1 = require("./toolchain");
 function parseSimcProgram(output) {
@@ -68,7 +69,18 @@ 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,
+        state: input.state
+            ? (0, state_1.buildArtifactStateMetadata)(input.state, {
+                anchorMode: input.state.anchorMode,
+                onChainAnchor: input.state.onChainAnchor,
+            })
+            : undefined,
         legacy: {
             simfTemplatePath: input.sourceSimfPath,
             params: {
@@ -80,11 +92,60 @@ async function buildArtifact(input) {
 }
 async function compileFromFile(config, input) {
     const definition = input.definition ? await (0, definition_1.loadDefinitionInput)(input.definition) : undefined;
+    const state = input.state ? await (0, state_1.loadStateInput)(input.state) : 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" });
+    }
+    if (state && input.templateVars?.STATE_HASH !== undefined) {
+        throw new errors_1.ValidationError("STATE_HASH must not be provided explicitly when state metadata is supplied", { code: "STATE_HASH_OVERRIDE_FORBIDDEN" });
+    }
+    if (state && input.templateVars?.STATE_ID !== undefined) {
+        throw new errors_1.ValidationError("STATE_ID must not be provided explicitly when state metadata is supplied", { code: "STATE_ID_OVERRIDE_FORBIDDEN" });
+    }
     const rawSource = await (0, promises_1.readFile)(input.simfPath, "utf8");
+    let onChainAnchor;
+    let onChainStateAnchor;
+    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,
+        };
+    }
+    if (input.state?.anchorMode === "on-chain-constant-committed") {
+        const detection = (0, state_1.detectOnChainStateAnchor)(rawSource);
+        if (!rawSource.includes("{{STATE_HASH}}")) {
+            throw new errors_1.ValidationError("Requested on-chain constant-committed state anchor, but the .simf source does not contain {{STATE_HASH}}", { code: "STATE_HASH_PLACEHOLDER_MISSING" });
+        }
+        if (!detection.sourceVerified || !detection.helper) {
+            const code = detection.reason?.includes("called")
+                ? "STATE_ONCHAIN_HELPER_NOT_CALLED"
+                : "STATE_ONCHAIN_HELPER_MISSING";
+            throw new errors_1.ValidationError(`Requested on-chain constant-committed state anchor, but the .simf source does not contain the required state helper pattern: ${detection.reason ?? "unknown reason"}`, { code });
+        }
+        onChainStateAnchor = {
+            helper: detection.helper,
+            templateVar: "STATE_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 } : {}),
+        ...(definition ? { DEFINITION_HASH: definition.hash, DEFINITION_ID: definition.definitionId } : {}),
+        ...(state ? { STATE_HASH: state.hash, STATE_ID: state.stateId } : {}),
     };
     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-"));
@@ -94,9 +155,22 @@ async function compileFromFile(config, input) {
         config,
         renderedSimfPath: renderedPath,
         sourceMode: "file",
-        sourceSimfPath: input.simfPath,
+        sourceSimfPath: node_path_1.default.resolve(input.simfPath),
         templateVars,
-        definition,
+        definition: definition
+            ? {
+                ...definition,
+                anchorMode: input.definition?.anchorMode ?? "artifact-hash-anchor",
+                onChainAnchor,
+            }
+            : undefined,
+        state: state
+            ? {
+                ...state,
+                anchorMode: input.state?.anchorMode ?? "artifact-hash-anchor",
+                onChainAnchor: onChainStateAnchor,
+            }
+            : undefined,
     });
     if (input.artifactPath) {
         await (0, artifact_1.saveArtifact)(input.artifactPath, artifact);
@@ -105,11 +179,30 @@ 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 });
+    }
+    if (input.state?.anchorMode === "on-chain-constant-committed") {
+        throw new errors_1.UnsupportedFeatureError(`Preset '${preset.id}' does not yet support on-chain constant-committed state anchors`, { code: "STATE_ANCHOR_MODE_UNSUPPORTED_FOR_PRESET", preset: preset.id });
+    }
     const definition = input.definition ? await (0, definition_1.loadDefinitionInput)(input.definition) : undefined;
+    const state = input.state ? await (0, state_1.loadStateInput)(input.state) : 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" });
+    }
+    if (state && input.params.STATE_HASH !== undefined) {
+        throw new errors_1.ValidationError("STATE_HASH must not be provided explicitly when state metadata is supplied", { code: "STATE_HASH_OVERRIDE_FORBIDDEN" });
+    }
+    if (state && input.params.STATE_ID !== undefined) {
+        throw new errors_1.ValidationError("STATE_ID must not be provided explicitly when state metadata is supplied", { code: "STATE_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 } : {}),
+        ...(definition ? { DEFINITION_HASH: definition.hash, DEFINITION_ID: definition.definitionId } : {}),
+        ...(state ? { STATE_HASH: state.hash, STATE_ID: state.stateId } : {}),
     };
     const rawSource = await (0, promises_1.readFile)(preset.simfTemplatePath, "utf8");
     const rendered = (0, templating_1.renderTemplate)(rawSource, params);
@@ -123,7 +216,18 @@ 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,
+        state: state
+            ? {
+                ...state,
+                anchorMode: input.state?.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,14 @@ function buildPsetSummary(decoded, meta) {
             id: meta.definitionId ?? null,
             hash: meta.definitionHash ?? null,
             trustMode: meta.definitionTrustMode ?? null,
+            anchorMode: meta.definitionAnchorMode ?? null,
+        },
+        state: {
+            type: meta.stateType ?? null,
+            id: meta.stateId ?? null,
+            hash: meta.stateHash ?? null,
+            trustMode: meta.stateTrustMode ?? null,
+            anchorMode: meta.stateAnchorMode ?? null,
         },
         contract: {
             address: meta.contractAddress,
@@ -302,6 +310,12 @@ async function buildExecutionState(config, artifact, input) {
         definitionId: artifact.definition?.definitionId,
         definitionHash: artifact.definition?.hash,
         definitionTrustMode: artifact.definition?.trustMode,
+        definitionAnchorMode: artifact.definition?.anchorMode,
+        stateType: artifact.state?.stateType,
+        stateId: artifact.state?.stateId,
+        stateHash: artifact.state?.hash,
+        stateTrustMode: artifact.state?.trustMode,
+        stateAnchorMode: artifact.state?.anchorMode,
         expectedLiquidReceiver: input.expectedLiquidReceiver ?? recipientAddress,
         contractAddress: artifact.compiled.contractAddress,
         cmr: artifact.compiled.cmr,
@@ -457,6 +471,12 @@ async function executeGaslessContractCall(config, artifact, input) {
         definitionId: artifact.definition?.definitionId,
         definitionHash: artifact.definition?.hash,
         definitionTrustMode: artifact.definition?.trustMode,
+        definitionAnchorMode: artifact.definition?.anchorMode,
+        stateType: artifact.state?.stateType,
+        stateId: artifact.state?.stateId,
+        stateHash: artifact.state?.hash,
+        stateTrustMode: artifact.state?.trustMode,
+        stateAnchorMode: artifact.state?.anchorMode,
         contractAddress: artifact.compiled.contractAddress,
         cmr: artifact.compiled.cmr,
         internalKey: artifact.compiled.internalKey,
@@ -648,6 +668,14 @@ 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,
+            },
+            state: {
+                type: artifact.state?.stateType ?? null,
+                id: artifact.state?.stateId ?? null,
+                hash: artifact.state?.hash ?? null,
+                trustMode: artifact.state?.trustMode ?? null,
+                anchorMode: artifact.state?.anchorMode ?? null,
             },
             contract: {
                 address: request.detailedSummary.contract.contractAddress,

package/dist/core/state.d.ts

@@ -0,0 +1,18 @@
+import { ArtifactStateMetadata, DefinitionAnchorMode, SimplicityArtifact, StateDocumentDescriptor, StateDocumentInput, StateVerificationResult } from "./types";
+export declare function loadStateInput(input: StateDocumentInput): Promise<StateDocumentDescriptor>;
+export declare function detectOnChainStateAnchor(simfSource: string): {
+    sourceVerified: boolean;
+    helper?: "nonzero-eq_256";
+    reason?: string;
+};
+export declare function buildArtifactStateMetadata(state: StateDocumentDescriptor, options?: {
+    anchorMode?: DefinitionAnchorMode;
+    onChainAnchor?: ArtifactStateMetadata["onChainAnchor"];
+}): ArtifactStateMetadata;
+export declare function verifyStateDescriptorAgainstArtifact(state: StateDocumentDescriptor, artifactState?: ArtifactStateMetadata, expectedType?: string, expectedId?: string): StateVerificationResult;
+export declare function verifyStateAgainstArtifact(input: {
+    artifact: SimplicityArtifact;
+    state: StateDocumentInput;
+    expectedType?: string;
+    expectedId?: string;
+}): Promise<StateVerificationResult>;