@ottochain/sdk 2.3.0 → 2.4.0

package/dist/esm/apps/identity/constants.js

@@ -5,7 +5,7 @@
  *
  * @packageDocumentation
  */
-import { IdentityState } from "../../generated/ottochain/apps/identity/v1/identity.js";
+import { State } from "../../generated/ottochain/apps/identity/v1/identity.js";
 import { AttestationType } from "../../generated/ottochain/apps/identity/v1/attestation.js";
 // ---------------------------------------------------------------------------
 // State Machine Transitions
@@ -16,25 +16,25 @@ import { AttestationType } from "../../generated/ottochain/apps/identity/v1/atte
  * Note: Some transitions are type-specific (agent vs oracle)
  */
 export const IDENTITY_TRANSITIONS = {
-    [IdentityState.IDENTITY_STATE_UNSPECIFIED]: [],
-    [IdentityState.IDENTITY_STATE_UNREGISTERED]: ["register"],
-    [IdentityState.IDENTITY_STATE_REGISTERED]: ["activate", "withdraw"],
-    [IdentityState.IDENTITY_STATE_ACTIVE]: [
+    [State.IDENTITY_STATE_UNSPECIFIED]: [],
+    [State.IDENTITY_STATE_UNREGISTERED]: ["register"],
+    [State.IDENTITY_STATE_REGISTERED]: ["activate", "withdraw"],
+    [State.IDENTITY_STATE_ACTIVE]: [
         "challenge",
         "slash",
         "deactivate",
         "withdraw",
     ],
-    [IdentityState.IDENTITY_STATE_CHALLENGED]: [
+    [State.IDENTITY_STATE_CHALLENGED]: [
         "uphold_challenge",
         "dismiss_challenge",
     ],
-    [IdentityState.IDENTITY_STATE_SUSPENDED]: ["begin_probation"],
-    [IdentityState.IDENTITY_STATE_PROBATION]: ["complete_probation"],
-    [IdentityState.IDENTITY_STATE_SLASHED]: ["reactivate", "withdraw"],
-    [IdentityState.IDENTITY_STATE_INACTIVE]: ["activate", "withdraw"],
-    [IdentityState.IDENTITY_STATE_WITHDRAWN]: [], // Terminal state
-    [IdentityState.UNRECOGNIZED]: [],
+    [State.IDENTITY_STATE_SUSPENDED]: ["begin_probation"],
+    [State.IDENTITY_STATE_PROBATION]: ["complete_probation"],
+    [State.IDENTITY_STATE_SLASHED]: ["reactivate", "withdraw"],
+    [State.IDENTITY_STATE_INACTIVE]: ["activate", "withdraw"],
+    [State.IDENTITY_STATE_WITHDRAWN]: [], // Terminal state
+    [State.UNRECOGNIZED]: [],
 };
 // Legacy alias
 export const AGENT_TRANSITIONS = IDENTITY_TRANSITIONS;
@@ -53,6 +53,45 @@ export const ATTESTATION_DELTAS = {
     [AttestationType.ATTESTATION_TYPE_BEHAVIORAL]: 3,
     [AttestationType.UNRECOGNIZED]: 0,
 };
+// ---------------------------------------------------------------------------
+// Identity Registry — role attestations
+// ---------------------------------------------------------------------------
+/**
+ * Role-attestation types issued by the identity registry (identity-registry fiber).
+ * These are the ecosystem-wide authority roles consumer apps gate on via the registry
+ * dependency + `signerHasRole` (see docs/design/app-hardening-identity-integration.md §4.2).
+ */
+export const REGISTRY_ROLES = {
+    ARBITER: "ARBITER",
+    SLASHER: "SLASHER",
+    ISSUER: "ISSUER",
+    BOARD_MEMBER: "BOARD_MEMBER",
+};
+/**
+ * Maps each role to the registry's flat per-role state-map field. A consumer app reads
+ * `machines.<registryDep>.state.<field>` (a `{ <address>: true }` map) and binds membership to a
+ * verified signer with `signerHasRole`. Kept in lock-step with the identity-registry stateSchema.
+ */
+export const REGISTRY_ROLE_MAP = {
+    ARBITER: "arbiters",
+    SLASHER: "slashers",
+    ISSUER: "issuers",
+    BOARD_MEMBER: "boardMembers",
+};
+/**
+ * Build the `machines.<registryDep>.state.<roleMap>` var path a consumer guard reads to check a role,
+ * e.g. `registryRolePath("reg-uuid", "ARBITER")` → `"machines.reg-uuid.state.arbiters"`.
+ */
+export function registryRolePath(registryDep, role) {
+    return `machines.${registryDep}.state.${REGISTRY_ROLE_MAP[role]}`;
+}
+/**
+ * Build the `machines.<registryDep>.state.reputations` var path a consumer guard reads for a
+ * reputation gate (`signerHasReputation`).
+ */
+export function registryReputationPath(registryDep) {
+    return `machines.${registryDep}.state.reputations`;
+}
 /**
  * Check if a transition is valid for the given state.
  */

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

@@ -16,13 +16,17 @@
  *
  * @packageDocumentation
  */
-// Re-export generated protobuf types (source of truth)
-export { IdentityType, IdentityState, Platform, PlatformLink, Reputation, PenaltyEvent, Identity, RegisterIdentityRequest, ActivateIdentityRequest, LinkPlatformRequest, ChallengeIdentityRequest, AddStakeRequest, WithdrawIdentityRequest, IdentityDefinition, identityTypeFromJSON, identityTypeToJSON, identityStateFromJSON, identityStateToJSON, platformFromJSON, platformToJSON, } from "../../generated/ottochain/apps/identity/v1/identity.js";
+// Re-export generated protobuf types (source of truth).
+// The nested lifecycle/kind enums dropped their app prefix in the proto; under
+// this app-scoped entrypoint they are unambiguously Type / State.
+export { Type, State, Platform, PlatformLink, Reputation, PenaltyEvent, Identity, RegisterIdentityRequest, ActivateIdentityRequest, LinkPlatformRequest, ChallengeIdentityRequest, AddStakeRequest, WithdrawIdentityRequest, IdentityDefinition, typeFromJSON, typeToJSON, stateFromJSON, stateToJSON, platformFromJSON, platformToJSON, } from "../../generated/ottochain/apps/identity/v1/identity.js";
 // Legacy aliases for backward compatibility
-export { IdentityState as AgentState } from "../../generated/ottochain/apps/identity/v1/identity.js";
+export { State as AgentState } from "../../generated/ottochain/apps/identity/v1/identity.js";
+// Deprecated app-prefixed aliases (renamed to Type / State); kept for compat.
+export { Type as IdentityType, State as IdentityState, typeFromJSON as identityTypeFromJSON, typeToJSON as identityTypeToJSON, stateFromJSON as identityStateFromJSON, stateToJSON as identityStateToJSON, } from "../../generated/ottochain/apps/identity/v1/identity.js";
 export { AttestationType, ReputationDelta, Attestation, VouchRequest, ChallengeRequest, ReputationConfig, attestationTypeFromJSON, attestationTypeToJSON, } from "../../generated/ottochain/apps/identity/v1/attestation.js";
 // Re-export constants and utilities
-export { IDENTITY_TRANSITIONS, AGENT_TRANSITIONS, ATTESTATION_DELTAS, canTransition, getReputationDelta, } from "./constants.js";
+export { IDENTITY_TRANSITIONS, AGENT_TRANSITIONS, ATTESTATION_DELTAS, REGISTRY_ROLES, REGISTRY_ROLE_MAP, registryRolePath, registryReputationPath, canTransition, getReputationDelta, } from "./constants.js";
 // ---------------------------------------------------------------------------
 // Configuration Defaults
 // ---------------------------------------------------------------------------
@@ -41,17 +45,18 @@ export const DEFAULT_REPUTATION_CONFIG = {
 // ---------------------------------------------------------------------------
 // State Machine Definitions (generated from JSON at build time)
 // ---------------------------------------------------------------------------
-import { identityUniversalDef, identityAgentDef, identityOracleDef, } from "./state-machines/index.js";
-export { identityUniversalDef, identityAgentDef, identityOracleDef };
+import { identityUniversalDef, identityAgentDef, identityOracleDef, identityRegistryDef, } from "./state-machines/index.js";
+export { identityUniversalDef, identityAgentDef, identityOracleDef, identityRegistryDef, };
 /** All identity state machine definitions */
 export const IDENTITY_DEFINITIONS = {
     universal: identityUniversalDef,
     agent: identityAgentDef,
     oracle: identityOracleDef,
+    registry: identityRegistryDef,
 };
 /**
  * Get an identity state machine definition by type.
- * @param type - 'universal' | 'agent' | 'oracle' (default: 'agent')
+ * @param type - 'universal' | 'agent' | 'oracle' | 'registry' (default: 'agent')
  */
 export function getIdentityDefinition(type = "agent") {
     return IDENTITY_DEFINITIONS[type];

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

@@ -194,7 +194,7 @@ export const identityAgentDef = defineFiberApp({
             effect: {
                 merge: [
                     { var: "state" },
-                    { status: "ACTIVE", activatedAt: { var: "$timestamp" } },
+                    { status: "ACTIVE", activatedAt: { var: "$ordinal" } },
                 ],
             },
         },
@@ -251,7 +251,7 @@ export const identityAgentDef = defineFiberApp({
             effect: {
                 merge: [
                     { var: "state" },
-                    { status: "SUSPENDED", suspendedAt: { var: "$timestamp" } },
+                    { status: "SUSPENDED", suspendedAt: { var: "$ordinal" } },
                 ],
             },
         },
@@ -263,7 +263,7 @@ export const identityAgentDef = defineFiberApp({
             effect: {
                 merge: [
                     { var: "state" },
-                    { status: "PROBATION", probationStartedAt: { var: "$timestamp" } },
+                    { status: "PROBATION", probationStartedAt: { var: "$ordinal" } },
                 ],
             },
         },

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: {
@@ -189,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,
@@ -206,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" } },
                 ],
             },
         },
@@ -225,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] },
                 ],
             },
@@ -234,7 +236,7 @@ export const identityOracleDef = defineFiberApp({
                     { var: "state" },
                     {
                         stake: { "+": [{ var: "state.stake" }, { var: "event.amount" }] },
-                        lastStakeAt: { var: "$timestamp" },
+                        lastStakeAt: { var: "$ordinal" },
                     },
                 ],
             },
@@ -265,7 +267,7 @@ export const identityOracleDef = defineFiberApp({
                                 },
                             ],
                         },
-                        lastResolutionAt: { var: "$timestamp" },
+                        lastResolutionAt: { var: "$ordinal" },
                     },
                 ],
             },
@@ -274,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" }] },
                 ],
@@ -295,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" },
                     },
                 ],
             },
@@ -311,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" } },
                 ],
             },
         },
@@ -326,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" },
                     },
                 ],
@@ -342,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

@@ -92,7 +92,7 @@ export const identityUniversalDef = defineFiberApp({
             effect: {
                 merge: [
                     { var: "state" },
-                    { status: "ACTIVE", activatedAt: { var: "$timestamp" } },
+                    { status: "ACTIVE", activatedAt: { var: "$ordinal" } },
                 ],
             },
         },
@@ -105,7 +105,7 @@ export const identityUniversalDef = defineFiberApp({
                 merge: [
                     { var: "state" },
                     {
-                        updatedAt: { var: "$timestamp" },
+                        updatedAt: { var: "$ordinal" },
                         metadata: { var: "event.metadata" },
                     },
                 ],
@@ -119,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";