@ottochain/sdk 2.3.0 → 2.4.0

package/dist/types/zk/prover.d.ts

@@ -0,0 +1,34 @@
+import type { Groth16Bundle } from './types';
+/** A request to prove that evaluating `expr` over `data` yields a result (raw JSON — canonicalized here). */
+export interface Groth16ProveRequest {
+    /** The JLVM rule (plain JSON). Canonicalized before it reaches the prover. */
+    expr: unknown;
+    /** The (private) data context (plain JSON). Canonicalized before it reaches the prover. */
+    data: unknown;
+}
+/** Produces SP1-Groth16 bundles for the semi-private tier. Swap implementations in tests. */
+export interface ZkProver {
+    proveGroth16(req: Groth16ProveRequest): Promise<Groth16Bundle>;
+}
+/** Configuration for {@link SubprocessProver}. Provide a binary OR a cargo manifest (binary wins). */
+export interface SubprocessProverOptions {
+    /** Path to a prebuilt zk-jlvm host binary. Defaults to `ZK_JLVM_BIN`. */
+    binaryPath?: string;
+    /** Path to the zk-jlvm `script` crate's `Cargo.toml` (run via `cargo run --release`). Defaults to `ZK_JLVM_MANIFEST`. */
+    cargoManifestPath?: string;
+    /** Extra environment for the child (e.g. `{ SP1_PROVER: 'cuda' }`). Merged over `process.env`. */
+    env?: Record<string, string>;
+    /** Working directory for the child process. */
+    cwd?: string;
+    /** Hard timeout in ms. Default 1_800_000 (30 min) — SP1 Groth16 wrapping is slow. */
+    timeoutMs?: number;
+}
+/** Parse the host's `vkey:` / `public values:` / `proof bytes:` stdout lines into a bundle. */
+export declare function parseGroth16Stdout(stdout: string): Groth16Bundle;
+/** Drives the zk-jlvm host out-of-process. */
+export declare class SubprocessProver implements ZkProver {
+    private readonly opts;
+    constructor(opts?: SubprocessProverOptions);
+    proveGroth16(req: Groth16ProveRequest): Promise<Groth16Bundle>;
+    private run;
+}

package/dist/types/zk/registry.d.ts

@@ -0,0 +1,34 @@
+/** A registered rule and the public `logicHash` that pins it on-chain and in proofs. */
+export interface RegisteredRule {
+    /** The JLVM rule, as plain JSON (canonicalized when hashed and when fed to the prover). */
+    rule: unknown;
+    /** `keccak256(canonicalize(rule))` — the on-chain `logicHash` and a proof's `exprHash` word. */
+    logicHash: `0x${string}`;
+}
+/** A client-side registry mapping rule names to their canonical `logicHash`. */
+export declare class ExprRegistry {
+    private readonly byName;
+    /** Register (or replace) a named rule; returns the entry with its computed `logicHash`. */
+    register(name: string, rule: unknown): RegisteredRule;
+    /** Whether a rule is registered under `name`. */
+    has(name: string): boolean;
+    /** The registered rule, or throw if unknown. */
+    ruleOf(name: string): unknown;
+    /** The registered rule's `logicHash`, or throw if unknown. */
+    logicHashOf(name: string): `0x${string}`;
+    /** All registered names, in insertion order. */
+    names(): string[];
+    private require;
+}
+/** The comparators a bound rule can pin a private value against. */
+export type Comparator = '>=' | '>' | '<=' | '<' | '==' | '!=';
+/**
+ * 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).
+ */
+export declare function boundRule(varName: string, op: Comparator, bound: number | string): Record<string, unknown>;
+/** `{">=":[{"var":varName}, bound]}` — "the hidden `varName` is at least `bound`". */
+export declare const atLeast: (varName: string, bound: number | string) => Record<string, unknown>;
+/** `{"<=":[{"var":varName}, bound]}` — "the hidden `varName` is at most `bound`". */
+export declare const atMost: (varName: string, bound: number | string) => Record<string, unknown>;

