@ottochain/sdk 2.2.5 → 2.4.0

package/dist/esm/apps/identity/state-machines/identity-oracle.js

@@ -1,4 +1,5 @@
 import { defineFiberApp } from "../../../schema/fiber-app.js";
+import { signerIsParty } from "../../../schema/guards.js";
 /**
  * Oracle identity with staking, attestations, reputation, and slashing mechanics.
  */
@@ -11,13 +12,18 @@ export const identityOracleDef = defineFiberApp({
         description: "Oracle identity with staking, attestations, reputation, and slashing mechanics",
     },
     createSchema: {
-        required: ["owner", "stake", "domains"],
+        required: ["owner", "stake", "domains", "slasher"],
         properties: {
             owner: {
                 type: "address",
                 description: "Oracle owner DAG address",
                 immutable: true,
             },
+            slasher: {
+                type: "address",
+                description: "DAG address of the slasher authorized to penalize this oracle's stake",
+                immutable: true,
+            },
             stake: {
                 type: "integer",
                 minimum: 0,
@@ -38,6 +44,7 @@ export const identityOracleDef = defineFiberApp({
     stateSchema: {
         properties: {
             owner: { type: "address", immutable: true },
+            slasher: { type: "address", immutable: true },
             address: { type: "address", computed: true },
             stake: { type: "integer", computed: true },
             minStake: { type: "integer" },
@@ -85,7 +92,6 @@ export const identityOracleDef = defineFiberApp({
             required: ["agent"],
             properties: {
                 agent: { type: "address" },
-                adminOverride: { type: "boolean", default: false },
             },
         },
         add_stake: {
@@ -129,11 +135,51 @@ export const identityOracleDef = defineFiberApp({
         },
     },
     states: {
-        UNREGISTERED: { id: "UNREGISTERED", isFinal: false },
-        REGISTERED: { id: "REGISTERED", isFinal: false },
-        ACTIVE: { id: "ACTIVE", isFinal: false },
-        SLASHED: { id: "SLASHED", isFinal: false },
-        WITHDRAWN: { id: "WITHDRAWN", isFinal: true },
+        UNREGISTERED: {
+            id: "UNREGISTERED",
+            isFinal: false,
+            metadata: {
+                label: "Unregistered",
+                description: "Oracle not yet registered; awaiting stake",
+                category: "initial",
+            },
+        },
+        REGISTERED: {
+            id: "REGISTERED",
+            isFinal: false,
+            metadata: {
+                label: "Registered",
+                description: "Oracle staked and registered but not yet active",
+                category: "pending",
+            },
+        },
+        ACTIVE: {
+            id: "ACTIVE",
+            isFinal: false,
+            metadata: {
+                label: "Active",
+                description: "Oracle is active and may submit resolutions",
+                category: "active",
+            },
+        },
+        SLASHED: {
+            id: "SLASHED",
+            isFinal: false,
+            metadata: {
+                label: "Slashed",
+                description: "Oracle penalized for a lost dispute; stake reduced",
+                category: "pending",
+            },
+        },
+        WITHDRAWN: {
+            id: "WITHDRAWN",
+            isFinal: true,
+            metadata: {
+                label: "Withdrawn",
+                description: "Oracle withdrawn and stake reclaimed (terminal)",
+                category: "terminal",
+            },
+        },
     },
     initialState: "UNREGISTERED",
     transitions: [
@@ -149,7 +195,7 @@ export const identityOracleDef = defineFiberApp({
                         status: "REGISTERED",
                         address: { var: "event.agent" },
                         stake: { var: "event.stake" },
-                        registeredAt: { var: "$timestamp" },
+                        registeredAt: { var: "$ordinal" },
                         reputation: {
                             accuracy: 100,
                             totalResolutions: 0,
@@ -166,16 +212,12 @@ export const identityOracleDef = defineFiberApp({
             from: "REGISTERED",
             to: "ACTIVE",
             eventName: "activate",
-            guard: {
-                or: [
-                    { "===": [{ var: "event.agent" }, { var: "state.address" }] },
-                    { var: "event.adminOverride" },
-                ],
-            },
+            // authority gate — an ARBITER/SLASHER attestation check layers on additively when the identity registry lands (see docs/design/app-hardening-identity-integration.md §4.2)
+            guard: signerIsParty("state.address"),
             effect: {
                 merge: [
                     { var: "state" },
-                    { status: "ACTIVE", activatedAt: { var: "$timestamp" } },
+                    { status: "ACTIVE", activatedAt: { var: "$ordinal" } },
                 ],
             },
         },
@@ -185,7 +227,7 @@ export const identityOracleDef = defineFiberApp({
             eventName: "add_stake",
             guard: {
                 and: [
-                    { "===": [{ var: "event.agent" }, { var: "state.address" }] },
+                    signerIsParty("state.address"),
                     { ">": [{ var: "event.amount" }, 0] },
                 ],
             },
@@ -194,7 +236,7 @@ export const identityOracleDef = defineFiberApp({
                     { var: "state" },
                     {
                         stake: { "+": [{ var: "state.stake" }, { var: "event.amount" }] },
-                        lastStakeAt: { var: "$timestamp" },
+                        lastStakeAt: { var: "$ordinal" },
                     },
                 ],
             },
@@ -225,7 +267,7 @@ export const identityOracleDef = defineFiberApp({
                                 },
                             ],
                         },
-                        lastResolutionAt: { var: "$timestamp" },
+                        lastResolutionAt: { var: "$ordinal" },
                     },
                 ],
             },
@@ -234,9 +276,10 @@ export const identityOracleDef = defineFiberApp({
             from: "ACTIVE",
             to: "SLASHED",
             eventName: "slash",
+            // authority gate — an ARBITER/SLASHER attestation check layers on additively when the identity registry lands (see docs/design/app-hardening-identity-integration.md §4.2)
             guard: {
                 and: [
-                    { var: "event.reason" },
+                    signerIsParty("state.slasher"),
                     { ">": [{ var: "event.amount" }, 0] },
                     { "<=": [{ var: "event.amount" }, { var: "state.stake" }] },
                 ],
@@ -255,12 +298,12 @@ export const identityOracleDef = defineFiberApp({
                                         reason: { var: "event.reason" },
                                         amount: { var: "event.amount" },
                                         marketId: { var: "event.marketId" },
-                                        slashedAt: { var: "$timestamp" },
+                                        slashedAt: { var: "$ordinal" },
                                     },
                                 ],
                             ],
                         },
-                        slashedAt: { var: "$timestamp" },
+                        slashedAt: { var: "$ordinal" },
                     },
                 ],
             },
@@ -271,14 +314,14 @@ export const identityOracleDef = defineFiberApp({
             eventName: "reactivate",
             guard: {
                 and: [
-                    { "===": [{ var: "event.agent" }, { var: "state.address" }] },
+                    signerIsParty("state.address"),
                     { ">=": [{ var: "state.stake" }, { var: "state.minStake" }] },
                 ],
             },
             effect: {
                 merge: [
                     { var: "state" },
-                    { status: "ACTIVE", reactivatedAt: { var: "$timestamp" } },
+                    { status: "ACTIVE", reactivatedAt: { var: "$ordinal" } },
                 ],
             },
         },
@@ -286,13 +329,13 @@ export const identityOracleDef = defineFiberApp({
             from: "ACTIVE",
             to: "WITHDRAWN",
             eventName: "withdraw",
-            guard: { "===": [{ var: "event.agent" }, { var: "state.address" }] },
+            guard: signerIsParty("state.address"),
             effect: {
                 merge: [
                     { var: "state" },
                     {
                         status: "WITHDRAWN",
-                        withdrawnAt: { var: "$timestamp" },
+                        withdrawnAt: { var: "$ordinal" },
                         finalStake: { var: "state.stake" },
                     },
                 ],
@@ -302,13 +345,13 @@ export const identityOracleDef = defineFiberApp({
             from: "SLASHED",
             to: "WITHDRAWN",
             eventName: "withdraw",
-            guard: { "===": [{ var: "event.agent" }, { var: "state.address" }] },
+            guard: signerIsParty("state.address"),
             effect: {
                 merge: [
                     { var: "state" },
                     {
                         status: "WITHDRAWN",
-                        withdrawnAt: { var: "$timestamp" },
+                        withdrawnAt: { var: "$ordinal" },
                         finalStake: { var: "state.stake" },
                     },
                 ],

package/dist/esm/apps/identity/state-machines/identity-registry.js

@@ -0,0 +1,285 @@
+import { defineFiberApp } from "../../../schema/fiber-app.js";
+import { signerIsParty } from "../../../schema/guards.js";
+/**
+ * Identity Registry — the ecosystem authority & reputation source.
+ *
+ * Aggregates, under a single authority-governed fiber:
+ *  - `reputations: { <address>: int }`  — the public reputation read by reputation-gated apps
+ *    (dao-reputation, credit-scoring) via a declared dependency + the `signerHasReputation` helper.
+ *  - role attestations (ARBITER / SLASHER / ISSUER / BOARD_MEMBER) as FLAT per-role maps
+ *    `{ <address>: true }`, read via the `signerHasRole` helper for judicial / issuance / governance
+ *    authority gates.
+ *
+ * Writes are gated to the registry's pinned `authority` (immutable, set at create) and bound to the
+ * CHAIN-VERIFIED signer via `signerIsParty("state.authority")` — never `event.agent`. Reads happen
+ * cross-fiber: a consumer app declares this registry as a dependency and reads
+ * `machines.<registryDep>.state.reputations` / `.arbiters` / … bound to `proofs[].address`.
+ *
+ * Roles are flat per-role maps rather than a nested `roles[addr][ROLE]` map on purpose: metakit
+ * `get`/`has` on a NULL inner map throw (they are not null-total), so a nested read would error for
+ * any signer with no roles entry — the common case. Flat maps keep both the write (`set`/`unset`) and
+ * the read (`has`) total and fail-closed. New role types are added as new state maps + a cascade arm.
+ *
+ * See docs/design/app-hardening-identity-integration.md §3–§4 and src/schema/guards.ts
+ * (signerHasReputation / signerHasRole).
+ */
+export const identityRegistryDef = defineFiberApp({
+    metadata: {
+        name: "IdentityRegistry",
+        app: "identity",
+        type: "registry",
+        version: "1.0.0",
+        description: "Ecosystem reputation + role-attestation registry; authority-gated writes, dependency reads.",
+        crossReferences: {
+            IdentityAgent: "per-agent reputation source",
+            Governance: "reputation-gated participation",
+            Contracts: "ARBITER-gated dispute settlement",
+            Corporate: "ISSUER / BOARD_MEMBER authority",
+        },
+    },
+    createSchema: {
+        required: ["authority"],
+        properties: {
+            authority: {
+                type: "address",
+                description: "DAG address authorized to write reputation + role attestations (immutable)",
+                immutable: true,
+            },
+        },
+    },
+    stateSchema: {
+        properties: {
+            authority: { type: "address", immutable: true },
+            // { <address>: int } — public reputation, read via signerHasReputation
+            reputations: { type: "object", computed: true },
+            // FLAT per-role attestation maps { <address>: true }, read via signerHasRole
+            arbiters: { type: "object", computed: true },
+            slashers: { type: "object", computed: true },
+            issuers: { type: "object", computed: true },
+            boardMembers: { type: "object", computed: true },
+        },
+    },
+    eventSchemas: {
+        set_reputation: {
+            description: "Authority sets an address's reputation to an absolute score",
+            required: ["subject", "score"],
+            properties: {
+                subject: { type: "address" },
+                score: { type: "integer" },
+            },
+        },
+        adjust_reputation: {
+            description: "Authority adjusts an address's reputation by a signed delta",
+            required: ["subject", "delta"],
+            properties: {
+                subject: { type: "address" },
+                delta: { type: "integer" },
+            },
+        },
+        grant_role: {
+            description: "Authority grants a role attestation (ARBITER|SLASHER|ISSUER|BOARD_MEMBER) to an address",
+            required: ["subject", "role"],
+            properties: {
+                subject: { type: "address" },
+                role: {
+                    type: "string",
+                    enum: ["ARBITER", "SLASHER", "ISSUER", "BOARD_MEMBER"],
+                },
+            },
+        },
+        revoke_role: {
+            description: "Authority revokes a role attestation from an address",
+            required: ["subject", "role"],
+            properties: {
+                subject: { type: "address" },
+                role: {
+                    type: "string",
+                    enum: ["ARBITER", "SLASHER", "ISSUER", "BOARD_MEMBER"],
+                },
+            },
+        },
+    },
+    states: {
+        ACTIVE: {
+            id: "ACTIVE",
+            isFinal: false,
+            metadata: {
+                label: "Active",
+                description: "Registry accepting authority writes",
+                category: "active",
+            },
+        },
+    },
+    initialState: "ACTIVE",
+    transitions: [
+        // ACTIVE → ACTIVE: set_reputation (absolute)
+        {
+            from: "ACTIVE",
+            to: "ACTIVE",
+            eventName: "set_reputation",
+            guard: signerIsParty("state.authority"),
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        reputations: {
+                            set: [
+                                { var: "state.reputations" },
+                                { var: "event.subject" },
+                                { var: "event.score" },
+                            ],
+                        },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        // ACTIVE → ACTIVE: adjust_reputation (signed delta; absent subject starts from 0)
+        {
+            from: "ACTIVE",
+            to: "ACTIVE",
+            eventName: "adjust_reputation",
+            guard: signerIsParty("state.authority"),
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        reputations: {
+                            set: [
+                                { var: "state.reputations" },
+                                { var: "event.subject" },
+                                {
+                                    "+": [
+                                        {
+                                            get: [
+                                                { var: "state.reputations" },
+                                                { var: "event.subject" },
+                                            ],
+                                        },
+                                        { var: "event.delta" },
+                                    ],
+                                },
+                            ],
+                        },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        // ACTIVE → ACTIVE: grant_role (cascade selects the flat per-role map)
+        {
+            from: "ACTIVE",
+            to: "ACTIVE",
+            eventName: "grant_role",
+            guard: signerIsParty("state.authority"),
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        arbiters: {
+                            if: [
+                                { "==": [{ var: "event.role" }, "ARBITER"] },
+                                {
+                                    set: [
+                                        { var: "state.arbiters" },
+                                        { var: "event.subject" },
+                                        true,
+                                    ],
+                                },
+                                { var: "state.arbiters" },
+                            ],
+                        },
+                        slashers: {
+                            if: [
+                                { "==": [{ var: "event.role" }, "SLASHER"] },
+                                {
+                                    set: [
+                                        { var: "state.slashers" },
+                                        { var: "event.subject" },
+                                        true,
+                                    ],
+                                },
+                                { var: "state.slashers" },
+                            ],
+                        },
+                        issuers: {
+                            if: [
+                                { "==": [{ var: "event.role" }, "ISSUER"] },
+                                {
+                                    set: [
+                                        { var: "state.issuers" },
+                                        { var: "event.subject" },
+                                        true,
+                                    ],
+                                },
+                                { var: "state.issuers" },
+                            ],
+                        },
+                        boardMembers: {
+                            if: [
+                                { "==": [{ var: "event.role" }, "BOARD_MEMBER"] },
+                                {
+                                    set: [
+                                        { var: "state.boardMembers" },
+                                        { var: "event.subject" },
+                                        true,
+                                    ],
+                                },
+                                { var: "state.boardMembers" },
+                            ],
+                        },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        // ACTIVE → ACTIVE: revoke_role (cascade unsets from the flat per-role map)
+        {
+            from: "ACTIVE",
+            to: "ACTIVE",
+            eventName: "revoke_role",
+            guard: signerIsParty("state.authority"),
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        arbiters: {
+                            if: [
+                                { "==": [{ var: "event.role" }, "ARBITER"] },
+                                { unset: [{ var: "state.arbiters" }, { var: "event.subject" }] },
+                                { var: "state.arbiters" },
+                            ],
+                        },
+                        slashers: {
+                            if: [
+                                { "==": [{ var: "event.role" }, "SLASHER"] },
+                                { unset: [{ var: "state.slashers" }, { var: "event.subject" }] },
+                                { var: "state.slashers" },
+                            ],
+                        },
+                        issuers: {
+                            if: [
+                                { "==": [{ var: "event.role" }, "ISSUER"] },
+                                { unset: [{ var: "state.issuers" }, { var: "event.subject" }] },
+                                { var: "state.issuers" },
+                            ],
+                        },
+                        boardMembers: {
+                            if: [
+                                { "==": [{ var: "event.role" }, "BOARD_MEMBER"] },
+                                {
+                                    unset: [
+                                        { var: "state.boardMembers" },
+                                        { var: "event.subject" },
+                                    ],
+                                },
+                                { var: "state.boardMembers" },
+                            ],
+                        },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+    ],
+});

package/dist/esm/apps/identity/state-machines/identity-universal.js

@@ -54,9 +54,33 @@ export const identityUniversalDef = defineFiberApp({
         },
     },
     states: {
-        CREATED: { id: "CREATED", isFinal: false },
-        ACTIVE: { id: "ACTIVE", isFinal: false },
-        INACTIVE: { id: "INACTIVE", isFinal: true },
+        CREATED: {
+            id: "CREATED",
+            isFinal: false,
+            metadata: {
+                label: "Created",
+                description: "Identity registered but not yet activated",
+                category: "initial",
+            },
+        },
+        ACTIVE: {
+            id: "ACTIVE",
+            isFinal: false,
+            metadata: {
+                label: "Active",
+                description: "Identity is active and can be updated",
+                category: "active",
+            },
+        },
+        INACTIVE: {
+            id: "INACTIVE",
+            isFinal: true,
+            metadata: {
+                label: "Inactive",
+                description: "Identity deactivated by its owner (terminal)",
+                category: "terminal",
+            },
+        },
     },
     initialState: "CREATED",
     transitions: [
@@ -68,7 +92,7 @@ export const identityUniversalDef = defineFiberApp({
             effect: {
                 merge: [
                     { var: "state" },
-                    { status: "ACTIVE", activatedAt: { var: "$timestamp" } },
+                    { status: "ACTIVE", activatedAt: { var: "$ordinal" } },
                 ],
             },
         },
@@ -81,7 +105,7 @@ export const identityUniversalDef = defineFiberApp({
                 merge: [
                     { var: "state" },
                     {
-                        updatedAt: { var: "$timestamp" },
+                        updatedAt: { var: "$ordinal" },
                         metadata: { var: "event.metadata" },
                     },
                 ],
@@ -95,7 +119,7 @@ export const identityUniversalDef = defineFiberApp({
             effect: {
                 merge: [
                     { var: "state" },
-                    { status: "INACTIVE", deactivatedAt: { var: "$timestamp" } },
+                    { status: "INACTIVE", deactivatedAt: { var: "$ordinal" } },
                 ],
             },
         },

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

@@ -5,3 +5,4 @@
 export { identityAgentDef } from './identity-agent.js';
 export { identityOracleDef } from './identity-oracle.js';
 export { identityUniversalDef } from './identity-universal.js';
+export { identityRegistryDef } from './identity-registry.js';

package/dist/esm/apps/index.js

@@ -32,3 +32,4 @@ export * as contracts from "./contracts/index.js";
 export * as markets from "./markets/index.js";
 export * as governance from "./governance/index.js";
 export * as corporate from "./corporate/index.js";
+export * as lending from "./lending/index.js";