@ottochain/sdk 2.3.0 → 2.4.0

package/dist/types/apps/identity/state-machines/identity-oracle.d.ts

@@ -10,13 +10,18 @@ export declare const identityOracleDef: {
         description: string;
     };
     createSchema: {
-        required: readonly ["owner", "stake", "domains"];
+        required: readonly ["owner", "stake", "domains", "slasher"];
         properties: {
             owner: {
                 type: "address";
                 description: string;
                 immutable: true;
             };
+            slasher: {
+                type: "address";
+                description: string;
+                immutable: true;
+            };
             stake: {
                 type: "integer";
                 minimum: number;
@@ -42,6 +47,10 @@ export declare const identityOracleDef: {
                 type: "address";
                 immutable: true;
             };
+            slasher: {
+                type: "address";
+                immutable: true;
+            };
             address: {
                 type: "address";
                 computed: true;
@@ -131,10 +140,6 @@ export declare const identityOracleDef: {
                 agent: {
                     type: "address";
                 };
-                adminOverride: {
-                    type: "boolean";
-                    default: boolean;
-                };
             };
         };
         add_stake: {
@@ -253,10 +258,8 @@ export declare const identityOracleDef: {
             ">=": {
                 var: string;
             }[];
-            or?: undefined;
             and?: undefined;
             var?: undefined;
-            "==="?: undefined;
         };
         effect: {
             merge: ({
@@ -296,21 +299,7 @@ export declare const identityOracleDef: {
         from: "REGISTERED";
         to: "ACTIVE";
         eventName: "activate";
-        guard: {
-            or: ({
-                "===": {
-                    var: string;
-                }[];
-                var?: undefined;
-            } | {
-                var: string;
-                "==="?: undefined;
-            })[];
-            ">="?: undefined;
-            and?: undefined;
-            var?: undefined;
-            "==="?: undefined;
-        };
+        guard: import("../../../schema/guards.js").GuardRule;
         effect: {
             merge: ({
                 var: string;
@@ -329,21 +318,9 @@ export declare const identityOracleDef: {
         to: "ACTIVE";
         eventName: "add_stake";
         guard: {
-            and: ({
-                "===": {
-                    var: string;
-                }[];
-                ">"?: undefined;
-            } | {
-                ">": (number | {
-                    var: string;
-                })[];
-                "==="?: undefined;
-            })[];
+            and: import("../../../schema/guards.js").GuardRule[];
             ">="?: undefined;
-            or?: undefined;
             var?: undefined;
-            "==="?: undefined;
         };
         effect: {
             merge: ({
@@ -369,9 +346,7 @@ export declare const identityOracleDef: {
         guard: {
             var: string;
             ">="?: undefined;
-            or?: undefined;
             and?: undefined;
-            "==="?: undefined;
         };
         effect: {
             merge: ({
@@ -415,27 +390,9 @@ export declare const identityOracleDef: {
         to: "SLASHED";
         eventName: "slash";
         guard: {
-            and: ({
-                var: string;
-                ">"?: undefined;
-                "<="?: undefined;
-            } | {
-                ">": (number | {
-                    var: string;
-                })[];
-                var?: undefined;
-                "<="?: undefined;
-            } | {
-                "<=": {
-                    var: string;
-                }[];
-                var?: undefined;
-                ">"?: undefined;
-            })[];
+            and: import("../../../schema/guards.js").GuardRule[];
             ">="?: undefined;
-            or?: undefined;
             var?: undefined;
-            "==="?: undefined;
         };
         effect: {
             merge: ({
@@ -480,21 +437,9 @@ export declare const identityOracleDef: {
         to: "ACTIVE";
         eventName: "reactivate";
         guard: {
-            and: ({
-                "===": {
-                    var: string;
-                }[];
-                ">="?: undefined;
-            } | {
-                ">=": {
-                    var: string;
-                }[];
-                "==="?: undefined;
-            })[];
+            and: import("../../../schema/guards.js").GuardRule[];
             ">="?: undefined;
-            or?: undefined;
             var?: undefined;
-            "==="?: undefined;
         };
         effect: {
             merge: ({
@@ -513,15 +458,7 @@ export declare const identityOracleDef: {
         from: "ACTIVE";
         to: "WITHDRAWN";
         eventName: "withdraw";
-        guard: {
-            "===": {
-                var: string;
-            }[];
-            ">="?: undefined;
-            or?: undefined;
-            and?: undefined;
-            var?: undefined;
-        };
+        guard: import("../../../schema/guards.js").GuardRule;
         effect: {
             merge: ({
                 var: string;
@@ -543,15 +480,7 @@ export declare const identityOracleDef: {
         from: "SLASHED";
         to: "WITHDRAWN";
         eventName: "withdraw";
-        guard: {
-            "===": {
-                var: string;
-            }[];
-            ">="?: undefined;
-            or?: undefined;
-            and?: undefined;
-            var?: undefined;
-        };
+        guard: import("../../../schema/guards.js").GuardRule;
         effect: {
             merge: ({
                 var: string;

package/dist/types/apps/identity/state-machines/identity-registry.d.ts

@@ -0,0 +1,379 @@
+/**
+ * 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 declare const identityRegistryDef: {
+    metadata: {
+        name: string;
+        app: string;
+        type: string;
+        version: string;
+        description: string;
+        crossReferences: {
+            IdentityAgent: string;
+            Governance: string;
+            Contracts: string;
+            Corporate: string;
+        };
+    };
+    createSchema: {
+        required: readonly ["authority"];
+        properties: {
+            authority: {
+                type: "address";
+                description: string;
+                immutable: true;
+            };
+        };
+    };
+    stateSchema: {
+        properties: {
+            authority: {
+                type: "address";
+                immutable: true;
+            };
+            reputations: {
+                type: "object";
+                computed: true;
+            };
+            arbiters: {
+                type: "object";
+                computed: true;
+            };
+            slashers: {
+                type: "object";
+                computed: true;
+            };
+            issuers: {
+                type: "object";
+                computed: true;
+            };
+            boardMembers: {
+                type: "object";
+                computed: true;
+            };
+        };
+    };
+    eventSchemas: {
+        set_reputation: {
+            description: string;
+            required: readonly ["subject", "score"];
+            properties: {
+                subject: {
+                    type: "address";
+                };
+                score: {
+                    type: "integer";
+                };
+            };
+        };
+        adjust_reputation: {
+            description: string;
+            required: readonly ["subject", "delta"];
+            properties: {
+                subject: {
+                    type: "address";
+                };
+                delta: {
+                    type: "integer";
+                };
+            };
+        };
+        grant_role: {
+            description: string;
+            required: readonly ["subject", "role"];
+            properties: {
+                subject: {
+                    type: "address";
+                };
+                role: {
+                    type: "string";
+                    enum: readonly ["ARBITER", "SLASHER", "ISSUER", "BOARD_MEMBER"];
+                };
+            };
+        };
+        revoke_role: {
+            description: string;
+            required: readonly ["subject", "role"];
+            properties: {
+                subject: {
+                    type: "address";
+                };
+                role: {
+                    type: "string";
+                    enum: readonly ["ARBITER", "SLASHER", "ISSUER", "BOARD_MEMBER"];
+                };
+            };
+        };
+    };
+    states: {
+        ACTIVE: {
+            id: string;
+            isFinal: false;
+            metadata: {
+                label: string;
+                description: string;
+                category: "active";
+            };
+        };
+    };
+    initialState: "ACTIVE";
+    transitions: ({
+        from: "ACTIVE";
+        to: "ACTIVE";
+        eventName: "set_reputation";
+        guard: import("../../../schema/guards.js").GuardRule;
+        effect: {
+            merge: ({
+                var: string;
+                reputations?: undefined;
+            } | {
+                reputations: {
+                    set: {
+                        var: string;
+                    }[];
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+    } | {
+        from: "ACTIVE";
+        to: "ACTIVE";
+        eventName: "adjust_reputation";
+        guard: import("../../../schema/guards.js").GuardRule;
+        effect: {
+            merge: ({
+                var: string;
+                reputations?: undefined;
+            } | {
+                reputations: {
+                    set: ({
+                        var: string;
+                        "+"?: undefined;
+                    } | {
+                        "+": ({
+                            get: {
+                                var: string;
+                            }[];
+                            var?: undefined;
+                        } | {
+                            var: string;
+                            get?: undefined;
+                        })[];
+                        var?: undefined;
+                    })[];
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+    } | {
+        from: "ACTIVE";
+        to: "ACTIVE";
+        eventName: "grant_role";
+        guard: import("../../../schema/guards.js").GuardRule;
+        effect: {
+            merge: ({
+                var: string;
+                arbiters?: undefined;
+                slashers?: undefined;
+                issuers?: undefined;
+                boardMembers?: undefined;
+            } | {
+                arbiters: {
+                    if: ({
+                        "==": (string | {
+                            var: string;
+                        })[];
+                        set?: undefined;
+                        var?: undefined;
+                    } | {
+                        set: (boolean | {
+                            var: string;
+                        })[];
+                        "=="?: undefined;
+                        var?: undefined;
+                    } | {
+                        var: string;
+                        "=="?: undefined;
+                        set?: undefined;
+                    })[];
+                };
+                slashers: {
+                    if: ({
+                        "==": (string | {
+                            var: string;
+                        })[];
+                        set?: undefined;
+                        var?: undefined;
+                    } | {
+                        set: (boolean | {
+                            var: string;
+                        })[];
+                        "=="?: undefined;
+                        var?: undefined;
+                    } | {
+                        var: string;
+                        "=="?: undefined;
+                        set?: undefined;
+                    })[];
+                };
+                issuers: {
+                    if: ({
+                        "==": (string | {
+                            var: string;
+                        })[];
+                        set?: undefined;
+                        var?: undefined;
+                    } | {
+                        set: (boolean | {
+                            var: string;
+                        })[];
+                        "=="?: undefined;
+                        var?: undefined;
+                    } | {
+                        var: string;
+                        "=="?: undefined;
+                        set?: undefined;
+                    })[];
+                };
+                boardMembers: {
+                    if: ({
+                        "==": (string | {
+                            var: string;
+                        })[];
+                        set?: undefined;
+                        var?: undefined;
+                    } | {
+                        set: (boolean | {
+                            var: string;
+                        })[];
+                        "=="?: undefined;
+                        var?: undefined;
+                    } | {
+                        var: string;
+                        "=="?: undefined;
+                        set?: undefined;
+                    })[];
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+    } | {
+        from: "ACTIVE";
+        to: "ACTIVE";
+        eventName: "revoke_role";
+        guard: import("../../../schema/guards.js").GuardRule;
+        effect: {
+            merge: ({
+                var: string;
+                arbiters?: undefined;
+                slashers?: undefined;
+                issuers?: undefined;
+                boardMembers?: undefined;
+            } | {
+                arbiters: {
+                    if: ({
+                        "==": (string | {
+                            var: string;
+                        })[];
+                        unset?: undefined;
+                        var?: undefined;
+                    } | {
+                        unset: {
+                            var: string;
+                        }[];
+                        "=="?: undefined;
+                        var?: undefined;
+                    } | {
+                        var: string;
+                        "=="?: undefined;
+                        unset?: undefined;
+                    })[];
+                };
+                slashers: {
+                    if: ({
+                        "==": (string | {
+                            var: string;
+                        })[];
+                        unset?: undefined;
+                        var?: undefined;
+                    } | {
+                        unset: {
+                            var: string;
+                        }[];
+                        "=="?: undefined;
+                        var?: undefined;
+                    } | {
+                        var: string;
+                        "=="?: undefined;
+                        unset?: undefined;
+                    })[];
+                };
+                issuers: {
+                    if: ({
+                        "==": (string | {
+                            var: string;
+                        })[];
+                        unset?: undefined;
+                        var?: undefined;
+                    } | {
+                        unset: {
+                            var: string;
+                        }[];
+                        "=="?: undefined;
+                        var?: undefined;
+                    } | {
+                        var: string;
+                        "=="?: undefined;
+                        unset?: undefined;
+                    })[];
+                };
+                boardMembers: {
+                    if: ({
+                        "==": (string | {
+                            var: string;
+                        })[];
+                        unset?: undefined;
+                        var?: undefined;
+                    } | {
+                        unset: {
+                            var: string;
+                        }[];
+                        "=="?: undefined;
+                        var?: undefined;
+                    } | {
+                        var: string;
+                        "=="?: undefined;
+                        unset?: undefined;
+                    })[];
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+    })[];
+};
+export type RegistryState = keyof typeof identityRegistryDef.states;
+export type RegistryEvent = (typeof identityRegistryDef.transitions)[number]["eventName"];

package/dist/types/apps/identity/state-machines/index.d.ts

@@ -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/types/apps/index.d.ts

@@ -31,3 +31,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";