package/dist/types/zk/types.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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.
+ */
+/** The decoded zk-jlvm public values: the keccak triple + the ok bit. */
+export interface DecodedPublicValues {
+    /** keccak256(canonicalize(expr)) — pins WHICH JLVM rule ran (equals the registry logicHash). */
+    exprHash: `0x${string}`;
+    /** keccak256(canonicalize(data)) — the (private) data context's hash. */
+    dataHash: `0x${string}`;
+    /** keccak256(canonicalize(output)) — for a guarded "rule == true" proof, equals KECCAK_TRUE. */
+    outputHash: `0x${string}`;
+    /** Whether the JLVM evaluation succeeded (false ⇒ the guest aborted / errored). */
+    ok: boolean;
+}
+/** A produced SP1-Groth16 bundle from the zk-jlvm prover (`--mode groth16`). */
+export interface Groth16Bundle {
+    /** `abi_encode(JlvmPublicValues)` as a `0x` hex string. */
+    publicValues: `0x${string}`;
+    /** SP1 Groth16 proof bytes as a `0x` hex string. */
+    proof: `0x${string}`;
+    /** The program verification key (`bytes32`) as a `0x` hex string. */
+    vkey: `0x${string}`;
+}
+/**
+ * Decode `abi_encode(JlvmPublicValues)`: four 32-byte words `[exprHash | dataHash | outputHash | ok]`.
+ * The bool is right-aligned in its word (final byte `0x00`/`0x01`).
+ */
+export declare function decodeJlvmPublicValues(pv: `0x${string}`): DecodedPublicValues;

package/dist/types/zk/witness.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Witness shapers: turn a produced proof bundle (or a Merkle inclusion path) into the exact
+ * `JsonLogicValue` map a holder carries on a signed op's `witness` field. The combiner injects that
+ * map under the `witness` context key, and the policy guard reads `witness.publicValues` /
+ * `witness.proof` (groth16) or `witness.leaf` / `witness.index` / `witness.siblings` (pmt) — the
+ * shapes are fixed by metakit's guard opcodes (see ottochain ZkGatedMorphismSuite).
+ */
+import type { FrHex } from './commit';
+import { type DecodedPublicValues, type Groth16Bundle } from './types';
+/** The on-op map a `groth16_verify` guard reads. The vkey is NOT here — it is a literal in the guard. */
+export interface Groth16WitnessMap {
+    /** `abi_encode(JlvmPublicValues)` as `0x` hex — the guard's `witness.publicValues`. */
+    publicValues: `0x${string}`;
+    /** SP1-Groth16 proof bytes as `0x` hex — the guard's `witness.proof`. */
+    proof: `0x${string}`;
+}
+/** A groth16 witness ready to attach to an op, plus its decoded public values for client binding. */
+export interface Groth16Witness {
+    /** Attach this to the op's `witness` field (it is a plain `JsonLogicValue` map). */
+    witness: Groth16WitnessMap;
+    /** The decoded `{exprHash, dataHash, outputHash, ok}` — inspect/bind BEFORE submitting. */
+    decoded: DecodedPublicValues;
+}
+/**
+ * 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.
+ */
+export declare function groth16Witness(bundle: Groth16Bundle): Groth16Witness;
+/**
+ * The on-op map a `pmt_verify` guard reads. `siblings` is the authentication path in the order the
+ * `pmt_verify` opcode folds it (ROOT-FIRST / top-down, as produced by metakit's PoseidonMerkleTree);
+ * `index` is the leaf position. Pass values straight through from the tree builder — do not reorder.
+ */
+export interface PmtWitnessMap {
+    leaf: FrHex;
+    index: number;
+    siblings: FrHex[];
+}
+/** Shape a Poseidon-Merkle inclusion path into the on-op `pmt_verify` witness map. */
+export declare function pmtWitness(leaf: FrHex, index: number, siblings: FrHex[]): PmtWitnessMap;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ottochain/sdk",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "TypeScript SDK for ottochain metagraph operations - signing, encoding, and network interactions",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -21,6 +21,11 @@
       "require": "./dist/cjs/ottochain/index.js",
       "types": "./dist/types/ottochain/index.d.ts"
     },
