@ottochain/sdk 2.3.0 → 2.5.0

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

@@ -2,357 +2,342 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.identityOracleDef = void 0;
 const fiber_app_js_1 = require("../../../schema/fiber-app.js");
+const guards_js_1 = require("../../../schema/guards.js");
 /**
  * Oracle identity with staking, attestations, reputation, and slashing mechanics.
  */
 exports.identityOracleDef = (0, fiber_app_js_1.defineFiberApp)({
     metadata: {
-        name: "IdentityOracle",
-        app: "identity",
-        type: "oracle",
-        version: "1.0.0",
-        description: "Oracle identity with staking, attestations, reputation, and slashing mechanics",
+        name: 'IdentityOracle',
+        app: 'identity',
+        type: 'oracle',
+        version: '1.0.0',
+        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",
+                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",
+                type: 'integer',
                 minimum: 0,
-                description: "Initial stake amount",
+                description: 'Initial stake amount',
             },
             domains: {
-                type: "array",
-                items: { type: "string" },
-                description: "Oracle specialization domains",
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Oracle specialization domains',
             },
             minStake: {
-                type: "integer",
+                type: 'integer',
                 default: 1000,
-                description: "Minimum stake required",
+                description: 'Minimum stake required',
             },
         },
     },
     stateSchema: {
         properties: {
-            owner: { type: "address", immutable: true },
-            address: { type: "address", computed: true },
-            stake: { type: "integer", computed: true },
-            minStake: { type: "integer" },
-            domains: { type: "array", items: { type: "string" } },
+            owner: { type: 'address', immutable: true },
+            slasher: { type: 'address', immutable: true },
+            address: { type: 'address', computed: true },
+            stake: { type: 'integer', computed: true },
+            minStake: { type: 'integer' },
+            domains: { type: 'array', items: { type: 'string' } },
             status: {
-                type: "string",
-                enum: [
-                    "UNREGISTERED",
-                    "REGISTERED",
-                    "ACTIVE",
-                    "SLASHED",
-                    "WITHDRAWN",
-                ],
+                type: 'string',
+                enum: ['UNREGISTERED', 'REGISTERED', 'ACTIVE', 'SLASHED', 'WITHDRAWN'],
                 computed: true,
             },
             reputation: {
-                type: "object",
+                type: 'object',
                 properties: {
-                    accuracy: { type: "integer" },
-                    totalResolutions: { type: "integer" },
-                    disputesWon: { type: "integer" },
-                    disputesLost: { type: "integer" },
+                    accuracy: { type: 'integer' },
+                    totalResolutions: { type: 'integer' },
+                    disputesWon: { type: 'integer' },
+                    disputesLost: { type: 'integer' },
                 },
                 computed: true,
             },
-            slashingHistory: { type: "array", computed: true },
-            registeredAt: { type: "timestamp", computed: true },
-            activatedAt: { type: "timestamp", computed: true },
-            slashedAt: { type: "timestamp", computed: true },
-            withdrawnAt: { type: "timestamp", computed: true },
+            slashingHistory: { type: 'array', computed: true },
+            registeredAt: { type: 'timestamp', computed: true },
+            activatedAt: { type: 'timestamp', computed: true },
+            slashedAt: { type: 'timestamp', computed: true },
+            withdrawnAt: { type: 'timestamp', computed: true },
         },
     },
     eventSchemas: {
         register: {
-            description: "Register as an oracle with initial stake",
-            required: ["agent", "stake", "domains"],
+            description: 'Register as an oracle with initial stake',
+            required: ['agent', 'stake', 'domains'],
             properties: {
-                agent: { type: "address" },
-                stake: { type: "integer", minimum: 0 },
-                domains: { type: "array", items: { type: "string" } },
+                agent: { type: 'address' },
+                stake: { type: 'integer', minimum: 0 },
+                domains: { type: 'array', items: { type: 'string' } },
             },
         },
         activate: {
-            description: "Activate a registered oracle",
-            required: ["agent"],
+            description: 'Activate a registered oracle',
+            required: ['agent'],
             properties: {
-                agent: { type: "address" },
-                adminOverride: { type: "boolean", default: false },
+                agent: { type: 'address' },
             },
         },
         add_stake: {
-            description: "Add stake to an active oracle",
-            required: ["agent", "amount"],
+            description: 'Add stake to an active oracle',
+            required: ['agent', 'amount'],
             properties: {
-                agent: { type: "address" },
-                amount: { type: "integer", minimum: 1 },
+                agent: { type: 'address' },
+                amount: { type: 'integer', minimum: 1 },
             },
         },
         record_resolution: {
-            description: "Record a market resolution outcome",
-            required: ["marketId", "correct"],
+            description: 'Record a market resolution outcome',
+            required: ['marketId', 'correct'],
             properties: {
-                marketId: { type: "uuid" },
-                correct: { type: "boolean" },
+                marketId: { type: 'uuid' },
+                correct: { type: 'boolean' },
             },
         },
         slash: {
-            description: "Slash oracle stake for misconduct",
-            required: ["reason", "amount"],
+            description: 'Slash oracle stake for misconduct',
+            required: ['reason', 'amount'],
             properties: {
-                reason: { type: "string" },
-                amount: { type: "integer", minimum: 1 },
-                marketId: { type: "uuid" },
+                reason: { type: 'string' },
+                amount: { type: 'integer', minimum: 1 },
+                marketId: { type: 'uuid' },
             },
         },
         reactivate: {
-            description: "Reactivate a slashed oracle",
-            required: ["agent"],
+            description: 'Reactivate a slashed oracle',
+            required: ['agent'],
             properties: {
-                agent: { type: "address" },
+                agent: { type: 'address' },
             },
         },
         withdraw: {
-            description: "Withdraw oracle and reclaim stake",
-            required: ["agent"],
+            description: 'Withdraw oracle and reclaim stake',
+            required: ['agent'],
             properties: {
-                agent: { type: "address" },
+                agent: { type: 'address' },
             },
         },
     },
     states: {
         UNREGISTERED: {
-            id: "UNREGISTERED",
+            id: 'UNREGISTERED',
             isFinal: false,
             metadata: {
-                label: "Unregistered",
-                description: "Oracle not yet registered; awaiting stake",
-                category: "initial",
+                label: 'Unregistered',
+                description: 'Oracle not yet registered; awaiting stake',
+                category: 'initial',
             },
         },
         REGISTERED: {
-            id: "REGISTERED",
+            id: 'REGISTERED',
             isFinal: false,
             metadata: {
-                label: "Registered",
-                description: "Oracle staked and registered but not yet active",
-                category: "pending",
+                label: 'Registered',
+                description: 'Oracle staked and registered but not yet active',
+                category: 'pending',
             },
         },
         ACTIVE: {
-            id: "ACTIVE",
+            id: 'ACTIVE',
             isFinal: false,
             metadata: {
-                label: "Active",
-                description: "Oracle is active and may submit resolutions",
-                category: "active",
+                label: 'Active',
+                description: 'Oracle is active and may submit resolutions',
+                category: 'active',
             },
         },
         SLASHED: {
-            id: "SLASHED",
+            id: 'SLASHED',
             isFinal: false,
             metadata: {
-                label: "Slashed",
-                description: "Oracle penalized for a lost dispute; stake reduced",
-                category: "pending",
+                label: 'Slashed',
+                description: 'Oracle penalized for a lost dispute; stake reduced',
+                category: 'pending',
             },
         },
         WITHDRAWN: {
-            id: "WITHDRAWN",
+            id: 'WITHDRAWN',
             isFinal: true,
             metadata: {
-                label: "Withdrawn",
-                description: "Oracle withdrawn and stake reclaimed (terminal)",
-                category: "terminal",
+                label: 'Withdrawn',
+                description: 'Oracle withdrawn and stake reclaimed (terminal)',
+                category: 'terminal',
             },
         },
     },
