@ottochain/sdk 2.3.0 → 2.5.0

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

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.identityRegistryDef = void 0;
+const fiber_app_js_1 = require("../../../schema/fiber-app.js");
+const guards_js_1 = require("../../../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).
+ */
+exports.identityRegistryDef = (0, fiber_app_js_1.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: (0, guards_js_1.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: (0, guards_js_1.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: (0, guards_js_1.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: (0, guards_js_1.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/cjs/apps/identity/state-machines/identity-universal.js

@@ -7,123 +7,117 @@ const fiber_app_js_1 = require("../../../schema/fiber-app.js");
  */
 exports.identityUniversalDef = (0, fiber_app_js_1.defineFiberApp)({
     metadata: {
-        name: "IdentityUniversal",
-        app: "identity",
-        type: "universal",
-        version: "1.0.0",
-        description: "Minimal identity state machine - extend for custom use cases",
+        name: 'IdentityUniversal',
+        app: 'identity',
+        type: 'universal',
+        version: '1.0.0',
+        description: 'Minimal identity state machine - extend for custom use cases',
     },
     createSchema: {
-        required: ["owner"],
+        required: ['owner'],
         properties: {
             owner: {
-                type: "address",
-                description: "Identity owner DAG address",
+                type: 'address',
+                description: 'Identity owner DAG address',
                 immutable: true,
             },
             metadata: {
-                type: "object",
-                description: "Arbitrary metadata",
+                type: 'object',
+                description: 'Arbitrary metadata',
                 default: {},
             },
         },
     },
     stateSchema: {
         properties: {
-            owner: { type: "address", immutable: true },
+            owner: { type: 'address', immutable: true },
             status: {
-                type: "string",
-                enum: ["CREATED", "ACTIVE", "INACTIVE"],
+                type: 'string',
+                enum: ['CREATED', 'ACTIVE', 'INACTIVE'],
                 computed: true,
             },
-            metadata: { type: "object" },
-            activatedAt: { type: "timestamp", computed: true },
-            updatedAt: { type: "timestamp", computed: true },
-            deactivatedAt: { type: "timestamp", computed: true },
+            metadata: { type: 'object' },
+            activatedAt: { type: 'timestamp', computed: true },
+            updatedAt: { type: 'timestamp', computed: true },
+            deactivatedAt: { type: 'timestamp', computed: true },
         },
     },
     eventSchemas: {
         activate: {
-            description: "Activate the identity",
+            description: 'Activate the identity',
         },
         update: {
-            description: "Update identity metadata",
+            description: 'Update identity metadata',
             properties: {
-                metadata: { type: "object" },
+                metadata: { type: 'object' },
             },
         },
         deactivate: {
-            description: "Deactivate the identity",
+            description: 'Deactivate the identity',
         },
     },
     states: {
         CREATED: {
-            id: "CREATED",
+            id: 'CREATED',
             isFinal: false,
             metadata: {
-                label: "Created",
-                description: "Identity registered but not yet activated",
-                category: "initial",
+                label: 'Created',
+                description: 'Identity registered but not yet activated',
+                category: 'initial',
             },
         },
         ACTIVE: {
-            id: "ACTIVE",
+            id: 'ACTIVE',
             isFinal: false,
             metadata: {
-                label: "Active",
-                description: "Identity is active and can be updated",
-                category: "active",
+                label: 'Active',
+                description: 'Identity is active and can be updated',
+                category: 'active',
             },
         },
         INACTIVE: {
-            id: "INACTIVE",
+            id: 'INACTIVE',
             isFinal: true,
             metadata: {
-                label: "Inactive",
-                description: "Identity deactivated by its owner (terminal)",
-                category: "terminal",
+                label: 'Inactive',
+                description: 'Identity deactivated by its owner (terminal)',
+                category: 'terminal',
             },
         },
     },
-    initialState: "CREATED",
+    initialState: 'CREATED',
     transitions: [
         {
-            from: "CREATED",
-            to: "ACTIVE",
-            eventName: "activate",
-            guard: { "==": [1, 1] },
+            from: 'CREATED',
+            to: 'ACTIVE',
+            eventName: 'activate',
+            guard: { '==': [1, 1] },
             effect: {
-                merge: [
-                    { var: "state" },
-                    { status: "ACTIVE", activatedAt: { var: "$timestamp" } },
-                ],
+                merge: [{ var: 'state' }, { status: 'ACTIVE', activatedAt: { var: '$ordinal' } }],
             },
         },
         {
-            from: "ACTIVE",
-            to: "ACTIVE",
-            eventName: "update",
-            guard: { "==": [1, 1] },
+            from: 'ACTIVE',
+            to: 'ACTIVE',
+            eventName: 'update',
+            guard: { '==': [1, 1] },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        updatedAt: { var: "$timestamp" },
-                        metadata: { var: "event.metadata" },
+                        updatedAt: { var: '$ordinal' },
+                        metadata: { var: 'event.metadata' },
                     },
                 ],
             },
         },
         {
-            from: "ACTIVE",
-            to: "INACTIVE",
-            eventName: "deactivate",
-            guard: { "==": [1, 1] },
+            from: 'ACTIVE',
+            to: 'INACTIVE',
+            eventName: 'deactivate',
+            guard: { '==': [1, 1] },
             effect: {
-                merge: [
-                    { var: "state" },
-                    { status: "INACTIVE", deactivatedAt: { var: "$timestamp" } },
-                ],
+                merge: [{ var: 'state' }, { status: 'INACTIVE', deactivatedAt: { var: '$ordinal' } }],
             },
         },
     ],

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

@@ -4,10 +4,12 @@
  * Re-exports from TypeScript definition files.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.identityUniversalDef = exports.identityOracleDef = exports.identityAgentDef = void 0;
+exports.identityRegistryDef = exports.identityUniversalDef = exports.identityOracleDef = exports.identityAgentDef = void 0;
 var identity_agent_js_1 = require("./identity-agent.js");
 Object.defineProperty(exports, "identityAgentDef", { enumerable: true, get: function () { return identity_agent_js_1.identityAgentDef; } });
 var identity_oracle_js_1 = require("./identity-oracle.js");
 Object.defineProperty(exports, "identityOracleDef", { enumerable: true, get: function () { return identity_oracle_js_1.identityOracleDef; } });
 var identity_universal_js_1 = require("./identity-universal.js");
 Object.defineProperty(exports, "identityUniversalDef", { enumerable: true, get: function () { return identity_universal_js_1.identityUniversalDef; } });
+var identity_registry_js_1 = require("./identity-registry.js");
+Object.defineProperty(exports, "identityRegistryDef", { enumerable: true, get: function () { return identity_registry_js_1.identityRegistryDef; } });

package/dist/cjs/apps/index.js

@@ -43,18 +43,32 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+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.corporate = exports.governance = exports.markets = exports.contracts = exports.identity = void 0;
+exports.privacy = exports.stakedPool = exports.compute = exports.lending = exports.corporate = exports.governance = exports.markets = exports.contracts = exports.identity = void 0;
 // Re-export as namespaces for organized access
 exports.identity = __importStar(require("./identity/index.js"));
 exports.contracts = __importStar(require("./contracts/index.js"));
 exports.markets = __importStar(require("./markets/index.js"));
 exports.governance = __importStar(require("./governance/index.js"));
 exports.corporate = __importStar(require("./corporate/index.js"));
+exports.lending = __importStar(require("./lending/index.js"));
+exports.compute = __importStar(require("./compute/index.js"));
+exports.stakedPool = __importStar(require("./staked-pool/index.js"));
+exports.privacy = __importStar(require("./privacy/index.js"));