+    "./zk": {
+      "import": "./dist/esm/zk/index.js",
+      "require": "./dist/cjs/zk/index.js",
+      "types": "./dist/types/zk/index.d.ts"
+    },
     "./apps/identity": {
       "import": "./dist/esm/apps/identity/index.js",
       "require": "./dist/cjs/apps/identity/index.js",
@@ -36,6 +41,11 @@
       "require": "./dist/cjs/apps/markets/index.js",
       "types": "./dist/types/apps/markets/index.d.ts"
     },
+    "./apps/lending": {
+      "import": "./dist/esm/apps/lending/index.js",
+      "require": "./dist/cjs/apps/lending/index.js",
+      "types": "./dist/types/apps/lending/index.d.ts"
+    },
     "./apps/oracles": {
       "import": "./dist/esm/apps/oracles/index.js",
       "require": "./dist/cjs/apps/oracles/index.js",
@@ -77,6 +87,7 @@
     "lint": "eslint src tests",
     "format": "prettier --write src tests",
     "generate": "buf generate",
+    "gen:openapi": "openapi-typescript openapi/ottochain-openapi.json -o src/generated/openapi.ts",
     "lint:proto": "buf lint",
     "docs": "typedoc",
     "docs:watch": "typedoc --watch",
@@ -107,31 +118,34 @@
   },
   "dependencies": {
     "@bufbuild/protobuf": "^2.12.0",
-    "@constellation-network/metagraph-sdk": "^0.2.0",
+    "@constellation-network/metagraph-sdk": "1.8.0-rc.5",
+    "@constellation-network/metagraph-sdk-jlvm": "1.8.0-rc.5",
+    "@noble/hashes": "^1.8.0",
     "@stardust-collective/dag4": "^2.6.0",
     "@stardust-collective/dag4-keystore": "^2.6.0",
     "canonicalize": "^3.0.0",
     "js-sha256": "^0.11.1",
     "js-sha512": "^0.9.0",
-    "zod": "^3.22.0"
+    "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@babel/preset-env": "^7.29.0",
-    "@commitlint/cli": "^20.5.2",
-    "@commitlint/config-conventional": "^20.5.0",
-    "@eslint/js": "^9.39.4",
+    "@babel/preset-env": "^7.29.7",
+    "@commitlint/cli": "^21.0.2",
+    "@commitlint/config-conventional": "^21.0.2",
+    "@eslint/js": "^10.0.1",
     "@jest/globals": "^30.3.0",
     "@types/jest": "^30.0.0",
-    "@types/node": "^25.6.0",
-    "@typescript-eslint/eslint-plugin": "^8.56.1",
-    "@typescript-eslint/parser": "^8.59.0",
-    "eslint": "^9.39.3",
+    "@types/node": "^25.9.3",
+    "@typescript-eslint/eslint-plugin": "^8.61.0",
+    "@typescript-eslint/parser": "^8.61.0",
+    "eslint": "^10.5.0",
     "jest": "^30.3.0",
-    "prettier": "^3.8.3",
+    "openapi-typescript": "^7.13.0",
+    "prettier": "^3.8.4",
     "ts-jest": "29.4.9",
     "ts-proto": "^2.11.6",
     "typedoc": "^0.28.19",
-    "typescript": "^5.0.0"
+    "typescript": "^6.0.3"
   },
   "peerDependencies": {
     "@stardust-collective/dag4": "^2.6.0"

package/dist/cjs/ottochain/normalize.js

@@ -1,186 +0,0 @@
-"use strict";
-/**
- * Normalize OttoChain Messages for Signing
- *
- * Converts OttoChain message objects to the wire format expected by the
- * Scala metagraph. Specifically, ensures all `Option[A]=None` fields are
- * present as explicit `null` values, matching what circe's magnolia encoder
- * produces on the Scala side.
- *
- * This is necessary because metakit's `JsonBinaryCodec.deriveDataUpdate`
- * (rc.8) canonicalizes the circe-encoded JSON **including null fields**.
- * If the TypeScript client omits optional fields (undefined), the canonical
- * JSON won't match and signature verification will fail.
- *
- * Schema mapping (Scala → TypeScript):
- * - `Option[A] = None` → `null` (must be explicit, not undefined/absent)
- * - `Option[A] = Some(v)` → `v`
- * - `List.empty` → `[]`
- * - `Map.empty` → `{}`
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeMessage = exports.normalizeArchiveStateMachine = exports.normalizeTransitionStateMachine = exports.normalizeCreateStateMachine = void 0;
-/**
- * Normalize a State object for wire format
- */
-function normalizeState(state) {
-    return {
-        id: state.id,
-        isFinal: state.isFinal ?? false,
-        metadata: state.metadata ?? null,
-    };
-}
-/**
- * Normalize a Transition object for wire format
- *
- * Scala Transition schema:
- *   from: StateId (required)
- *   to: StateId (required)
- *   eventName: String (required)
- *   guard: JsonLogicExpression (required)
- *   effect: JsonLogicExpression (required)
- *   dependencies: Set[UUID] = Set.empty
- *
- * `dependencies` serializes as `[]` when empty (default). Both `guard`
- * and `effect` are required non-optional fields.
- */
-function normalizeTransition(t) {
-    return {
-        from: t.from,
-        to: t.to,
-        eventName: t.eventName,
-        guard: t.guard,
-        effect: t.effect,
-        dependencies: t.dependencies ?? [],
-    };
-}
-/**
- * Check if a value looks like FiberAppMetadata (has 'name' and 'app' fields).
- * These TypeScript-only fields should be stripped before sending to metagraph.
- */
-function isFiberAppMetadata(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        'name' in value &&
-        'app' in value);
-}
-/**
- * Normalize a StateMachineDefinition for wire format
- *
- * Strips FiberAppMetadata from the definition — the Scala schema expects
- * `metadata: Option[Json] = None`, not the TypeScript app metadata object.
- */
-function normalizeDefinition(def) {
-    const states = def.states;
-    const normalizedStates = {};
-    if (states) {
-        for (const [key, state] of Object.entries(states)) {
-            normalizedStates[key] = normalizeState(state);
-        }
-    }
-    const transitions = def.transitions ?? [];
-    // Strip FiberAppMetadata if present — it's TypeScript-only, not part of wire format.
-    // The Scala schema has `metadata: Option[Json] = None`, so use null for wire format.
-    const wireMetadata = isFiberAppMetadata(def.metadata) ? null : (def.metadata ?? null);
-    return {
-        states: normalizedStates,
-        initialState: def.initialState,
-        transitions: transitions.map(normalizeTransition),
-        metadata: wireMetadata,
-    };
-}
-/**
- * Normalize a CreateStateMachine message for wire format
- *
- * Ensures all Option/default fields are explicit in wire format:
- * - definition.metadata → null when absent
- * - definition.states[*].metadata → null when absent
- * - definition.transitions[*].dependencies → [] when absent
- * - parentFiberId → null when absent
- *
- * @example
- * ```typescript
- * const message = normalizeCreateStateMachine({
- *   fiberId: '...',
- *   definition: { states: { INIT: { id: { value: 'INIT' }, isFinal: false } }, ... },
- *   initialData: {}
- * });
- * // message now has parentFiberId: null, definition.metadata: null, etc.
- * ```
- */
-function normalizeCreateStateMachine(msg) {
-    return {
-        fiberId: msg.fiberId,
-        definition: normalizeDefinition(msg.definition),
-        initialData: msg.initialData ?? {},
-        parentFiberId: msg.parentFiberId ?? null,
-    };
-}
-exports.normalizeCreateStateMachine = normalizeCreateStateMachine;
-/**
- * Normalize a TransitionStateMachine message for wire format
- *
- * Scala TransitionStateMachine schema:
- *   fiberId: UUID (required)
- *   eventName: String (required)
- *   payload: JsonLogicValue (required)
- *   targetSequenceNumber: FiberOrdinal (required)
- *
- * All fields are required — no Option types, so no null normalization needed.
- */
-function normalizeTransitionStateMachine(msg) {
-    return {
-        fiberId: msg.fiberId,
-        eventName: msg.eventName,
-        payload: msg.payload,
-        targetSequenceNumber: msg.targetSequenceNumber,
-    };
-}
-exports.normalizeTransitionStateMachine = normalizeTransitionStateMachine;
-/**
- * Normalize an ArchiveStateMachine message for wire format
- *
- * Scala ArchiveStateMachine schema:
- *   fiberId: UUID (required)
- *   targetSequenceNumber: FiberOrdinal (required)
- *
- * All fields are required — no Option types, so no null normalization needed.
- */
-function normalizeArchiveStateMachine(msg) {
-    return {
-        fiberId: msg.fiberId,
-        targetSequenceNumber: msg.targetSequenceNumber,
-    };
-}
-exports.normalizeArchiveStateMachine = normalizeArchiveStateMachine;
-/**
- * Normalize any OttochainMessage wrapper for wire format.
- *
- * Detects the message type from the wrapper key and applies the
- * appropriate normalization.
- *
- * @param message - OttochainMessage in wrapper format: `{ CreateStateMachine: {...} }`
- * @returns Normalized message with all Option fields as explicit null
- *
- * @example
- * ```typescript
- * const normalized = normalizeMessage({
- *   CreateStateMachine: { fiberId: '...', definition: {...}, initialData: {} }
- * });
- * const signed = await signDataUpdate(normalized, privateKey);
- * ```
- */
-function normalizeMessage(message) {
-    if ('CreateStateMachine' in message) {
-        return { CreateStateMachine: normalizeCreateStateMachine(message.CreateStateMachine) };
-    }
-    if ('TransitionStateMachine' in message) {
-        return { TransitionStateMachine: normalizeTransitionStateMachine(message.TransitionStateMachine) };
-    }
-    if ('ArchiveStateMachine' in message) {
-        return { ArchiveStateMachine: normalizeArchiveStateMachine(message.ArchiveStateMachine) };
-    }
-    // CreateScript and InvokeScript — pass through (no optional fields)
-    return message;
-}
-exports.normalizeMessage = normalizeMessage;

