@ottochain/sdk 2.3.0 → 2.5.0

package/dist/cjs/templates/asset-policy.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sumBehavior = sumBehavior;
+exports.defaultStateTypeName = defaultStateTypeName;
+exports.fungiblePolicy = fungiblePolicy;
+exports.nftPolicy = nftPolicy;
+exports.soulboundPolicy = soulboundPolicy;
+exports.customPolicy = customPolicy;
+/**
+ * Asset-policy preset builders (§1.1 of the SDK std-lib/templates handoff).
+ *
+ * Each builder is a PURE function that emits the exact {@link CreateAssetPolicy} wire body the chain
+ * re-derives — no `Date.now()`/`Math.random()`/`crypto.randomUUID()`; fixed inputs → fixed output. The
+ * on-chain policy `schemaHash` and `logicHash` are both `RegistryShape.AssetPolicy.computeDigest` over
+ * `behavior`/`supply`/`morphisms`/`stateShape` (no JSON-Logic body), so these presets are pure data.
+ *
+ * Hard invariants (CLAUDE.md rule #1 — the signed canonical is frozen):
+ *  - `behavior` is ALWAYS summed from {@link TOKEN_BEHAVIOR_BITS} (T=16, S=8, C=4, E=2, G=1), never a
+ *    magic literal int.
+ *  - `morphisms` is REQUIRED on the wire (presence required, emptiness meaningful) — emit `{}` when empty,
+ *    NEVER omit it.
+ *  - `supply` is REQUIRED — emit `{}` when there is no supply authority, never omit it.
+ *  - Absent optionals are OMITTED, never emitted as `null`/`undefined` (the chain signs over
+ *    `JCS(dropNulls(payload))`).
+ *
+ * @see src/ottochain/types.ts — CreateAssetPolicy, SupplyPolicy, MorphismSpec, MorphismKind, TOKEN_BEHAVIOR_BITS
+ */
+const types_js_1 = require("../ottochain/types.js");
+/** The default mint/burn guard the riverdale presets use: an always-true predicate `{"==":[1,1]}`. */
+const alwaysTrue = () => ({ '==': [1, 1] });
+/** A `PUBLIC`-visibility morphism spec (the riverdale preset visibility). Fresh object per call. */
+const publicMorphism = () => ({ visibility: 'PUBLIC' });
+/** Sum behavior bits from their NAMES — never a magic literal int (CLAUDE.md #1). */
+function sumBehavior(bits) {
+    return bits.reduce((acc, name) => acc + types_js_1.TOKEN_BEHAVIOR_BITS[name], 0);
+}
+/**
+ * Derive the default `stateShape.typeName`: strip a trailing `.asset` label, PascalCase the remainder
+ * (splitting on `.`/`-`/`_`/space), then append `State`.
+ *   `rvd.asset` → `RvdState`, `goods.asset` → `GoodsState`, `capped.asset` → `CappedState`.
+ */
+function defaultStateTypeName(name) {
+    const ASSET_SUFFIX = '.asset';
+    const base = name.endsWith(ASSET_SUFFIX) ? name.slice(0, -ASSET_SUFFIX.length) : name;
+    const pascal = base
+        .split(/[.\-_\s]+/)
+        .filter(Boolean)
+        .map((seg) => seg.charAt(0).toUpperCase() + seg.slice(1))
+        .join('');
+    return `${pascal}State`;
+}
+/** Build a {@link SupplyPolicy}, OMITTING every absent field (no `undefined`/`null` keys). */
+function buildSupply(opts) {
+    const supply = {};
+    if (opts.maxSupply !== undefined)
+        supply.maxSupply = opts.maxSupply;
+    if (opts.mintPolicy !== undefined)
+        supply.mintPolicy = opts.mintPolicy;
+    if (opts.burnPolicy !== undefined)
+        supply.burnPolicy = opts.burnPolicy;
+    if (opts.decimals !== undefined)
+        supply.decimals = opts.decimals;
+    return supply;
+}
+/** Assemble the final {@link CreateAssetPolicy}, attaching `metadata` only when present. */
+function assemble(args) {
+    const stateShape = {
+        typeName: args.stateTypeName ?? defaultStateTypeName(args.name),
+        fields: [],
+    };
+    const policy = {
+        name: args.name,
+        version: args.version,
+        behavior: args.behavior,
+        supply: args.supply,
+        morphisms: args.morphisms,
+        stateShape,
+    };
+    if (args.metadata !== undefined)
+        policy.metadata = args.metadata;
+    return policy;
+}
+/**
+ * Fungible currency. Behavior `T|S|C = 28` (transferable + splittable + combinable). Standard morphism
+ * set TRANSFER + FRACTIONALIZE + STAKE (`stakeable`, default true) + BURN (when `burnable`), all PUBLIC.
+ *
+ * Reproduces `riverdale-economy/rvd-policy.json` exactly via
+ * `fungiblePolicy({ name: 'rvd.asset', version: '1.0.0', mintable: true, burnable: true })`.
+ */
+function fungiblePolicy(p) {
+    const behavior = sumBehavior(['transferable', 'splittable', 'combinable']); // 28
+    const morphisms = {
+        TRANSFER: publicMorphism(),
+        FRACTIONALIZE: publicMorphism(),
+    };
+    if (p.stakeable !== false)
+        morphisms.STAKE = publicMorphism();
+    if (p.burnable)
+        morphisms.BURN = publicMorphism();
+    let mintPolicy;
+    if (p.mintGuard !== undefined)
+        mintPolicy = p.mintGuard;
+    else if (p.mintable)
+        mintPolicy = alwaysTrue();
+    const supply = buildSupply({
+        maxSupply: p.maxSupply,
+        mintPolicy,
+        burnPolicy: p.burnable ? alwaysTrue() : undefined,
+        decimals: p.decimals,
+    });
+    return assemble({
+        name: p.name,
+        version: p.version,
+        behavior,
+        supply,
+        morphisms,
+        stateTypeName: p.stateTypeName,
+        metadata: p.metadata,
+    });
+}
+/**
+ * Non-fungible token. Behavior `T = 16`, or `T|C = 20` with `combinable: true` (the riverdale
+ * `goods.asset`); `transferable: false` drops the T bit (a bound collectible). `morphisms` is `{}` by
+ * default (emitted explicitly, never omitted). Mintable by default ⇒ `supply.mintPolicy = {"==":[1,1]}`.
+ *
+ * Reproduces `riverdale-economy/goods-policy.json` exactly via
+ * `nftPolicy({ name: 'goods.asset', version: '1.0.0', combinable: true })`.
+ */
+function nftPolicy(p) {
+    const bits = [];
+    if (p.transferable !== false)
+        bits.push('transferable');
+    if (p.combinable)
+        bits.push('combinable');
+    const behavior = sumBehavior(bits);
+    let mintPolicy;
+    if (p.mintGuard !== undefined)
+        mintPolicy = p.mintGuard;
+    else if (p.mintable !== false)
+        mintPolicy = alwaysTrue();
+    const supply = buildSupply({ maxSupply: p.maxSupply, mintPolicy });
+    return assemble({
+        name: p.name,
+        version: p.version,
+        behavior,
+        supply,
+        morphisms: {},
+        stateTypeName: p.stateTypeName,
+        metadata: p.metadata,
+    });
+}
+/**
+ * Soulbound token: non-transferable, governable only (`G = 1`; `+E = 3` when `expirable`). No TRANSFER
+ * morphism (`morphisms: {}`); minting is closed after issue (empty `supply`).
+ */
+function soulboundPolicy(p) {
+    const bits = ['governable'];
+    if (p.expirable)
+        bits.push('expirable');
+    const behavior = sumBehavior(bits);
+    return assemble({
+        name: p.name,
+        version: p.version,
+        behavior,
+        supply: buildSupply({}), // mint closed after issue
+        morphisms: {}, // non-transferable: no TRANSFER morphism
+        stateTypeName: p.stateTypeName,
+        metadata: p.metadata,
+    });
+}
+/**
+ * Escape hatch: declare `behavior` by NAME (summed from {@link TOKEN_BEHAVIOR_BITS}, never a magic int)
+ * and pass `supply` + `morphisms` through raw. Use when no preset fits.
+ *
+ * Reproduces `riverdale-economy/capped-policy.json` exactly via
+ * `customPolicy({ name: 'capped.asset', version: '1.0.0',
+ *                 behavior: ['transferable', 'splittable', 'combinable'],
+ *                 supply: { maxSupply: 100, mintPolicy: { '==': [1, 1] } }, morphisms: {} })`.
+ */
+function customPolicy(p) {
+    return assemble({
+        name: p.name,
+        version: p.version,
+        behavior: sumBehavior(p.behavior),
+        supply: p.supply,
+        morphisms: p.morphisms,
+        stateTypeName: p.stateTypeName,
+        metadata: p.metadata,
+    });
+}