-    initialState: "UNREGISTERED",
+    initialState: 'UNREGISTERED',
     transitions: [
         {
-            from: "UNREGISTERED",
-            to: "REGISTERED",
-            eventName: "register",
-            guard: { ">=": [{ var: "event.stake" }, { var: "state.minStake" }] },
+            from: 'UNREGISTERED',
+            to: 'REGISTERED',
+            eventName: 'register',
+            guard: { '>=': [{ var: 'event.stake' }, { var: 'state.minStake' }] },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        status: "REGISTERED",
-                        address: { var: "event.agent" },
-                        stake: { var: "event.stake" },
-                        registeredAt: { var: "$timestamp" },
+                        status: 'REGISTERED',
+                        address: { var: 'event.agent' },
+                        stake: { var: 'event.stake' },
+                        registeredAt: { var: '$ordinal' },
                         reputation: {
                             accuracy: 100,
                             totalResolutions: 0,
                             disputesWon: 0,
                             disputesLost: 0,
                         },
-                        domains: { var: "event.domains" },
+                        domains: { var: 'event.domains' },
                         slashingHistory: [],
                     },
                 ],
             },
         },
         {
-            from: "REGISTERED",
-            to: "ACTIVE",
-            eventName: "activate",
-            guard: {
-                or: [
-                    { "===": [{ var: "event.agent" }, { var: "state.address" }] },
-                    { var: "event.adminOverride" },
-                ],
-            },
+            from: 'REGISTERED',
+            to: 'ACTIVE',
+            eventName: 'activate',
+            // 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: (0, guards_js_1.signerIsParty)('state.address'),
             effect: {
-                merge: [
-                    { var: "state" },
-                    { status: "ACTIVE", activatedAt: { var: "$timestamp" } },
-                ],
+                merge: [{ var: 'state' }, { status: 'ACTIVE', activatedAt: { var: '$ordinal' } }],
             },
         },
         {
-            from: "ACTIVE",
-            to: "ACTIVE",
-            eventName: "add_stake",
+            from: 'ACTIVE',
+            to: 'ACTIVE',
+            eventName: 'add_stake',
             guard: {
-                and: [
-                    { "===": [{ var: "event.agent" }, { var: "state.address" }] },
-                    { ">": [{ var: "event.amount" }, 0] },
-                ],
+                and: [(0, guards_js_1.signerIsParty)('state.address'), { '>': [{ var: 'event.amount' }, 0] }],
             },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        stake: { "+": [{ var: "state.stake" }, { var: "event.amount" }] },
-                        lastStakeAt: { var: "$timestamp" },
+                        stake: { '+': [{ var: 'state.stake' }, { var: 'event.amount' }] },
+                        lastStakeAt: { var: '$ordinal' },
                     },
                 ],
             },
         },
         {
-            from: "ACTIVE",
-            to: "ACTIVE",
-            eventName: "record_resolution",
-            guard: { var: "event.marketId" },
+            from: 'ACTIVE',
+            to: 'ACTIVE',
+            eventName: 'record_resolution',
+            guard: { var: 'event.marketId' },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
                         reputation: {
                             merge: [
-                                { var: "state.reputation" },
+                                { var: 'state.reputation' },
                                 {
                                     totalResolutions: {
-                                        "+": [{ var: "state.reputation.totalResolutions" }, 1],
+                                        '+': [{ var: 'state.reputation.totalResolutions' }, 1],
                                     },
                                     accuracy: {
                                         if: [
-                                            { var: "event.correct" },
-                                            { var: "state.reputation.accuracy" },
-                                            { "-": [{ var: "state.reputation.accuracy" }, 5] },
+                                            { var: 'event.correct' },
+                                            { var: 'state.reputation.accuracy' },
+                                            { '-': [{ var: 'state.reputation.accuracy' }, 5] },
                                         ],
                                     },
                                 },
                             ],
                         },
-                        lastResolutionAt: { var: "$timestamp" },
+                        lastResolutionAt: { var: '$ordinal' },
                     },
                 ],
             },
         },
         {
-            from: "ACTIVE",
-            to: "SLASHED",
-            eventName: "slash",
+            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" },
-                    { ">": [{ var: "event.amount" }, 0] },
-                    { "<=": [{ var: "event.amount" }, { var: "state.stake" }] },
+                    (0, guards_js_1.signerIsParty)('state.slasher'),
+                    { '>': [{ var: 'event.amount' }, 0] },
+                    { '<=': [{ var: 'event.amount' }, { var: 'state.stake' }] },
                 ],
             },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        status: "SLASHED",