package/dist/esm/ottochain/normalize.js

@@ -1,179 +0,0 @@
-/**
- * Normalize OttoChain Messages for Signing
- *
- * Converts OttoChain message objects to the wire format expected by the
- * Scala metagraph. Specifically, ensures all `Option[A]=None` fields are
- * present as explicit `null` values, matching what circe's magnolia encoder
- * produces on the Scala side.
- *
- * This is necessary because metakit's `JsonBinaryCodec.deriveDataUpdate`
- * (rc.8) canonicalizes the circe-encoded JSON **including null fields**.
- * If the TypeScript client omits optional fields (undefined), the canonical
- * JSON won't match and signature verification will fail.
- *
- * Schema mapping (Scala → TypeScript):
- * - `Option[A] = None` → `null` (must be explicit, not undefined/absent)
- * - `Option[A] = Some(v)` → `v`
- * - `List.empty` → `[]`
- * - `Map.empty` → `{}`
- */
-/**
- * Normalize a State object for wire format
- */
-function normalizeState(state) {
-    return {
-        id: state.id,
-        isFinal: state.isFinal ?? false,
-        metadata: state.metadata ?? null,
-    };
-}
-/**
- * Normalize a Transition object for wire format
- *
- * Scala Transition schema:
- *   from: StateId (required)
- *   to: StateId (required)
- *   eventName: String (required)
- *   guard: JsonLogicExpression (required)
- *   effect: JsonLogicExpression (required)
- *   dependencies: Set[UUID] = Set.empty
- *
- * `dependencies` serializes as `[]` when empty (default). Both `guard`
- * and `effect` are required non-optional fields.
- */
-function normalizeTransition(t) {
-    return {
-        from: t.from,
-        to: t.to,
-        eventName: t.eventName,
-        guard: t.guard,
-        effect: t.effect,
-        dependencies: t.dependencies ?? [],
-    };
-}
-/**
- * Check if a value looks like FiberAppMetadata (has 'name' and 'app' fields).
- * These TypeScript-only fields should be stripped before sending to metagraph.
- */
-function isFiberAppMetadata(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        'name' in value &&
-        'app' in value);
-}
-/**
- * Normalize a StateMachineDefinition for wire format
- *
- * Strips FiberAppMetadata from the definition — the Scala schema expects
- * `metadata: Option[Json] = None`, not the TypeScript app metadata object.
- */
-function normalizeDefinition(def) {
-    const states = def.states;
-    const normalizedStates = {};
-    if (states) {
-        for (const [key, state] of Object.entries(states)) {
-            normalizedStates[key] = normalizeState(state);
-        }
-    }
-    const transitions = def.transitions ?? [];
-    // Strip FiberAppMetadata if present — it's TypeScript-only, not part of wire format.
-    // The Scala schema has `metadata: Option[Json] = None`, so use null for wire format.
-    const wireMetadata = isFiberAppMetadata(def.metadata) ? null : (def.metadata ?? null);
-    return {
-        states: normalizedStates,
-        initialState: def.initialState,
-        transitions: transitions.map(normalizeTransition),
-        metadata: wireMetadata,
-    };
-}
-/**
- * Normalize a CreateStateMachine message for wire format
- *
- * Ensures all Option/default fields are explicit in wire format:
- * - definition.metadata → null when absent
- * - definition.states[*].metadata → null when absent
- * - definition.transitions[*].dependencies → [] when absent
- * - parentFiberId → null when absent
- *
- * @example
- * ```typescript
- * const message = normalizeCreateStateMachine({
- *   fiberId: '...',
- *   definition: { states: { INIT: { id: { value: 'INIT' }, isFinal: false } }, ... },
- *   initialData: {}
- * });
- * // message now has parentFiberId: null, definition.metadata: null, etc.
- * ```
- */
-export function normalizeCreateStateMachine(msg) {
-    return {
-        fiberId: msg.fiberId,
-        definition: normalizeDefinition(msg.definition),
-        initialData: msg.initialData ?? {},
-        parentFiberId: msg.parentFiberId ?? null,
-    };
-}
-/**
- * Normalize a TransitionStateMachine message for wire format
- *
- * Scala TransitionStateMachine schema:
- *   fiberId: UUID (required)
- *   eventName: String (required)
- *   payload: JsonLogicValue (required)
- *   targetSequenceNumber: FiberOrdinal (required)
- *
- * All fields are required — no Option types, so no null normalization needed.
- */
-export function normalizeTransitionStateMachine(msg) {
-    return {
-        fiberId: msg.fiberId,
-        eventName: msg.eventName,
-        payload: msg.payload,
-        targetSequenceNumber: msg.targetSequenceNumber,
-    };
-}
-/**
- * Normalize an ArchiveStateMachine message for wire format
- *
- * Scala ArchiveStateMachine schema:
- *   fiberId: UUID (required)
- *   targetSequenceNumber: FiberOrdinal (required)
- *
- * All fields are required — no Option types, so no null normalization needed.
- */
-export function normalizeArchiveStateMachine(msg) {
-    return {
-        fiberId: msg.fiberId,
-        targetSequenceNumber: msg.targetSequenceNumber,
-    };
-}
-/**
- * Normalize any OttochainMessage wrapper for wire format.
- *
- * Detects the message type from the wrapper key and applies the
- * appropriate normalization.
- *
- * @param message - OttochainMessage in wrapper format: `{ CreateStateMachine: {...} }`
- * @returns Normalized message with all Option fields as explicit null
- *
- * @example
- * ```typescript
- * const normalized = normalizeMessage({
- *   CreateStateMachine: { fiberId: '...', definition: {...}, initialData: {} }
- * });
- * const signed = await signDataUpdate(normalized, privateKey);
- * ```
- */
-export function normalizeMessage(message) {
-    if ('CreateStateMachine' in message) {
-        return { CreateStateMachine: normalizeCreateStateMachine(message.CreateStateMachine) };
-    }
-    if ('TransitionStateMachine' in message) {
-        return { TransitionStateMachine: normalizeTransitionStateMachine(message.TransitionStateMachine) };
-    }
-    if ('ArchiveStateMachine' in message) {
-        return { ArchiveStateMachine: normalizeArchiveStateMachine(message.ArchiveStateMachine) };
-    }
-    // CreateScript and InvokeScript — pass through (no optional fields)
-    return message;
-}

