@ottochain/sdk 2.3.0 → 2.5.0

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

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMPUTE_DEFINITIONS = exports.computeRule110Def = void 0;
+exports.getComputeDefinition = getComputeDefinition;
+const index_js_1 = require("./state-machines/index.js");
+Object.defineProperty(exports, "computeRule110Def", { enumerable: true, get: function () { return index_js_1.computeRule110Def; } });
+/** All compute (bare-computation) state machine definitions. */
+exports.COMPUTE_DEFINITIONS = {
+    rule110: index_js_1.computeRule110Def,
+};
+/**
+ * Get a compute state machine definition by type.
+ * @param type - 'rule110' (default).
+ */
+function getComputeDefinition(type = 'rule110') {
+    return exports.COMPUTE_DEFINITIONS[type];
+}

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

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeRule110Def = void 0;
+const fiber_app_js_1 = require("../../../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).
+ */
+exports.computeRule110Def = (0, fiber_app_js_1.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/cjs/apps/compute/state-machines/index.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Compute (bare-computation) state machine definitions.
+ * Re-exports from TypeScript definition files.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeRule110Def = void 0;
+var compute_rule110_js_1 = require("./compute-rule110.js");
+Object.defineProperty(exports, "computeRule110Def", { enumerable: true, get: function () { return compute_rule110_js_1.computeRule110Def; } });

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

@@ -7,7 +7,7 @@
  * @example
  * ```typescript
  * import {
- *   ContractState,
+ *   State,
  *   Contract,
  *   getContractDefinition,
  *   CONTRACTS_DEFINITIONS
@@ -20,10 +20,14 @@
  * @packageDocumentation
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEscrowDefinition = exports.getContractDefinition = exports.CONTRACTS_DEFINITIONS = exports.contractEscrowDef = exports.contractAgreementDef = exports.contractUniversalDef = exports.contractStateToJSON = exports.contractStateFromJSON = exports.ContractDefinition = exports.DisputeContractRequest = exports.RejectContractRequest = exports.CompleteContractRequest = exports.AcceptContractRequest = exports.ProposeContractRequest = exports.Contract = exports.ContractState = void 0;
-// Re-export generated protobuf types (source of truth)
+exports.CONTRACTS_DEFINITIONS = exports.contractEscrowDef = exports.contractAgreementDef = exports.contractUniversalDef = exports.contractStateToJSON = exports.contractStateFromJSON = exports.ContractState = exports.stateToJSON = exports.stateFromJSON = exports.ContractDefinition = exports.DisputeContractRequest = exports.RejectContractRequest = exports.CompleteContractRequest = exports.AcceptContractRequest = exports.ProposeContractRequest = exports.Contract = exports.State = void 0;
+exports.getContractDefinition = getContractDefinition;
+exports.getEscrowDefinition = getEscrowDefinition;
+// 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.
 var contract_js_1 = require("../../generated/ottochain/apps/contracts/v1/contract.js");
-Object.defineProperty(exports, "ContractState", { enumerable: true, get: function () { return contract_js_1.ContractState; } });
+Object.defineProperty(exports, "State", { enumerable: true, get: function () { return contract_js_1.State; } });
 Object.defineProperty(exports, "Contract", { enumerable: true, get: function () { return contract_js_1.Contract; } });
 Object.defineProperty(exports, "ProposeContractRequest", { enumerable: true, get: function () { return contract_js_1.ProposeContractRequest; } });
 Object.defineProperty(exports, "AcceptContractRequest", { enumerable: true, get: function () { return contract_js_1.AcceptContractRequest; } });
@@ -31,8 +35,13 @@ Object.defineProperty(exports, "CompleteContractRequest", { enumerable: true, ge
 Object.defineProperty(exports, "RejectContractRequest", { enumerable: true, get: function () { return contract_js_1.RejectContractRequest; } });
 Object.defineProperty(exports, "DisputeContractRequest", { enumerable: true, get: function () { return contract_js_1.DisputeContractRequest; } });
 Object.defineProperty(exports, "ContractDefinition", { enumerable: true, get: function () { return contract_js_1.ContractDefinition; } });
-Object.defineProperty(exports, "contractStateFromJSON", { enumerable: true, get: function () { return contract_js_1.contractStateFromJSON; } });
-Object.defineProperty(exports, "contractStateToJSON", { enumerable: true, get: function () { return contract_js_1.contractStateToJSON; } });
+Object.defineProperty(exports, "stateFromJSON", { enumerable: true, get: function () { return contract_js_1.stateFromJSON; } });
+Object.defineProperty(exports, "stateToJSON", { enumerable: true, get: function () { return contract_js_1.stateToJSON; } });
+// Deprecated app-prefixed alias (renamed to State); kept for compat.
+var contract_js_2 = require("../../generated/ottochain/apps/contracts/v1/contract.js");
+Object.defineProperty(exports, "ContractState", { enumerable: true, get: function () { return contract_js_2.State; } });
+Object.defineProperty(exports, "contractStateFromJSON", { enumerable: true, get: function () { return contract_js_2.stateFromJSON; } });
+Object.defineProperty(exports, "contractStateToJSON", { enumerable: true, get: function () { return contract_js_2.stateToJSON; } });
 // ---------------------------------------------------------------------------
 // State Machine Definitions (generated from JSON at build time)
 // ---------------------------------------------------------------------------
@@ -50,12 +59,10 @@ exports.CONTRACTS_DEFINITIONS = {
  * Get a contract state machine definition by type.
  * @param type - 'universal' | 'agreement' | 'escrow' (default: 'agreement')
  */
-function getContractDefinition(type = "agreement") {
+function getContractDefinition(type = 'agreement') {
     return exports.CONTRACTS_DEFINITIONS[type];
 }
-exports.getContractDefinition = getContractDefinition;
 /** @deprecated Use getContractDefinition('escrow') */
 function getEscrowDefinition() {
     return index_js_1.contractEscrowDef;
 }
-exports.getEscrowDefinition = getEscrowDefinition;