package/dist/cjs/templates/index.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * `@ottochain/sdk/templates` — the fiber & asset authoring template catalog.
+ *
+ * Typed builders that emit the EXACT canonical wire shapes app authors otherwise hand-roll as raw
+ * JSON-Logic (asset policies, versioned machines, effect directives, migrations, seeded state). Every
+ * builder is additive and pure — it returns the same wire shape the chain re-derives, so a template
+ * output signs to byte-identical `JCS(dropNulls(payload))` (CLAUDE.md rule #1). Hand-rolled JSON keeps
+ * working; these just make the recurring shapes typed, named, and mistake-resistant.
+ *
+ * Origin: the fiber-ergonomics program (ottochain `docs/proposals/fiber-ergonomics/`), Phase A — the
+ * `riverdale-economy` e2e is the migration proof (each preset reproduces its checked-in golden JSON).
+ *
+ * @example
+ * import {
+ *   fungiblePolicy, machine, transition, effect, guard,
+ *   transferAsset, triggers, spawn, seedState, seedFields,
+ * } from '@ottochain/sdk/templates';
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectFiberPolicy = exports.immutable = exports.unconstrained = exports.constrained = exports.toProtoDefinition = exports.defineFiberApp = exports.guard = void 0;
+// ─── 1.1 Asset-policy presets ────────────────────────────────────────────────
+// fungiblePolicy / nftPolicy / soulboundPolicy / customPolicy (+ sumBehavior, defaultStateTypeName,
+// BehaviorBitName) — emit a `CreateAssetPolicy`; behavior is summed from TOKEN_BEHAVIOR_BITS, never a literal.
+__exportStar(require("./asset-policy.js"), exports);
+// ─── 1.2 Versioned-machine skeleton + transition()/effect() ──────────────────
+// machine / transition / effect (+ TransitionSpec, MachineSpec, Machine, …). The skeleton owns ONE
+// canonical wire definition, so publish + create cannot drift (verified binding, F9).
+__exportStar(require("./machine.js"), exports);
+// ─── 1.4 Migration helpers ───────────────────────────────────────────────────
+// seedFields / migration — hides the bare-state-root ({"var":""}) foot-gun.
+__exportStar(require("./migration.js"), exports);
+// ─── 1.5 State-shape-with-defaults ───────────────────────────────────────────
+// seedState / declaredFields / StateShape — auto-seed accumulators so no field reads null (F5).
+__exportStar(require("./state-shape.js"), exports);
+// ─── 1.3 Effect-directive builders ───────────────────────────────────────────
+// transferAsset / triggers / spawn / emit / toFiber / toWallet / addDependency / setDependencyActive /
+// RESERVED_EFFECT_KEYS — a typo'd directive is a TS error, not a silent state field (F4).
+__exportStar(require("../schema/effects.js"), exports);
+// ─── Authorization-guard builders (namespace) ────────────────────────────────
+// `guard.signerIsParty('state.borrower')` reads as intent at the call site.
+exports.guard = __importStar(require("../schema/guards.js"));
+// ─── Existing machine/policy primitives re-surfaced for one-import authoring ──
+var fiber_app_js_1 = require("../schema/fiber-app.js");
+Object.defineProperty(exports, "defineFiberApp", { enumerable: true, get: function () { return fiber_app_js_1.defineFiberApp; } });
+Object.defineProperty(exports, "toProtoDefinition", { enumerable: true, get: function () { return fiber_app_js_1.toProtoDefinition; } });
+Object.defineProperty(exports, "constrained", { enumerable: true, get: function () { return fiber_app_js_1.constrained; } });
+Object.defineProperty(exports, "unconstrained", { enumerable: true, get: function () { return fiber_app_js_1.unconstrained; } });
+Object.defineProperty(exports, "immutable", { enumerable: true, get: function () { return fiber_app_js_1.immutable; } });
+Object.defineProperty(exports, "projectFiberPolicy", { enumerable: true, get: function () { return fiber_app_js_1.projectFiberPolicy; } });

package/dist/cjs/templates/machine.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * Versioned-machine skeleton + `transition()` / `effect()` composition (handoff §1.2).
+ *
+ * Two moves:
+ *   1. `transition()` / `effect()` build the wire `Transition` + its flat effect map from typed
+ *      fragments instead of a hand-rolled JSON blob.
+ *   2. `machine()` is a versioned-package SKELETON that OWNS exactly ONE canonical wire definition
+ *      (`toProtoDefinition(app)`, computed once) and hands the SAME object to BOTH `publishVersion()`
+ *      and `create()`. That is the verified-binding invariant (F9): because publish and create cannot
+ *      drift, the chain's `definition.computeDigest` equals the registered `logicHash` and the bind
+ *      admits the fiber. The skeleton REUSES `toProtoDefinition` (the one canonicalization path) — it
+ *      never re-derives the wire shape.
+ *
+ * Guardrail (CLAUDE.md #1): every builder here is a pure function emitting the exact wire shape the
+ * chain re-derives. Absent optionals (`metadata`/`participants`/`parentFiberId`/`migration`) are
+ * OMITTED, never `null`; required-no-default fields (`strict` on publish, `dependencies: []` per
+ * transition) are ALWAYS present.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transition = transition;
+exports.effect = effect;
+exports.machine = machine;
+const fiber_app_js_1 = require("../schema/fiber-app.js");
+/**
+ * Build a wire {@link Transition} from a typed spec.
+ *
+ *   - `on` → `eventName` (the wire key);
+ *   - `guard` defaults to `{ "==": [1, 1] }`;
+ *   - `dependencies` defaults to `[]` and is ALWAYS present;
+ *   - `effect` is passed through (build it with {@link effect}).
+ *
+ * @example
+ * ```ts
+ * transition({
+ *   from: 'debt_current', to: 'debt_current', on: 'buy',
+ *   effect: effect(
+ *     { status: 'debt_current', purchaseCount: { '+': [{ var: 'state.purchaseCount' }, 1] } },
+ *     triggers([...]), transferAsset([...]),
+ *   ),
+ * });
+ * ```
+ */
+function transition(t) {
+    return {
+        from: t.from,
+        to: t.to,
+        eventName: t.on,
+        guard: t.guard ?? { '==': [1, 1] },
+        effect: t.effect,
+        dependencies: t.dependencies ?? [],
+    };
+}
+// =============================================================================
+// effect()
+// =============================================================================
+/**
+ * Compose an effect into ONE FLAT map: the state-update fields PLUS any `_`-directive fragments,
+ * all in a single object (`Object.assign({}, stateUpdate, ...directives)`).
+ *
+ * Riverdale effects are flat maps that mix `_`-reserved directives (`_triggers`, `_transferAsset`,
+ * `_spawn`, …) with plain state-update fields — they are NOT `merge`-wrapped. Each directive fragment
+ * is a `Record` (e.g. the output of `transferAsset(...)` / `triggers(...)`), spread in here. Later
+ * fragments override earlier keys (`Object.assign` semantics).
+ *
+ * @example
+ * ```ts
+ * effect(
+ *   { status: 'debt_current', purchaseCount: { '+': [{ var: 'state.purchaseCount' }, 1] } },
+ *   { _triggers: [...] },
+ *   transferAsset([{ assetId: { var: 'event.payAssetId' }, recipient: toFiber({ var: 'event.retailerId' }) }]),
+ * );
+ * // => { status, purchaseCount, _triggers, _transferAsset }
+ * ```
+ */
+function effect(stateUpdate, ...directives) {
+    return Object.assign({}, stateUpdate, ...directives);
+}
+/** A pinned-Exact `SchemaRef` for `name@version`. Wire: `{ name, version: { Exact: { version } } }`. */
+function exactRef(name, version) {
+    return { name, version: { Exact: { version } } };
+}
+/**
+ * Build a versioned-machine skeleton that binds publish + create to ONE canonical definition.
+ *
+ * The definition is projected ONCE here (`toProtoDefinition(spec.app)`) and the SAME reference is handed
+ * to `wireDefinition()`, `publishVersion().definition`, `create().definition`, and
+ * `upgradeFrom().newDefinition` — so they cannot drift and the chain's verified binding admits the fiber
+ * (F9). REUSES `toProtoDefinition` (the single canonicalization path); never re-derives the wire shape.
+ */
+function machine(spec) {
+    // Project the canonical wire definition ONCE; every consumer reuses this exact reference.
+    const wireDef = (0, fiber_app_js_1.toProtoDefinition)(spec.app);
+    return {
+        wireDefinition() {
+            return wireDef;
+        },
+        publishVersion(o) {
+            return {
+                name: spec.name,
+                version: spec.version,
+                // REQUIRED-no-default on the wire; '' is valid empty base64 when no descriptor set is bound.
+                schemaB64: o?.schemaB64 ?? '',
+                machineShape: spec.schemaShape,
+                definition: wireDef, // SAME reference as wireDefinition()/create()
+                strict: o?.strict ?? false, // REQUIRED — never omitted
+                ...(o?.metadata ? { metadata: o.metadata } : {}), // OMIT when absent
+            };
+        },
+        create(o) {
+            return {
+                fiberId: o.fiberId,
+                definition: wireDef, // SAME reference as wireDefinition()/publishVersion()
+                initialData: o.initialData,
+                schemaRef: exactRef(spec.name, spec.version), // verified binding: name@version
+                ...(o.participants ? { participants: o.participants } : {}), // OMIT when absent
+                ...(o.parentFiberId ? { parentFiberId: o.parentFiberId } : {}), // OMIT when absent
+            };
+        },
+        upgradeFrom(o) {
+            return {
+                fiberId: o.fiberId,
+                targetRef: exactRef(spec.name, spec.version),
+                newDefinition: wireDef, // SAME reference — re-pin hashes to the same logicHash
+                targetSequenceNumber: o.targetSequenceNumber,
+                ...(o.migration !== undefined ? { migration: o.migration } : {}), // OMIT (Option) when absent
+            };
+        },
+    };
+}

package/dist/cjs/templates/migration.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Migration builders — the `UpgradeFiber.migration` JSON-Logic transform applied on a version upgrade.
+ *
+ * THE FOOT-GUN (F9): a migration's evaluation root is the BARE prior state, not `state.x`.
+ * The chain evaluates the migration expression against `sm.stateData` directly
+ * (`MeteredEvaluator.eval(expr, sm.stateData, Migration)`, FiberEngine.scala:300), so:
+ *   - `{ var: '' }`            => the WHOLE prior state object
+ *   - `{ var: 'loyaltyPoints' }` => the top-level `loyaltyPoints` field
+ * This is UNLIKE an effect, where the root is the transition context and you read `{ var: 'state.x' }`.
+ * Writing `state.loyaltyPoints` in a migration silently reads `undefined`. These helpers hide that
+ * asymmetry by pinning the bare-state root for you.
+ *
+ * `migration` is `Option` on `UpgradeFiber` — when there is no transform, OMIT the key (never send `null`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migration = exports.seedFields = void 0;
+/**
+ * Seed / overwrite top-level state fields on a version upgrade.
+ * Emits `{ merge: [{ var: '' }, fields] }` — merges `fields` onto the bare prior state, so existing
+ * fields are preserved and the named fields are added or overwritten.
+ *
+ * The `{ var: '' }` root is the BARE prior state (NOT `state.x` like an effect) — that asymmetry is
+ * exactly the F9 foot-gun this helper hides.
+ *
+ * @example seedFields({ loyaltyPoints: 0 }) // => { merge: [{ var: '' }, { loyaltyPoints: 0 }] }
+ */
+const seedFields = (fields) => ({
+    merge: [{ var: '' }, fields],
+});
+exports.seedFields = seedFields;
+/**
+ * General migration transform with the bare-state root made explicit. `build` receives `{ var: '' }`
+ * (the whole prior state) and returns the migration JSON-Logic.
+ *
+ * @example migration((s) => ({ merge: [s, { x: 1 }] })) // => { merge: [{ var: '' }, { x: 1 }] }
+ */
+const migration = (build) => build({ var: '' });
+exports.migration = migration;

package/dist/cjs/templates/state-shape.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * State-shape-with-defaults — the SDK half of Proposal 01's "declared state shape" (removes F5).
+ *
+ * A declared shape carries a `default` (and optional `type`) per field. It seeds `initialData` so every
+ * accumulator starts at a concrete value — a counter read via `{ '+': [{ var: 'state.x' }, ...] }` never
+ * resolves `null` because `x` was never written. It also yields the set of declared field names for
+ * Proposal 01's var-path checks.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seedState = seedState;
+exports.declaredFields = declaredFields;
+/**
+ * Build `initialData` by overlaying `overrides` onto each field's declared `default`.
+ * Every declared field gets a concrete value, so no field reads `null` at runtime. An override for a
+ * field replaces that field's default; overrides for undeclared fields are ignored (only declared fields
+ * are emitted). Determinism: pure function of its inputs, stable key order (declared order).
+ *
+ * @example seedState({ fields: { purchaseCount: { default: 0 }, status: { default: 'ACTIVE' } } })
+ *          // => { purchaseCount: 0, status: 'ACTIVE' }
+ */
+function seedState(shape, overrides) {
+    const seeded = {};
+    for (const [name, field] of Object.entries(shape.fields)) {
+        seeded[name] =
+            overrides !== undefined && Object.prototype.hasOwnProperty.call(overrides, name)
+                ? overrides[name]
+                : field.default;
+    }
+    return seeded;
+}
+/**
+ * The set of declared state-field names — the fields the effects may read.
+ * Feeds Proposal 01's var-path checks (a `{ var: 'state.foo' }` whose `foo` is not declared is suspect).
+ */
+function declaredFields(shape) {
+    return new Set(Object.keys(shape.fields));
+}

package/dist/cjs/types.js

@@ -8,18 +8,17 @@
  * @packageDocumentation
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidFiberId = exports.isValidAddress = void 0;
+exports.isValidAddress = isValidAddress;
+exports.isValidFiberId = isValidFiberId;
 /**
  * Validate a DAG address format.
  */
 function isValidAddress(value) {
     return /^DAG[0-9a-zA-Z]+$/.test(value);
 }
-exports.isValidAddress = isValidAddress;
 /**
  * Validate a UUID format.
  */
 function isValidFiberId(value) {
     return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
 }
-exports.isValidFiberId = isValidFiberId;

package/dist/cjs/validation.js

@@ -7,7 +7,14 @@
  * @packageDocumentation
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assert = exports.safeParse = exports.validateKeyPair = exports.validateAddress = exports.validatePublicKey = exports.validatePrivateKey = exports.validate = exports.CompleteContractRequestSchema = exports.AcceptContractRequestSchema = exports.ProposeContractRequestSchema = exports.ContractTermsSchema = exports.PlatformLinkSchema = exports.AgentIdentityRegistrationSchema = exports.TransferParamsSchema = exports.CurrencyTransactionSchema = exports.CurrencyTransactionValueSchema = exports.TransactionReferenceSchema = exports.SignedSchema = exports.SignatureProofSchema = exports.KeyPairSchema = exports.PublicKeySchema = exports.PrivateKeySchema = exports.DagAddressSchema = void 0;
+exports.CompleteContractRequestSchema = exports.AcceptContractRequestSchema = exports.ProposeContractRequestSchema = exports.ContractTermsSchema = exports.PlatformLinkSchema = exports.AgentIdentityRegistrationSchema = exports.TransferParamsSchema = exports.CurrencyTransactionSchema = exports.CurrencyTransactionValueSchema = exports.TransactionReferenceSchema = exports.SignedSchema = exports.SignatureProofSchema = exports.KeyPairSchema = exports.PublicKeySchema = exports.PrivateKeySchema = exports.DagAddressSchema = void 0;
+exports.validate = validate;
+exports.validatePrivateKey = validatePrivateKey;
+exports.validatePublicKey = validatePublicKey;
+exports.validateAddress = validateAddress;
+exports.validateKeyPair = validateKeyPair;
+exports.safeParse = safeParse;
+exports.assert = assert;
 const zod_1 = require("zod");
 const errors_js_1 = require("./errors.js");
 // ============================================================================
@@ -26,9 +33,7 @@ const hexString = (length) => {
 /**
  * Schema for a DAG address
  */
-exports.DagAddressSchema = zod_1.z
-    .string()
-    .regex(/^DAG[0-9][a-zA-Z0-9]{36}$/, 'Must be a valid DAG address');
+exports.DagAddressSchema = zod_1.z.string().regex(/^DAG[0-9][a-zA-Z0-9]{36}$/, 'Must be a valid DAG address');
 // ============================================================================
 // Core Type Schemas
 // ============================================================================
@@ -209,7 +214,6 @@ function validate(schema, data, fieldName) {
     }
     return result.data;
 }
-exports.validate = validate;
 /**
  * Validate a private key
  *
@@ -220,7 +224,6 @@ exports.validate = validate;
 function validatePrivateKey(privateKey) {
     return validate(exports.PrivateKeySchema, privateKey, 'privateKey');
 }
-exports.validatePrivateKey = validatePrivateKey;
 /**
  * Validate a public key
  *
@@ -231,7 +234,6 @@ exports.validatePrivateKey = validatePrivateKey;
 function validatePublicKey(publicKey) {
     return validate(exports.PublicKeySchema, publicKey, 'publicKey');
 }
-exports.validatePublicKey = validatePublicKey;
 /**
  * Validate a DAG address
  *
@@ -242,7 +244,6 @@ exports.validatePublicKey = validatePublicKey;
 function validateAddress(address) {
     return validate(exports.DagAddressSchema, address, 'address');
 }
-exports.validateAddress = validateAddress;
 /**
  * Validate a KeyPair
  *
@@ -253,7 +254,6 @@ exports.validateAddress = validateAddress;
 function validateKeyPair(keyPair) {
     return validate(exports.KeyPairSchema, keyPair, 'keyPair');
 }
-exports.validateKeyPair = validateKeyPair;
 /**
  * Safe validation that returns a result object instead of throwing
  *
@@ -295,7 +295,6 @@ function safeParse(schema, data) {
         }),
     };
 }
-exports.safeParse = safeParse;
 /**
  * Assert that a condition is true, throwing ValidationError if not
  *
@@ -309,4 +308,3 @@ function assert(condition, message, field) {
         throw new errors_js_1.ValidationError(message, { field });
     }
 }
-exports.assert = assert;

package/dist/cjs/verify.js

@@ -5,13 +5,18 @@
  * The package embeds `mode: "standard"|"dataUpdate"` in signed objects and
  * its verify() ignores the `isDataUpdate` parameter when `mode` is present.
  * This wrapper strips `mode` so callers' explicit `isDataUpdate` always wins.
+ *
+ * In dataUpdate mode, verification happens over the null-dropped canonical
+ * bytes (drop null object fields, preserve array nulls, then RFC 8785) —
+ * mirroring the SDK's dataUpdate signers and metakit's content-hash rule.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.verify = void 0;
+exports.verify = verify;
 const metagraph_sdk_1 = require("@constellation-network/metagraph-sdk");
+const drop_nulls_js_1 = require("./ottochain/drop-nulls.js");
 function verify(signed, isDataUpdate) {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const { mode, ...rest } = signed;
-    return (0, metagraph_sdk_1.verify)(rest, isDataUpdate);
+    const isDU = isDataUpdate ?? mode === 'dataUpdate';
+    const target = isDU ? { ...rest, value: (0, drop_nulls_js_1.dropNulls)(signed.value) } : rest;
+    return (0, metagraph_sdk_1.verify)(target, isDU);
 }
-exports.verify = verify;

package/dist/cjs/zk/commit.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.frToHex = exports.toFr = exports.R = void 0;
+exports.randomSalt = randomSalt;
+exports.poseidonCommitN = poseidonCommitN;
+exports.poseidonCommit = poseidonCommit;
+exports.openCommitment = openCommitment;
+/**
+ * Poseidon commitments over BN254 Fr, computed through the JLVM `poseidon` opcode — the SAME
+ * byte-for-byte implementation the chain and the Rust/Scala circuits use. We deliberately route
+ * through `jsonLogic.apply` rather than reimplementing Poseidon: the opcode locks the field order,
+ * the circomlib round constants, and the `0x` 32-byte big-endian Fr encoding every crypto opcode
+ * expects (hard acceptance vector: `poseidon([1,2]) == 0x115cc0f5…189a`).
+ *
+ * (The standalone `poseidonHash`/`encodeFr` functions exist inside `-jlvm` but are NOT part of its
+ * public export surface — only the VM opcodes are — so the opcode path is also the only stable one.)
+ */
+const metagraph_sdk_jlvm_1 = require("@constellation-network/metagraph-sdk-jlvm");
+const node_crypto_1 = require("node:crypto");
+/**
+ * BN254 (alt_bn128) scalar field modulus R. A public field constant (not a secret / not Poseidon
+ * itself); the `poseidon` opcode re-validates canonicity, so this only drives reduction + sampling.
+ */
+exports.R = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+/** Reduce an arbitrary bigint into a canonical BN254 Fr element `[0, R)`. */
+const toFr = (x) => ((x % exports.R) + exports.R) % exports.R;
+exports.toFr = toFr;
+/** Encode a field element as the lowercase `0x` 32-byte big-endian hex the crypto opcodes expect. */
+const frToHex = (x) => `0x${(0, exports.toFr)(x).toString(16).padStart(64, '0')}`;
+exports.frToHex = frToHex;
+const bytesToBig = (b) => b.reduce((a, x) => (a << 8n) | BigInt(x), 0n);
+/** A fresh random salt as a canonical Fr (rejection-sampled to avoid modulo bias near R). */
+function randomSalt() {
+    for (;;) {
+        const v = bytesToBig((0, node_crypto_1.randomBytes)(32));
+        if (v < exports.R)
+            return v;
+    }
+}
+/** `cm = Poseidon([...fields, salt])` via the VM's own opcode. Returns the `0x` 32-byte commitment. */
+function poseidonCommitN(fields, saltFr) {
+    const inputs = [...fields.map(exports.frToHex), (0, exports.frToHex)(saltFr)];
+    // The bundled poseidon supports width t ≤ 5 (≤ 4 inputs incl. the salt); the opcode throws past it.
+    return metagraph_sdk_jlvm_1.jsonLogic.apply({ poseidon: inputs }, {});
+}
+/** `cm = Poseidon([fieldFr, saltFr])` — the commitment for one value field (a bid, a score). */
+function poseidonCommit(fieldFr, saltFr) {
+    return poseidonCommitN([fieldFr], saltFr);
+}
+/** Commit `fields` under a fresh (or supplied) salt; returns the commitment + opening. */
+function openCommitment(fields, salt = randomSalt()) {
+    return { cm: poseidonCommitN(fields, salt), fields, salt };
+}