package/dist/types/ottochain/normalize.d.ts

@@ -1,79 +0,0 @@
-/**
- * Normalize OttoChain Messages for Signing
- *
- * Converts OttoChain message objects to the wire format expected by the
- * Scala metagraph. Specifically, ensures all `Option[A]=None` fields are
- * present as explicit `null` values, matching what circe's magnolia encoder
- * produces on the Scala side.
- *
- * This is necessary because metakit's `JsonBinaryCodec.deriveDataUpdate`
- * (rc.8) canonicalizes the circe-encoded JSON **including null fields**.
- * If the TypeScript client omits optional fields (undefined), the canonical
- * JSON won't match and signature verification will fail.
- *
- * Schema mapping (Scala → TypeScript):
- * - `Option[A] = None` → `null` (must be explicit, not undefined/absent)
- * - `Option[A] = Some(v)` → `v`
- * - `List.empty` → `[]`
- * - `Map.empty` → `{}`
- */
-/**
- * Normalize a CreateStateMachine message for wire format
- *
- * Ensures all Option/default fields are explicit in wire format:
- * - definition.metadata → null when absent
- * - definition.states[*].metadata → null when absent
- * - definition.transitions[*].dependencies → [] when absent
- * - parentFiberId → null when absent
- *
- * @example
- * ```typescript
- * const message = normalizeCreateStateMachine({
- *   fiberId: '...',
- *   definition: { states: { INIT: { id: { value: 'INIT' }, isFinal: false } }, ... },
- *   initialData: {}
- * });
- * // message now has parentFiberId: null, definition.metadata: null, etc.
- * ```
- */
-export declare function normalizeCreateStateMachine(msg: Record<string, unknown>): Record<string, unknown>;
-/**
- * Normalize a TransitionStateMachine message for wire format
- *
- * Scala TransitionStateMachine schema:
- *   fiberId: UUID (required)
- *   eventName: String (required)
- *   payload: JsonLogicValue (required)
- *   targetSequenceNumber: FiberOrdinal (required)
- *
- * All fields are required — no Option types, so no null normalization needed.
- */
-export declare function normalizeTransitionStateMachine(msg: Record<string, unknown>): Record<string, unknown>;
-/**
- * Normalize an ArchiveStateMachine message for wire format
- *
- * Scala ArchiveStateMachine schema:
- *   fiberId: UUID (required)
- *   targetSequenceNumber: FiberOrdinal (required)
- *
- * All fields are required — no Option types, so no null normalization needed.
- */
-export declare function normalizeArchiveStateMachine(msg: Record<string, unknown>): Record<string, unknown>;
-/**
- * Normalize any OttochainMessage wrapper for wire format.
- *
- * Detects the message type from the wrapper key and applies the
- * appropriate normalization.
- *
- * @param message - OttochainMessage in wrapper format: `{ CreateStateMachine: {...} }`
- * @returns Normalized message with all Option fields as explicit null
- *
- * @example
- * ```typescript
- * const normalized = normalizeMessage({
- *   CreateStateMachine: { fiberId: '...', definition: {...}, initialData: {} }
- * });
- * const signed = await signDataUpdate(normalized, privateKey);
- * ```
- */
-export declare function normalizeMessage(message: Record<string, unknown>): Record<string, unknown>;