@ottochain/sdk 2.0.0 → 2.1.0

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

@@ -0,0 +1,550 @@
+/**
+ * Oracle identity with staking, attestations, reputation, and slashing mechanics.
+ */
+export declare const identityOracleDef: {
+    metadata: {
+        name: string;
+        app: string;
+        type: string;
+        version: string;
+        description: string;
+    };
+    createSchema: {
+        required: readonly ["owner", "stake", "domains"];
+        properties: {
+            owner: {
+                type: "address";
+                description: string;
+                immutable: true;
+            };
+            stake: {
+                type: "integer";
+                minimum: number;
+                description: string;
+            };
+            domains: {
+                type: "array";
+                items: {
+                    type: "string";
+                };
+                description: string;
+            };
+            minStake: {
+                type: "integer";
+                default: number;
+                description: string;
+            };
+        };
+    };
+    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";
+                };
+            };
+            status: {
+                type: "string";
+                enum: readonly ["UNREGISTERED", "REGISTERED", "ACTIVE", "SLASHED", "WITHDRAWN"];
+                computed: true;
+            };
+            reputation: {
+                type: "object";
+                properties: {
+                    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;
+            };
+        };
+    };
+    eventSchemas: {
+        register: {
+            description: string;
+            required: readonly ["agent", "stake", "domains"];
+            properties: {
+                agent: {
+                    type: "address";
+                };
+                stake: {
+                    type: "integer";
+                    minimum: number;
+                };
+                domains: {
+                    type: "array";
+                    items: {
+                        type: "string";
+                    };
+                };
+            };
+        };
+        activate: {
+            description: string;
+            required: readonly ["agent"];
+            properties: {
+                agent: {
+                    type: "address";
+                };
+                adminOverride: {
+                    type: "boolean";
+                    default: boolean;
+                };
+            };
+        };
+        add_stake: {
+            description: string;
+            required: readonly ["agent", "amount"];
+            properties: {
+                agent: {
+                    type: "address";
+                };
+                amount: {
+                    type: "integer";
+                    minimum: number;
+                };
+            };
+        };
+        record_resolution: {
+            description: string;
+            required: readonly ["marketId", "correct"];
+            properties: {
+                marketId: {
+                    type: "uuid";
+                };
+                correct: {
+                    type: "boolean";
+                };
+            };
+        };
+        slash: {
+            description: string;
+            required: readonly ["reason", "amount"];
+            properties: {
+                reason: {
+                    type: "string";
+                };
+                amount: {
+                    type: "integer";
+                    minimum: number;
+                };
+                marketId: {
+                    type: "uuid";
+                };
+            };
+        };
+        reactivate: {
+            description: string;
+            required: readonly ["agent"];
+            properties: {
+                agent: {
+                    type: "address";
+                };
+            };
+        };
+        withdraw: {
+            description: string;
+            required: readonly ["agent"];
+            properties: {
+                agent: {
+                    type: "address";
+                };
+            };
+        };
+    };
+    states: {
+        UNREGISTERED: {
+            id: string;
+            isFinal: false;
+        };
+        REGISTERED: {
+            id: string;
+            isFinal: false;
+        };
+        ACTIVE: {
+            id: string;
+            isFinal: false;
+        };
+        SLASHED: {
+            id: string;
+            isFinal: false;
+        };
+        WITHDRAWN: {
+            id: string;
+            isFinal: true;
+        };
+    };
+    initialState: "UNREGISTERED";
+    transitions: ({
+        from: "UNREGISTERED";
+        to: "REGISTERED";
+        eventName: "register";
+        guard: {
+            ">=": {
+                var: string;
+            }[];
+            or?: undefined;
+            and?: undefined;
+            var?: undefined;
+            "==="?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                status?: undefined;
+                address?: undefined;
+                stake?: undefined;
+                registeredAt?: undefined;
+                reputation?: undefined;
+                domains?: undefined;
+                slashingHistory?: undefined;
+            } | {
+                status: string;
+                address: {
+                    var: string;
+                };
+                stake: {
+                    var: string;
+                };
+                registeredAt: {
+                    var: string;
+                };
+                reputation: {
+                    accuracy: number;
+                    totalResolutions: number;
+                    disputesWon: number;
+                    disputesLost: number;
+                };
+                domains: {
+                    var: string;
+                };
+                slashingHistory: never[];
+                var?: undefined;
+            })[];
+        };
+    } | {
+        from: "REGISTERED";
+        to: "ACTIVE";
+        eventName: "activate";
+        guard: {
+            or: ({
+                "===": {
+                    var: string;
+                }[];
+                var?: undefined;
+            } | {
+                var: string;
+                "==="?: undefined;
+            })[];
+            ">="?: undefined;
+            and?: undefined;
+            var?: undefined;
+            "==="?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                status?: undefined;
+                activatedAt?: undefined;
+            } | {
+                status: string;
+                activatedAt: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+    } | {
+        from: "ACTIVE";
+        to: "ACTIVE";
+        eventName: "add_stake";
+        guard: {
+            and: ({
+                "===": {
+                    var: string;
+                }[];
+                ">"?: undefined;
+            } | {
+                ">": (number | {
+                    var: string;
+                })[];
+                "==="?: undefined;
+            })[];
+            ">="?: undefined;
+            or?: undefined;
+            var?: undefined;
+            "==="?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                stake?: undefined;
+                lastStakeAt?: undefined;
+            } | {
+                stake: {
+                    "+": {
+                        var: string;
+                    }[];
+                };
+                lastStakeAt: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+    } | {
+        from: "ACTIVE";
+        to: "ACTIVE";
+        eventName: "record_resolution";
+        guard: {
+            var: string;
+            ">="?: undefined;
+            or?: undefined;
+            and?: undefined;
+            "==="?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                reputation?: undefined;
+                lastResolutionAt?: undefined;
+            } | {
+                reputation: {
+                    merge: ({
+                        var: string;
+                        totalResolutions?: undefined;
+                        accuracy?: undefined;
+                    } | {
+                        totalResolutions: {
+                            "+": (number | {
+                                var: string;
+                            })[];
+                        };
+                        accuracy: {
+                            if: ({
+                                var: string;
+                                "-"?: undefined;
+                            } | {
+                                "-": (number | {
+                                    var: string;
+                                })[];
+                                var?: undefined;
+                            })[];
+                        };
+                        var?: undefined;
+                    })[];
+                };
+                lastResolutionAt: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+    } | {
+        from: "ACTIVE";
+        to: "SLASHED";
+        eventName: "slash";
+        guard: {
+            and: ({
+                var: string;
+                ">"?: undefined;
+                "<="?: undefined;
+            } | {
+                ">": (number | {
+                    var: string;
+                })[];
+                var?: undefined;
+                "<="?: undefined;
+            } | {
+                "<=": {
+                    var: string;
+                }[];
+                var?: undefined;
+                ">"?: undefined;
+            })[];
+            ">="?: undefined;
+            or?: undefined;
+            var?: undefined;
+            "==="?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                status?: undefined;
+                stake?: undefined;
+                slashingHistory?: undefined;
+                slashedAt?: undefined;
+            } | {
+                status: string;
+                stake: {
+                    "-": {
+                        var: string;
+                    }[];
+                };
+                slashingHistory: {
+                    cat: ({
+                        var: string;
+                    } | {
+                        reason: {
+                            var: string;
+                        };
+                        amount: {
+                            var: string;
+                        };
+                        marketId: {
+                            var: string;
+                        };
+                        slashedAt: {
+                            var: string;
+                        };
+                    }[])[];
+                };
+                slashedAt: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+    } | {
+        from: "SLASHED";
+        to: "ACTIVE";
+        eventName: "reactivate";
+        guard: {
+            and: ({
+                "===": {
+                    var: string;
+                }[];
+                ">="?: undefined;
+            } | {
+                ">=": {
+                    var: string;
+                }[];
+                "==="?: undefined;
+            })[];
+            ">="?: undefined;
+            or?: undefined;
+            var?: undefined;
+            "==="?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                status?: undefined;
+                reactivatedAt?: undefined;
+            } | {
+                status: string;
+                reactivatedAt: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+    } | {
+        from: "ACTIVE";
+        to: "WITHDRAWN";
+        eventName: "withdraw";
+        guard: {
+            "===": {
+                var: string;
+            }[];
+            ">="?: undefined;
+            or?: undefined;
+            and?: undefined;
+            var?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                status?: undefined;
+                withdrawnAt?: undefined;
+                finalStake?: undefined;
+            } | {
+                status: string;
+                withdrawnAt: {
+                    var: string;
+                };
+                finalStake: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+    } | {
+        from: "SLASHED";
+        to: "WITHDRAWN";
+        eventName: "withdraw";
+        guard: {
+            "===": {
+                var: string;
+            }[];
+            ">="?: undefined;
+            or?: undefined;
+            and?: undefined;
+            var?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                status?: undefined;
+                withdrawnAt?: undefined;
+                finalStake?: undefined;
+            } | {
+                status: string;
+                withdrawnAt: {
+                    var: string;
+                };
+                finalStake: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+    })[];
+};
+export type OracleState = keyof typeof identityOracleDef.states;
+export type OracleEvent = (typeof identityOracleDef.transitions)[number]["eventName"];

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

@@ -0,0 +1,151 @@
+/**
+ * Minimal identity state machine - extend for custom use cases.
+ */
+export declare const identityUniversalDef: {
+    metadata: {
+        name: string;
+        app: string;
+        type: string;
+        version: string;
+        description: string;
+    };
+    createSchema: {
+        required: readonly ["owner"];
+        properties: {
+            owner: {
+                type: "address";
+                description: string;
+                immutable: true;
+            };
+            metadata: {
+                type: "object";
+                description: string;
+                default: {};
+            };
+        };
+    };
+    stateSchema: {
+        properties: {
+            owner: {
+                type: "address";
+                immutable: true;
+            };
+            status: {
+                type: "string";
+                enum: readonly ["CREATED", "ACTIVE", "INACTIVE"];
+                computed: true;
+            };
+            metadata: {
+                type: "object";
+            };
+            activatedAt: {
+                type: "timestamp";
+                computed: true;
+            };
+            updatedAt: {
+                type: "timestamp";
+                computed: true;
+            };
+            deactivatedAt: {
+                type: "timestamp";
+                computed: true;
+            };
+        };
+    };
+    eventSchemas: {
+        activate: {
+            description: string;
+        };
+        update: {
+            description: string;
+            properties: {
+                metadata: {
+                    type: "object";
+                };
+            };
+        };
+        deactivate: {
+            description: string;
+        };
+    };
+    states: {
+        CREATED: {
+            id: string;
+            isFinal: false;
+        };
+        ACTIVE: {
+            id: string;
+            isFinal: false;
+        };
+        INACTIVE: {
+            id: string;
+            isFinal: true;
+        };
+    };
+    initialState: "CREATED";
+    transitions: ({
+        from: "CREATED";
+        to: "ACTIVE";
+        eventName: "activate";
+        guard: {
+            "==": number[];
+        };
+        effect: {
+            merge: ({
+                var: string;
+                status?: undefined;
+                activatedAt?: undefined;
+            } | {
+                status: string;
+                activatedAt: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+    } | {
+        from: "ACTIVE";
+        to: "ACTIVE";
+        eventName: "update";
+        guard: {
+            "==": number[];
+        };
+        effect: {
+            merge: ({
+                var: string;
+                updatedAt?: undefined;
+                metadata?: undefined;
+            } | {
+                updatedAt: {
+                    var: string;
+                };
+                metadata: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+    } | {
+        from: "ACTIVE";
+        to: "INACTIVE";
+        eventName: "deactivate";
+        guard: {
+            "==": number[];
+        };
+        effect: {
+            merge: ({
+                var: string;
+                status?: undefined;
+                deactivatedAt?: undefined;
+            } | {
+                status: string;
+                deactivatedAt: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+    })[];
+};
+export type UniversalIdentityState = keyof typeof identityUniversalDef.states;
+export type UniversalIdentityEvent = (typeof identityUniversalDef.transitions)[number]["eventName"];