-                        stake: { "-": [{ var: "state.stake" }, { var: "event.amount" }] },
+                        status: 'SLASHED',
+                        stake: { '-': [{ var: 'state.stake' }, { var: 'event.amount' }] },
                         slashingHistory: {
                             cat: [
-                                { var: "state.slashingHistory" },
+                                { var: 'state.slashingHistory' },
                                 [
                                     {
-                                        reason: { var: "event.reason" },
-                                        amount: { var: "event.amount" },
-                                        marketId: { var: "event.marketId" },
-                                        slashedAt: { var: "$timestamp" },
+                                        reason: { var: 'event.reason' },
+                                        amount: { var: 'event.amount' },
+                                        marketId: { var: 'event.marketId' },
+                                        slashedAt: { var: '$ordinal' },
                                     },
                                 ],
                             ],
                         },
-                        slashedAt: { var: "$timestamp" },
+                        slashedAt: { var: '$ordinal' },
                     },
                 ],
             },
         },
         {
-            from: "SLASHED",
-            to: "ACTIVE",
-            eventName: "reactivate",
+            from: 'SLASHED',
+            to: 'ACTIVE',
+            eventName: 'reactivate',
             guard: {
-                and: [
-                    { "===": [{ var: "event.agent" }, { var: "state.address" }] },
-                    { ">=": [{ var: "state.stake" }, { var: "state.minStake" }] },
-                ],
+                and: [(0, guards_js_1.signerIsParty)('state.address'), { '>=': [{ var: 'state.stake' }, { var: 'state.minStake' }] }],
             },
             effect: {
-                merge: [
-                    { var: "state" },
-                    { status: "ACTIVE", reactivatedAt: { var: "$timestamp" } },
-                ],
+                merge: [{ var: 'state' }, { status: 'ACTIVE', reactivatedAt: { var: '$ordinal' } }],
             },
         },
         {
-            from: "ACTIVE",
-            to: "WITHDRAWN",
-            eventName: "withdraw",
-            guard: { "===": [{ var: "event.agent" }, { var: "state.address" }] },
+            from: 'ACTIVE',
+            to: 'WITHDRAWN',
+            eventName: 'withdraw',
+            guard: (0, guards_js_1.signerIsParty)('state.address'),
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        status: "WITHDRAWN",
-                        withdrawnAt: { var: "$timestamp" },
-                        finalStake: { var: "state.stake" },
+                        status: 'WITHDRAWN',
+                        withdrawnAt: { var: '$ordinal' },
+                        finalStake: { var: 'state.stake' },
                     },
                 ],
             },
         },
         {
-            from: "SLASHED",
-            to: "WITHDRAWN",
-            eventName: "withdraw",
-            guard: { "===": [{ var: "event.agent" }, { var: "state.address" }] },
+            from: 'SLASHED',
+            to: 'WITHDRAWN',
+            eventName: 'withdraw',
+            guard: (0, guards_js_1.signerIsParty)('state.address'),
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        status: "WITHDRAWN",
-                        withdrawnAt: { var: "$timestamp" },
-                        finalStake: { var: "state.stake" },
+                        status: 'WITHDRAWN',
+                        withdrawnAt: { var: '$ordinal' },
+                        finalStake: { var: 'state.stake' },
                     },
                 ],
             },