@ottochain/sdk 2.3.0 → 2.5.0

package/dist/cjs/zk/guard.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wordOffset = void 0;
+exports.semiPrivateGuard = semiPrivateGuard;
+exports.verifyGroth16Bundle = verifyGroth16Bundle;
+exports.checkSemiPrivateBinding = checkSemiPrivateBinding;
+exports.verifySemiPrivate = verifySemiPrivate;
+/**
+ * The semi-private guard: the JLVM predicate a policy embeds, and its client-side mirror.
+ *
+ * The guard pins THREE facts about the witness the holder carries, using only opcodes metakit
+ * already gas-meters — no new `jlvm_pv_decode`, the public-values blob is parsed with native
+ * `substr`/`cat`:
+ *   1. `groth16_verify[vkey, witness.publicValues, witness.proof]` — the SP1 proof is valid.
+ *   2. the `exprHash` word of the public values == the policy's `logicHash` — the proof ran the
+ *      INTENDED rule (the pinned, legible predicate).
+ *   3. the `outputHash` word == `keccak256("true")` — that rule evaluated to TRUE on the hidden data.
+ *
+ * `publicValues` rides as a `0x` + 256-hex-char string (`0x` | exprHash | dataHash | outputHash | ok),
+ * so word w begins at char `2 + 64*w` and is 64 chars wide. `cat("0x", substr(pv, off, 64))` lifts a
+ * word back to a `0x`-hex value comparable with a `bytes32` literal. These offsets are the on-chain
+ * guard's contract; the Scala policy mirrors this exact shape.
+ */
+const metagraph_sdk_jlvm_1 = require("@constellation-network/metagraph-sdk-jlvm");
+const preimage_1 = require("./preimage");
+const types_1 = require("./types");
+const HEX_PREFIX = 2; // "0x"
+const WORD_HEX = 64; // 32-byte ABI word as hex chars
+/** Char offset of public-values word `w` (0=exprHash, 1=dataHash, 2=outputHash, 3=ok) in the `0x` string. */
+const wordOffset = (w) => HEX_PREFIX + WORD_HEX * w;
+exports.wordOffset = wordOffset;
+/** Lift public-values word `w` back to a `0x`-hex value (`cat("0x", substr(pv, off, 64))`). */
+const pvWord = (w) => ({
+    cat: ['0x', { substr: [{ var: 'witness.publicValues' }, (0, exports.wordOffset)(w), WORD_HEX] }],
+});
+/**
+ * Build the JLVM guard a `Governed` morphism / mint policy embeds. `vkey` is the zk-jlvm program
+ * verification key (a `bytes32` `0x`-hex literal); `logicHash` is the pinned rule's hash (from
+ * {@link ExprRegistry.logicHashOf}). Returns plain JSON — feed it into an ASSET policy's guard/mintPolicy
+ * (the asset combiner injects the reserved `witness`). In a fiber TRANSITION there is no `witness` key —
+ * the proof rides in the event payload, so read `event.witness.*` instead.
+ *
+ * REPLAY (audit zk-guards): the proven public values commit only {exprHash, dataHash, outputHash, ok} —
+ * nothing situational (no fiber / asset / `$ordinal` / nonce). A valid `{publicValues, proof}` is therefore
+ * a reusable bearer token, replayable across any action pinning the same vkey + logicHash. Bind the action
+ * INSIDE the proven rule (pin a spender/asset/subject, as `reputationCreditRule` pins `subject`) and/or gate
+ * with a one-time nonce ledger until the public values carry action context.
+ */
+function semiPrivateGuard(vkey, logicHash, opts = {}) {
+    const { requireTrue = true } = opts;
+    const clauses = [
+        { groth16_verify: [vkey, { var: 'witness.publicValues' }, { var: 'witness.proof' }] },
+        { '==': [pvWord(0), logicHash] },
+    ];
+    if (requireTrue) {
+        clauses.push({ '==': [pvWord(2), preimage_1.KECCAK_TRUE] });
+        // ok bit: the final hex pair of word 3 (offset 256) must be "01" — the JLVM run did not error.
+        clauses.push({ '==': [{ substr: [{ var: 'witness.publicValues' }, (0, exports.wordOffset)(3) + 62, 2] }, '01'] });
+    }
+    return { and: clauses };
+}
+/**
+ * Locally run the SAME `groth16_verify` pairing the chain runs (the verifier opcode, not the prover).
+ * Returns `false` — never throws — on an invalid/garbage bundle, mirroring the guard's graceful deny.
+ */
+function verifyGroth16Bundle(bundle) {
+    try {
+        return metagraph_sdk_jlvm_1.jsonLogic.apply({ groth16_verify: [bundle.vkey, bundle.publicValues, bundle.proof] }, {}) === true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check the binding words WITHOUT the pairing: `exprHash == expectedLogicHash`, `ok` set, and
+ * (when `requireTrue`) `outputHash == keccak256("true")`. Pair with {@link verifyGroth16Bundle} for
+ * the full client-side mirror of the on-chain guard (see {@link verifySemiPrivate}).
+ */
+function checkSemiPrivateBinding(bundle, expectedLogicHash, opts = {}) {
+    const { requireTrue = true } = opts;
+    const decoded = (0, types_1.decodeJlvmPublicValues)(bundle.publicValues);
+    const eq = (a, b) => a.toLowerCase() === b.toLowerCase();
+    const reasons = [];
+    if (!eq(decoded.exprHash, expectedLogicHash))
+        reasons.push(`exprHash ${decoded.exprHash} != expected logicHash ${expectedLogicHash}`);
+    if (!decoded.ok)
+        reasons.push('ok bit is false (guest evaluation errored)');
+    if (requireTrue && !eq(decoded.outputHash, preimage_1.KECCAK_TRUE))
+        reasons.push(`outputHash ${decoded.outputHash} != keccak256("true") ${preimage_1.KECCAK_TRUE}`);
+    return { ok: reasons.length === 0, reasons, decoded };
+}
+/**
+ * The full client-side mirror of the on-chain guard: the proof verifies AND its words bind to the
+ * pinned rule (and, by default, to a `true` result). Run this before submitting to fail fast instead
+ * of paying for an on-chain rejection.
+ */
+function verifySemiPrivate(bundle, expectedLogicHash, opts = {}) {
+    const binding = checkSemiPrivateBinding(bundle, expectedLogicHash, opts);
+    if (!verifyGroth16Bundle(bundle)) {
+        return {
+            ok: false,
+            reasons: ['groth16_verify failed (invalid proof for this vkey/publicValues)', ...binding.reasons],
+            decoded: binding.decoded,
+        };
+    }
+    return binding;
+}

package/dist/cjs/zk/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGroth16Stdout = exports.SubprocessProver = exports.verifySemiPrivate = exports.checkSemiPrivateBinding = exports.verifyGroth16Bundle = exports.semiPrivateGuard = exports.wordOffset = exports.atMost = exports.atLeast = exports.boundRule = exports.ExprRegistry = exports.pmtWitness = exports.groth16Witness = exports.decodeJlvmPublicValues = exports.openCommitment = exports.poseidonCommitN = exports.poseidonCommit = exports.randomSalt = exports.frToHex = exports.toFr = exports.R = exports.KECCAK_TRUE = exports.dataHash = exports.exprHash = exports.proverPreimage = exports.canonicalForSigning = void 0;
+/**
+ * `@ottochain/sdk/zk` — the client-side semi-private tier.
+ *
+ * Public-by-default, private-by-opt-in: a holder proves (off-chain, via SP1 zk-jlvm) that some
+ * PRIVATE data satisfies a PUBLIC, pinned JLVM rule, and carries only `{publicValues, proof}` on a
+ * signed op. A policy's {@link semiPrivateGuard} re-verifies the proof and binds it to the pinned
+ * rule on-chain — the value stays hidden, the predicate stays legible.
+ *
+ * The ONE canonical invariant tying it together: the prover is fed `canonicalForSigning(expr)` /
+ * `canonicalForSigning(data)`, so a proof's `exprHash` word equals {@link exprHash}`(rule)` equals a
+ * policy's `logicHash` — see {@link proverPreimage} and docs/design/client-side-private-data.md §3.0.
+ */
+var preimage_1 = require("./preimage");
+Object.defineProperty(exports, "canonicalForSigning", { enumerable: true, get: function () { return preimage_1.canonicalForSigning; } });
+Object.defineProperty(exports, "proverPreimage", { enumerable: true, get: function () { return preimage_1.proverPreimage; } });
+Object.defineProperty(exports, "exprHash", { enumerable: true, get: function () { return preimage_1.exprHash; } });
+Object.defineProperty(exports, "dataHash", { enumerable: true, get: function () { return preimage_1.dataHash; } });
+Object.defineProperty(exports, "KECCAK_TRUE", { enumerable: true, get: function () { return preimage_1.KECCAK_TRUE; } });
+var commit_1 = require("./commit");
+Object.defineProperty(exports, "R", { enumerable: true, get: function () { return commit_1.R; } });
+Object.defineProperty(exports, "toFr", { enumerable: true, get: function () { return commit_1.toFr; } });
+Object.defineProperty(exports, "frToHex", { enumerable: true, get: function () { return commit_1.frToHex; } });
+Object.defineProperty(exports, "randomSalt", { enumerable: true, get: function () { return commit_1.randomSalt; } });
+Object.defineProperty(exports, "poseidonCommit", { enumerable: true, get: function () { return commit_1.poseidonCommit; } });
+Object.defineProperty(exports, "poseidonCommitN", { enumerable: true, get: function () { return commit_1.poseidonCommitN; } });
+Object.defineProperty(exports, "openCommitment", { enumerable: true, get: function () { return commit_1.openCommitment; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "decodeJlvmPublicValues", { enumerable: true, get: function () { return types_1.decodeJlvmPublicValues; } });
+var witness_1 = require("./witness");
+Object.defineProperty(exports, "groth16Witness", { enumerable: true, get: function () { return witness_1.groth16Witness; } });
+Object.defineProperty(exports, "pmtWitness", { enumerable: true, get: function () { return witness_1.pmtWitness; } });
+var registry_1 = require("./registry");
+Object.defineProperty(exports, "ExprRegistry", { enumerable: true, get: function () { return registry_1.ExprRegistry; } });
+Object.defineProperty(exports, "boundRule", { enumerable: true, get: function () { return registry_1.boundRule; } });
+Object.defineProperty(exports, "atLeast", { enumerable: true, get: function () { return registry_1.atLeast; } });
+Object.defineProperty(exports, "atMost", { enumerable: true, get: function () { return registry_1.atMost; } });
+var guard_1 = require("./guard");
+Object.defineProperty(exports, "wordOffset", { enumerable: true, get: function () { return guard_1.wordOffset; } });
+Object.defineProperty(exports, "semiPrivateGuard", { enumerable: true, get: function () { return guard_1.semiPrivateGuard; } });
+Object.defineProperty(exports, "verifyGroth16Bundle", { enumerable: true, get: function () { return guard_1.verifyGroth16Bundle; } });
+Object.defineProperty(exports, "checkSemiPrivateBinding", { enumerable: true, get: function () { return guard_1.checkSemiPrivateBinding; } });
+Object.defineProperty(exports, "verifySemiPrivate", { enumerable: true, get: function () { return guard_1.verifySemiPrivate; } });
+var prover_1 = require("./prover");
+Object.defineProperty(exports, "SubprocessProver", { enumerable: true, get: function () { return prover_1.SubprocessProver; } });
+Object.defineProperty(exports, "parseGroth16Stdout", { enumerable: true, get: function () { return prover_1.parseGroth16Stdout; } });

package/dist/cjs/zk/preimage.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KECCAK_TRUE = exports.dataHash = exports.exprHash = void 0;
+exports.canonicalForSigning = canonicalForSigning;
+exports.proverPreimage = proverPreimage;
+/**
+ * The ONE canonical path for the semi-private tier.
+ *
+ * metakit-sdk 1.8.x `canonicalize` = `serializeJcs(dropNullFields)` — it drops null object-fields
+ * before RFC 8785 (server-aligned), so it is the EXACT byte string the chain signs over. Feeding
+ * the zk-jlvm prover this same string makes the proof's keccak preimage equal the signature
+ * preimage — the determinism binding (see docs/design/client-side-private-data.md §3.0).
+ *
+ * Note the two hashes differ by design: signing is sha256 over the canonical bytes (+ Constellation
+ * prefix), the zk-jlvm guest is keccak256 over the canonical bytes — they bind the SAME canonical
+ * string, which is the load-bearing invariant.
+ */
+const metagraph_sdk_1 = require("@constellation-network/metagraph-sdk");
+const sha3_js_1 = require("@noble/hashes/sha3.js");
+const utf8 = (s) => new TextEncoder().encode(s);
+const toHex = (b) => Array.from(b, (x) => x.toString(16).padStart(2, '0')).join('');
+/** The single canonical string both the signer and the prover-feed share (JCS ∘ dropNullFields). */
+function canonicalForSigning(x) {
+    return (0, metagraph_sdk_1.canonicalize)(x);
+}
+/** keccak256 of the canonical bytes — the value the zk-jlvm guest commits as exprHash / dataHash. */
+function proverPreimage(x) {
+    return `0x${toHex((0, sha3_js_1.keccak_256)(utf8(canonicalForSigning(x))))}`;
+}
+/** exprHash of a published JLVM rule (canonicalized + keccak'd). Equals the chain's `logicHash`. */
+const exprHash = (rule) => proverPreimage(rule);
+exports.exprHash = exprHash;
+/** dataHash of a private data context — kept private; only its hash is public. */
+const dataHash = (data) => proverPreimage(data);
+exports.dataHash = dataHash;
+/** `keccak256(canonicalize(true))` — the `outputHash` a guard binds for a "rule returned true" proof. */
+exports.KECCAK_TRUE = proverPreimage(true);

package/dist/cjs/zk/prover.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubprocessProver = void 0;
+exports.parseGroth16Stdout = parseGroth16Stdout;
+/**
+ * Driving the SP1 zk-jlvm host (`rust/zk-jlvm/script`, `--mode groth16`) to produce a
+ * {@link Groth16Bundle} from a JLVM `expr` + `data`.
+ *
+ * THE load-bearing step: the host's guest hashes the RAW `--expr` / `--data` strings
+ * (`exprHash = keccak256(expr_bytes)`), so this driver feeds it `canonicalForSigning(expr)` /
+ * `canonicalForSigning(data)`. That makes a proof's `exprHash` word equal {@link exprHash}`(rule)`
+ * equal a policy's `logicHash` — without it the binding silently never matches.
+ *
+ * Proving is heavy (SP1; minutes, optionally `SP1_PROVER=cuda`) and needs the Rust toolchain, so this
+ * is an out-of-process driver, not an in-SDK prover. Point it at a prebuilt `binaryPath`, or at the
+ * crate via `cargoManifestPath`; configure either explicitly or through `ZK_JLVM_BIN` /
+ * `ZK_JLVM_MANIFEST` env vars.
+ */
+const preimage_1 = require("./preimage");
+const reLine = (label) => new RegExp(`^${label}:\\s*(0x[0-9a-fA-F]+)\\s*$`, 'm');
+/** Parse the host's `vkey:` / `public values:` / `proof bytes:` stdout lines into a bundle. */
+function parseGroth16Stdout(stdout) {
+    const grab = (label, key) => {
+        const m = stdout.match(reLine(label));
+        if (!m)
+            throw new Error(`zk-jlvm host produced no "${label}:" line (could not read ${key})`);
+        return m[1].toLowerCase();
+    };
+    return {
+        vkey: grab('vkey', 'vkey'),
+        publicValues: grab('public values', 'publicValues'),
+        proof: grab('proof bytes', 'proof'),
+    };
+}
+/** Drives the zk-jlvm host out-of-process. */
+class SubprocessProver {
+    constructor(opts = {}) {
+        this.opts = opts;
+    }
+    async proveGroth16(req) {
+        // Canonicalize BEFORE proving so exprHash/dataHash bind the same bytes the chain signs over.
+        const expr = (0, preimage_1.canonicalForSigning)(req.expr);
+        const data = (0, preimage_1.canonicalForSigning)(req.data);
+        const modeArgs = ['--mode', 'groth16', '--expr', expr, '--data', data];
+        const binaryPath = this.opts.binaryPath ?? process.env.ZK_JLVM_BIN;
+        const manifest = this.opts.cargoManifestPath ?? process.env.ZK_JLVM_MANIFEST;
+        let command;
+        let args;
+        if (binaryPath) {
+            command = binaryPath;
+            args = modeArgs;
+        }
+        else if (manifest) {
+            command = 'cargo';
+            args = ['run', '--release', '--manifest-path', manifest, '--', ...modeArgs];
+        }
+        else {
+            throw new Error('SubprocessProver: set `binaryPath` (or ZK_JLVM_BIN), or `cargoManifestPath` (or ZK_JLVM_MANIFEST)');
+        }
+        const stdout = await this.run(command, args);
+        return parseGroth16Stdout(stdout);
+    }
+    run(command, args) {
+        const { env, cwd, timeoutMs = 1800000 } = this.opts;
+        // Lazy-load child_process so importing the zk slice stays light for non-proving consumers.
+        return import('node:child_process').then(({ spawn }) => new Promise((resolve, reject) => {
+            // argv (no shell) — `expr`/`data` are JSON with quotes/braces; never interpolate into a shell.
+            const child = spawn(command, args, {
+                cwd,
+                env: { ...process.env, ...env },
+                timeout: timeoutMs,
+            });
+            let out = '';
+            let err = '';
+            child.stdout.on('data', (d) => (out += d.toString()));
+            child.stderr.on('data', (d) => (err += d.toString()));
+            child.on('error', reject);
+            child.on('close', (code) => {
+                if (code === 0)
+                    resolve(out);
+                else
+                    reject(new Error(`zk-jlvm host exited ${code}: ${err.trim() || out.trim()}`));
+            });
+        }));
+    }
+}
+exports.SubprocessProver = SubprocessProver;

package/dist/cjs/zk/registry.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.atMost = exports.atLeast = exports.ExprRegistry = void 0;
+exports.boundRule = boundRule;
+/**
+ * The expression registry binds a human name → a published JLVM rule → its `logicHash`
+ * (`keccak256(canonicalize(rule))`). The `logicHash` is the load-bearing public value: it equals the
+ * `exprHash` word a zk-jlvm proof commits AND the literal a semi-private guard pins. Registering a
+ * rule with a LITERAL bound ("pin the bound into the rule", e.g. `{">=":[{"var":"score"},700]}`)
+ * makes "the proof's exprHash == this logicHash" mean "the hidden value satisfies THIS public,
+ * legible rule" — privacy of the value, transparency of the predicate.
+ */
+const preimage_1 = require("./preimage");
+/** A client-side registry mapping rule names to their canonical `logicHash`. */
+class ExprRegistry {
+    constructor() {
+        this.byName = new Map();
+    }
+    /** Register (or replace) a named rule; returns the entry with its computed `logicHash`. */
+    register(name, rule) {
+        const entry = { rule, logicHash: (0, preimage_1.exprHash)(rule) };
+        this.byName.set(name, entry);
+        return entry;
+    }
+    /** Whether a rule is registered under `name`. */
+    has(name) {
+        return this.byName.has(name);
+    }
+    /** The registered rule, or throw if unknown. */
+    ruleOf(name) {
+        return this.require(name).rule;
+    }
+    /** The registered rule's `logicHash`, or throw if unknown. */
+    logicHashOf(name) {
+        return this.require(name).logicHash;
+    }
+    /** All registered names, in insertion order. */
+    names() {
+        return [...this.byName.keys()];
+    }
+    require(name) {
+        const entry = this.byName.get(name);
+        if (!entry)
+            throw new Error(`ExprRegistry: no rule registered under "${name}"`);
+        return entry;
+    }
+}
+exports.ExprRegistry = ExprRegistry;
+/**
+ * A single-bound predicate `{[op]:[{var:varName}, bound]}` — the "pinned bound" a proof binds to.
+ * `bound` stays a JSON primitive (number/string) so the canonical bytes the prover hashes match the
+ * canonical bytes the rule registers under (bigint is not JSON-serializable — pre-encode if needed).
+ */
+function boundRule(varName, op, bound) {
+    return { [op]: [{ var: varName }, bound] };
+}
+/** `{">=":[{"var":varName}, bound]}` — "the hidden `varName` is at least `bound`". */
+const atLeast = (varName, bound) => boundRule(varName, '>=', bound);
+exports.atLeast = atLeast;
+/** `{"<=":[{"var":varName}, bound]}` — "the hidden `varName` is at most `bound`". */
+const atMost = (varName, bound) => boundRule(varName, '<=', bound);
+exports.atMost = atMost;

package/dist/cjs/zk/types.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * SP1 zk-jlvm public-values types + decode.
+ *
+ * The guest commits `abi_encode(JlvmPublicValues{ bytes32 exprHash, bytes32 dataHash,
+ * bytes32 outputHash, bool ok })` — four 32-byte words, the bool right-aligned in its word.
+ * There is no on-chain `jlvm_pv_decode` opcode: the chain guard parses the same blob with the
+ * native JLVM `cat`/`substr` ops. This decode mirrors that for client-side binding/inspection.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeJlvmPublicValues = decodeJlvmPublicValues;
+/**
+ * Decode `abi_encode(JlvmPublicValues)`: four 32-byte words `[exprHash | dataHash | outputHash | ok]`.
+ * The bool is right-aligned in its word (final byte `0x00`/`0x01`).
+ */
+function decodeJlvmPublicValues(pv) {
+    const b = pv.startsWith('0x') ? pv.slice(2) : pv;
+    if (b.length < 4 * 64) {
+        throw new Error(`publicValues too short: ${b.length} hex chars (need >= 256)`);
+    }
+    const word = (i) => `0x${b.slice(i * 64, i * 64 + 64)}`;
+    return {
+        exprHash: word(0),
+        dataHash: word(1),
+        outputHash: word(2),
+        ok: b.slice(3 * 64 + 62, 3 * 64 + 64) !== '00',
+    };
+}

package/dist/cjs/zk/witness.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groth16Witness = groth16Witness;
+exports.pmtWitness = pmtWitness;
+const types_1 = require("./types");
+/**
+ * Shape a produced {@link Groth16Bundle} into the on-op witness map (`{publicValues, proof}`) and
+ * surface its decoded public values. The vkey rides in the guard, not the witness, so it is dropped.
+ */
+function groth16Witness(bundle) {
+    return {
+        witness: { publicValues: bundle.publicValues, proof: bundle.proof },
+        decoded: (0, types_1.decodeJlvmPublicValues)(bundle.publicValues),
+    };
+}
+/** Shape a Poseidon-Merkle inclusion path into the on-op `pmt_verify` witness map. */
+function pmtWitness(leaf, index, siblings) {
+    return { leaf, index, siblings };
+}

package/dist/esm/apps/compute/index.js

@@ -0,0 +1,29 @@
+/**
+ * Compute Application — bare computation substrates.
+ *
+ * Turing-complete JLVM substrates with no parties, assets, or governance: pure
+ * in-place state evolution. The flagship is `rule110`, an in-place Rule-110
+ * cellular automaton that proves the account layer is Turing-complete.
+ *
+ * @example
+ * ```typescript
+ * import { getComputeDefinition, COMPUTE_DEFINITIONS } from '@ottochain/sdk/apps/compute';
+ *
+ * const rule110Def = getComputeDefinition('rule110');
+ * ```
+ *
+ * @packageDocumentation
+ */
+import { computeRule110Def } from './state-machines/index.js';
+export { computeRule110Def };
+/** All compute (bare-computation) state machine definitions. */
+export const COMPUTE_DEFINITIONS = {
+    rule110: computeRule110Def,
+};
+/**
+ * Get a compute state machine definition by type.
+ * @param type - 'rule110' (default).
+ */
+export function getComputeDefinition(type = 'rule110') {
+    return COMPUTE_DEFINITIONS[type];
+}

package/dist/esm/apps/compute/state-machines/compute-rule110.js

@@ -0,0 +1,161 @@
+import { defineFiberApp } from '../../../schema/fiber-app.js';
+/**
+ * Rule-110 cellular automaton — an in-place, Turing-complete JLVM substrate.
+ *
+ * Each `step` event advances ONE CA generation in place:
+ *   next[i] = R110(tape[i-1], tape[i], tape[i+1])
+ * with fixed-0 boundaries, computed as a JLVM `map` over a STORED index array
+ * (`idx`) — no bitwise ops, no spawn, no zip. The fiber loops RUNNING → RUNNING;
+ * the chain of transitions IS the Turing-machine tape-head.
+ *
+ * Rule 110: out = 1 iff p ∈ {1,2,3,5,6}, where p = 4·left + 2·center + right.
+ *
+ * THE INLINED-CELL CONSTRAINT (do not "simplify" with `let`)
+ * ---------------------------------------------------------
+ * Inside `map`, a primitive element is overlaid into the eval context, so
+ * `{var:""}` coerces to the element int ONLY in arithmetic position. Opening a
+ * `let` scope over the element makes `{var:""}` resolve to the whole context
+ * object (`{"tag":"map"}`) and any `cat` on it throws `JsonLogicRuntimeError`.
+ * Therefore the per-cell predicate P is fully INLINED at each of the five `==`
+ * comparison sites (P appears 5×; each neighbour read `nb` reads the tape once
+ * per occurrence). This is the only form that works inside `map`. It is built
+ * programmatically below to avoid hand-duplicating P, but it expands to the
+ * inlined AST — NOT a `let`-form.
+ *
+ * Neighbour access uses a computed `var` PATH with a null-default boundary:
+ *   nb(off) = { var: [ { cat: ["state.tape.", off] }, 0 ] }
+ * An out-of-bounds index (-1 or N) resolves to the default `0` (fixed-0
+ * boundary), so `tape`/`idx` stay exactly length N forever.
+ *
+ * Verified end-to-end against `@constellation-network/metagraph-sdk-jlvm@1.8.0-rc.5`:
+ * the effect reproduces the canonical left-growing Rule-110 fractal exactly,
+ * `idx` is byte-identical across every generation, and the unbounded/bounded
+ * guard halts at `gen == maxGen`.
+ */
+// nb(off): read tape at element-relative offset, fixed-0 boundary via null-default.
+const nb = (off) => ({
+    var: [{ cat: ['state.tape.', off] }, 0],
+});
+// P = 4·left + 2·center + right  (element {var:""} is the cell index i).
+const P = {
+    '+': [{ '*': [4, nb({ '-': [{ var: '' }, 1] })] }, { '*': [2, nb({ var: '' })] }, nb({ '+': [{ var: '' }, 1] })],
+};
+// CELL: 1 iff P ∈ {1,2,3,5,6}, else 0. P is INLINED at each `==` site (B1: never
+// `let` over the map element). Built from the rule-110 truth set programmatically.
+const CELL = {
+    if: [{ or: [1, 2, 3, 5, 6].map((k) => ({ '==': [P, k] })) }, 1, 0],
+};
+/**
+ * Rule-110 cellular-automaton fiber definition.
+ *
+ * Trust model: PUBLIC / PERMISSIONLESS / pure compute. No assets, no parties,
+ * no owner — anyone may submit `step`. The DoS surface is bounded by per-event
+ * gas/fee (~987 gas/cell) and the optional `maxGen` halt bound (absent ⇒
+ * unbounded; runs until fees stop).
+ */
+export const computeRule110Def = defineFiberApp({
+    metadata: {
+        name: 'ComputeRule110',
+        app: 'compute',
+        type: 'rule110',
+        version: '1.0.0',
+        description: 'In-place Rule-110 cellular automaton — a Turing-complete substrate. Each ' +
+            '`step` advances one generation: next[i]=R110(tape[i-1],tape[i],tape[i+1]) ' +
+            'with fixed-0 boundaries, as a JLVM map over a stored index array (no ' +
+            'bitwise, no spawn, no zip).',
+    },
+    createSchema: {
+        // maxGen is NOT required: absent ⇒ unbounded (the step guard uses `missing`).
+        required: ['tape', 'idx'],
+        properties: {
+            tape: {
+                type: 'array',
+                items: { type: 'integer' },
+                description: '0/1 CA row (length N).',
+            },
+            idx: {
+                type: 'array',
+                items: { type: 'integer' },
+                immutable: true,
+                description: 'Monotone index array [0..N-1]; REQUIRED (no range/iota opcode). ' +
+                    'Never mutated — the effect preserves it across every generation.',
+            },
+            gen: {
+                type: 'integer',
+                default: 0,
+                description: 'Generation counter (TM step count).',
+            },
+            maxGen: {
+                type: 'integer',
+                description: 'Optional halt bound; absent ⇒ unbounded.',
+            },
+        },
+    },
+    stateSchema: {
+        properties: {
+            tape: { type: 'array', items: { type: 'integer' }, computed: true },
+            idx: { type: 'array', items: { type: 'integer' }, immutable: true },
+            gen: { type: 'integer', computed: true },
+            maxGen: { type: 'integer' },
+            status: { type: 'string', computed: true },
+        },
+    },
+    eventSchemas: {
+        step: { description: 'Advance one CA generation in place.' },
+        halt: { description: 'Terminate once maxGen is reached (gated by gen >= maxGen).' },
+    },
+    states: {
+        RUNNING: {
+            id: 'RUNNING',
+            isFinal: false,
+            metadata: {
+                label: 'Running',
+                description: 'CA evolving; each step = one generation.',
+                category: 'active',
+            },
+        },
+        HALTED: {
+            id: 'HALTED',
+            isFinal: true,
+            metadata: {
+                label: 'Halted',
+                description: 'maxGen reached; terminal.',
+                category: 'terminal',
+            },
+        },
+    },
+    initialState: 'RUNNING',
+    transitions: [
+        {
+            // One `step` = one generation. Loops in place (the TM tape-head).
+            from: 'RUNNING',
+            to: 'RUNNING',
+            eventName: 'step',
+            // Unbounded when maxGen is absent (`missing` → true); else gate on gen < maxGen.
+            guard: {
+                or: [{ missing: ['state.maxGen'] }, { '<': [{ var: 'state.gen' }, { var: 'state.maxGen' }] }],
+            },
+            // Effect result IS the new stateData: merge[state, overrides] preserves
+            // idx/maxGen and overwrites tape/gen.
+            effect: {
+                merge: [
+                    { var: 'state' },
+                    {
+                        tape: { map: [{ var: 'state.idx' }, CELL] },
+                        gen: { '+': [{ var: 'state.gen' }, 1] },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            // halt is rejected until exhaustion: gen >= maxGen.
+            from: 'RUNNING',
+            to: 'HALTED',
+            eventName: 'halt',
+            guard: { '>=': [{ var: 'state.gen' }, { var: 'state.maxGen' }] },
+            effect: { merge: [{ var: 'state' }, { status: 'halted' }] },
+            dependencies: [],
+        },
+    ],
+});

package/dist/esm/apps/compute/state-machines/index.js

@@ -0,0 +1,5 @@
+/**
+ * Compute (bare-computation) state machine definitions.
+ * Re-exports from TypeScript definition files.
+ */
+export { computeRule110Def } from './compute-rule110.js';

package/dist/esm/apps/contracts/index.js

@@ -6,7 +6,7 @@
  * @example
  * ```typescript
  * import {
- *   ContractState,
+ *   State,
  *   Contract,
  *   getContractDefinition,
  *   CONTRACTS_DEFINITIONS
@@ -18,12 +18,16 @@
  *
  * @packageDocumentation
  */
-// Re-export generated protobuf types (source of truth)
-export { ContractState, Contract, ProposeContractRequest, AcceptContractRequest, CompleteContractRequest, RejectContractRequest, DisputeContractRequest, ContractDefinition, contractStateFromJSON, contractStateToJSON, } from "../../generated/ottochain/apps/contracts/v1/contract.js";
+// Re-export generated protobuf types (source of truth).
+// The nested lifecycle enum dropped its app prefix in the proto; under this
+// app-scoped entrypoint it is unambiguously State.
+export { State, Contract, ProposeContractRequest, AcceptContractRequest, CompleteContractRequest, RejectContractRequest, DisputeContractRequest, ContractDefinition, stateFromJSON, stateToJSON, } from '../../generated/ottochain/apps/contracts/v1/contract.js';
+// Deprecated app-prefixed alias (renamed to State); kept for compat.
+export { State as ContractState, stateFromJSON as contractStateFromJSON, stateToJSON as contractStateToJSON, } from '../../generated/ottochain/apps/contracts/v1/contract.js';
 // ---------------------------------------------------------------------------
 // State Machine Definitions (generated from JSON at build time)
 // ---------------------------------------------------------------------------
-import { contractUniversalDef, contractAgreementDef, contractEscrowDef, } from "./state-machines/index.js";
+import { contractUniversalDef, contractAgreementDef, contractEscrowDef } from './state-machines/index.js';
 export { contractUniversalDef, contractAgreementDef, contractEscrowDef };
 /** All contract state machine definitions */
 export const CONTRACTS_DEFINITIONS = {
@@ -35,7 +39,7 @@ export const CONTRACTS_DEFINITIONS = {
  * Get a contract state machine definition by type.
  * @param type - 'universal' | 'agreement' | 'escrow' (default: 'agreement')
  */
-export function getContractDefinition(type = "agreement") {
+export function getContractDefinition(type = 'agreement') {
     return CONTRACTS_DEFINITIONS[type];
 }
 /** @deprecated Use getContractDefinition('escrow') */