@ottochain/sdk 2.0.0 → 2.1.0

package/dist/types/apps/contracts/state-machines/contract-escrow.d.ts

@@ -0,0 +1,511 @@
+/**
+ * Asset custody with conditional release, dispute resolution, and split payments.
+ */
+export declare const contractEscrowDef: {
+    metadata: {
+        name: string;
+        app: string;
+        type: string;
+        version: string;
+        description: string;
+        crossReferences: {
+            contractId: {
+                machine: string;
+                field: string;
+                description: string;
+            };
+            marketId: {
+                machine: string;
+                field: string;
+                description: string;
+            };
+            insuranceId: {
+                machine: string;
+                field: string;
+                description: string;
+            };
+            arbitrationPoolId: {
+                machine: string;
+                field: string;
+                description: string;
+            };
+            treasuryId: {
+                machine: string;
+                field: string;
+                description: string;
+            };
+        };
+    };
+    createSchema: {
+        required: readonly ["depositor", "beneficiary", "requiredAmount"];
+        properties: {
+            depositor: {
+                type: "address";
+                description: string;
+            };
+            beneficiary: {
+                type: "address";
+                description: string;
+            };
+            requiredAmount: {
+                type: "number";
+                minimum: number;
+                description: string;
+            };
+            releaseWindowMs: {
+                type: "integer";
+                description: string;
+                nullable: true;
+            };
+            expiresAt: {
+                type: "integer";
+                description: string;
+                nullable: true;
+            };
+            autoActivate: {
+                type: "boolean";
+                description: string;
+                nullable: true;
+            };
+        };
+    };
+    stateSchema: {
+        properties: {
+            depositor: {
+                type: "address";
+            };
+            beneficiary: {
+                type: "address";
+            };
+            requiredAmount: {
+                type: "number";
+            };
+            balance: {
+                type: "number";
+            };
+            fundedAt: {
+                type: "integer";
+                nullable: true;
+            };
+            activatedAt: {
+                type: "integer";
+                nullable: true;
+            };
+            releaseRequest: {
+                type: "object";
+                nullable: true;
+            };
+            releaseDeadline: {
+                type: "integer";
+                nullable: true;
+            };
+            releasedAt: {
+                type: "integer";
+                nullable: true;
+            };
+            releasedTo: {
+                type: "address";
+                nullable: true;
+            };
+            disputedAt: {
+                type: "integer";
+                nullable: true;
+            };
+            refundedAt: {
+                type: "integer";
+                nullable: true;
+            };
+            splits: {
+                type: "array";
+                nullable: true;
+            };
+            rulingId: {
+                type: "string";
+                nullable: true;
+            };
+            releaseWindowMs: {
+                type: "integer";
+                nullable: true;
+            };
+            expiresAt: {
+                type: "integer";
+                nullable: true;
+            };
+            autoActivate: {
+                type: "boolean";
+                nullable: true;
+            };
+        };
+    };
+    eventSchemas: {
+        deposit: {
+            properties: {
+                amount: {
+                    type: "number";
+                };
+            };
+        };
+        activate: {};
+        request_release: {
+            properties: {
+                amount: {
+                    type: "number";
+                };
+                reason: {
+                    type: "string";
+                    nullable: true;
+                };
+            };
+        };
+        approve_release: {};
+        dispute: {};
+        ruling: {
+            properties: {
+                judicialRuling: {
+                    type: "boolean";
+                };
+                splits: {
+                    type: "array";
+                };
+                rulingId: {
+                    type: "string";
+                };
+            };
+        };
+        refund: {
+            properties: {
+                mutualConsent: {
+                    type: "boolean";
+                    nullable: true;
+                };
+            };
+        };
+        cancel: {};
+    };
+    states: {
+        CREATED: {
+            id: string;
+            isFinal: false;
+            metadata: null;
+        };
+        FUNDED: {
+            id: string;
+            isFinal: false;
+            metadata: null;
+        };
+        ACTIVE: {
+            id: string;
+            isFinal: false;
+            metadata: null;
+        };
+        RELEASING: {
+            id: string;
+            isFinal: false;
+            metadata: null;
+        };
+        DISPUTED: {
+            id: string;
+            isFinal: false;
+            metadata: null;
+        };
+        RELEASED: {
+            id: string;
+            isFinal: true;
+            metadata: null;
+        };
+        REFUNDED: {
+            id: string;
+            isFinal: true;
+            metadata: null;
+        };
+        SPLIT: {
+            id: string;
+            isFinal: true;
+            metadata: null;
+        };
+    };
+    initialState: "CREATED";
+    transitions: ({
+        from: "CREATED";
+        to: "FUNDED";
+        eventName: "deposit";
+        guard: {
+            and: ({
+                "===": {
+                    var: string;
+                }[];
+                ">="?: undefined;
+            } | {
+                ">=": {
+                    var: string;
+                }[];
+                "==="?: undefined;
+            })[];
+            or?: undefined;
+            "==="?: undefined;
+            var?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                balance?: undefined;
+                fundedAt?: undefined;
+            } | {
+                balance: {
+                    var: string;
+                };
+                fundedAt: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+        spawns?: undefined;
+    } | {
+        from: "FUNDED";
+        to: "ACTIVE";
+        eventName: "activate";
+        guard: {
+            or: ({
+                "===": {
+                    var: string;
+                }[];
+                var?: undefined;
+            } | {
+                var: string;
+                "==="?: undefined;
+            })[];
+            and?: undefined;
+            "==="?: undefined;
+            var?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                activatedAt?: undefined;
+            } | {
+                activatedAt: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+        spawns?: undefined;
+    } | {
+        from: "ACTIVE";
+        to: "RELEASING";
+        eventName: "request_release";
+        guard: {
+            "===": {
+                var: string;
+            }[];
+            and?: undefined;
+            or?: undefined;
+            var?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                releaseRequest?: undefined;
+                releaseDeadline?: undefined;
+            } | {
+                releaseRequest: {
+                    requestedBy: {
+                        var: string;
+                    };
+                    amount: {
+                        var: string;
+                    };
+                    reason: {
+                        var: string;
+                    };
+                    requestedAt: {
+                        var: string;
+                    };
+                };
+                releaseDeadline: {
+                    "+": {
+                        var: string;
+                    }[];
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+        spawns?: undefined;
+    } | {
+        from: "RELEASING";
+        to: "RELEASED";
+        eventName: "approve_release";
+        guard: {
+            or: ({
+                "===": {
+                    var: string;
+                }[];
+                ">="?: undefined;
+            } | {
+                ">=": {
+                    var: string;
+                }[];
+                "==="?: undefined;
+            })[];
+            and?: undefined;
+            "==="?: undefined;
+            var?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                releasedAt?: undefined;
+                releasedTo?: undefined;
+            } | {
+                releasedAt: {
+                    var: string;
+                };
+                releasedTo: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+        spawns?: undefined;
+    } | {
+        from: "RELEASING";
+        to: "DISPUTED";
+        eventName: "dispute";
+        guard: {
+            and: ({
+                "===": {
+                    var: string;
+                }[];
+                "<"?: undefined;
+            } | {
+                "<": {
+                    var: string;
+                }[];
+                "==="?: undefined;
+            })[];
+            or?: undefined;
+            "==="?: undefined;
+            var?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                disputedAt?: undefined;
+            } | {
+                disputedAt: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+        spawns: {
+            sm: string;
+            initialData: {
+                caseType: string;
+                plaintiff: {
+                    var: string;
+                };
+                defendant: {
+                    var: string;
+                };
+                claim: {
+                    escrowId: {
+                        var: string;
+                    };
+                    amount: {
+                        var: string;
+                    };
+                };
+            };
+        };
+        dependencies: never[];
+    } | {
+        from: "DISPUTED";
+        to: "SPLIT";
+        eventName: "ruling";
+        guard: {
+            var: string;
+            and?: undefined;
+            or?: undefined;
+            "==="?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                splits?: undefined;
+                rulingId?: undefined;
+            } | {
+                splits: {
+                    var: string;
+                };
+                rulingId: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+        spawns?: undefined;
+    } | {
+        from: "ACTIVE";
+        to: "REFUNDED";
+        eventName: "refund";
+        guard: {
+            or: ({
+                var: string;
+                ">="?: undefined;
+            } | {
+                ">=": {
+                    var: string;
+                }[];
+                var?: undefined;
+            })[];
+            and?: undefined;
+            "==="?: undefined;
+            var?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                refundedAt?: undefined;
+            } | {
+                refundedAt: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+        spawns?: undefined;
+    } | {
+        from: "CREATED";
+        to: "REFUNDED";
+        eventName: "cancel";
+        guard: {
+            "===": {
+                var: string;
+            }[];
+            and?: undefined;
+            or?: undefined;
+            var?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                refundedAt?: undefined;
+            } | {
+                refundedAt: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+        spawns?: undefined;
+    })[];
+};

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

@@ -0,0 +1,147 @@
+/**
+ * Minimal contract state machine - extend for custom use cases.
+ */
+export declare const contractUniversalDef: {
+    metadata: {
+        name: string;
+        app: string;
+        type: string;
+        version: string;
+        description: string;
+    };
+    createSchema: {
+        properties: {};
+    };
+    stateSchema: {
+        properties: {
+            status: {
+                type: "string";
+            };
+            acceptedAt: {
+                type: "integer";
+                nullable: true;
+            };
+            cancelledAt: {
+                type: "integer";
+                nullable: true;
+            };
+            completedAt: {
+                type: "integer";
+                nullable: true;
+            };
+        };
+    };
+    eventSchemas: {
+        accept: {};
+        cancel: {};
+        complete: {};
+    };
+    states: {
+        PROPOSED: {
+            id: string;
+            isFinal: false;
+            metadata: null;
+        };
+        ACTIVE: {
+            id: string;
+            isFinal: false;
+            metadata: null;
+        };
+        COMPLETED: {
+            id: string;
+            isFinal: true;
+            metadata: null;
+        };
+        CANCELLED: {
+            id: string;
+            isFinal: true;
+            metadata: null;
+        };
+    };
+    initialState: "PROPOSED";
+    transitions: ({
+        from: "PROPOSED";
+        to: "ACTIVE";
+        eventName: "accept";
+        guard: {
+            "==": number[];
+        };
+        effect: {
+            merge: ({
+                var: string;
+                status?: undefined;
+                acceptedAt?: undefined;
+            } | {
+                status: string;
+                acceptedAt: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+    } | {
+        from: "PROPOSED";
+        to: "CANCELLED";
+        eventName: "cancel";
+        guard: {
+            "==": number[];
+        };
+        effect: {
+            merge: ({
+                var: string;
+                status?: undefined;
+                cancelledAt?: undefined;
+            } | {
+                status: string;
+                cancelledAt: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+    } | {
+        from: "ACTIVE";
+        to: "COMPLETED";
+        eventName: "complete";
+        guard: {
+            "==": number[];
+        };
+        effect: {
+            merge: ({
+                var: string;
+                status?: undefined;
+                completedAt?: undefined;
+            } | {
+                status: string;
+                completedAt: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+    } | {
+        from: "ACTIVE";
+        to: "CANCELLED";
+        eventName: "cancel";
+        guard: {
+            "==": number[];
+        };
+        effect: {
+            merge: ({
+                var: string;
+                status?: undefined;
+                cancelledAt?: undefined;
+            } | {
+                status: string;
+                cancelledAt: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+    })[];
+};