@ottochain/sdk 2.0.0 → 2.2.0

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

@@ -0,0 +1,462 @@
+/**
+ * Two-party agreement with mutual completion attestation and dispute resolution.
+ */
+export declare const contractAgreementDef: {
+    metadata: {
+        name: string;
+        app: string;
+        type: string;
+        version: string;
+        description: string;
+        crossReferences: {
+            proposerIdentityId: {
+                machine: string;
+                field: string;
+                description: string;
+            };
+            counterpartyIdentityId: {
+                machine: string;
+                field: string;
+                description: string;
+            };
+            escrowId: {
+                machine: string;
+                field: string;
+                description: string;
+            };
+            arbitrationPoolId: {
+                machine: string;
+                field: string;
+                description: string;
+            };
+        };
+    };
+    createSchema: {
+        required: readonly ["proposer", "counterparty"];
+        properties: {
+            proposer: {
+                type: "address";
+                description: string;
+                immutable: true;
+            };
+            counterparty: {
+                type: "address";
+                description: string;
+                immutable: true;
+            };
+        };
+    };
+    stateSchema: {
+        properties: {
+            status: {
+                type: "string";
+            };
+            proposer: {
+                type: "address";
+            };
+            counterparty: {
+                type: "address";
+            };
+            completions: {
+                type: "array";
+            };
+            acceptedAt: {
+                type: "integer";
+                nullable: true;
+            };
+            rejectedAt: {
+                type: "integer";
+                nullable: true;
+            };
+            rejectReason: {
+                type: "string";
+                nullable: true;
+            };
+            cancelledAt: {
+                type: "integer";
+                nullable: true;
+            };
+            completedAt: {
+                type: "integer";
+                nullable: true;
+            };
+            disputedAt: {
+                type: "integer";
+                nullable: true;
+            };
+            disputeReason: {
+                type: "string";
+                nullable: true;
+            };
+            disputedBy: {
+                type: "address";
+                nullable: true;
+            };
+            resolvedAt: {
+                type: "integer";
+                nullable: true;
+            };
+            resolution: {
+                type: "string";
+                nullable: true;
+            };
+            rulingId: {
+                type: "string";
+                nullable: true;
+            };
+        };
+    };
+    eventSchemas: {
+        accept: {};
+        reject: {
+            properties: {
+                reason: {
+                    type: "string";
+                };
+            };
+        };
+        cancel: {};
+        submit_completion: {
+            properties: {
+                proof: {
+                    type: "string";
+                };
+            };
+        };
+        finalize: {};
+        dispute: {
+            properties: {
+                reason: {
+                    type: "string";
+                };
+            };
+        };
+        resolve: {
+            properties: {
+                judicialRuling: {
+                    type: "boolean";
+                    nullable: true;
+                };
+                proposerApproves: {
+                    type: "boolean";
+                    nullable: true;
+                };
+                counterpartyApproves: {
+                    type: "boolean";
+                    nullable: true;
+                };
+                resolution: {
+                    type: "string";
+                };
+                rulingId: {
+                    type: "string";
+                    nullable: true;
+                };
+            };
+        };
+    };
+    states: {
+        PROPOSED: {
+            id: string;
+            isFinal: false;
+            metadata: null;
+        };
+        ACTIVE: {
+            id: string;
+            isFinal: false;
+            metadata: null;
+        };
+        COMPLETED: {
+            id: string;
+            isFinal: true;
+            metadata: null;
+        };
+        DISPUTED: {
+            id: string;
+            isFinal: false;
+            metadata: null;
+        };
+        REJECTED: {
+            id: string;
+            isFinal: true;
+            metadata: null;
+        };
+        CANCELLED: {
+            id: string;
+            isFinal: true;
+            metadata: null;
+        };
+    };
+    initialState: "PROPOSED";
+    transitions: ({
+        from: "PROPOSED";
+        to: "ACTIVE";
+        eventName: "accept";
+        guard: {
+            "===": {
+                var: string;
+            }[];
+            and?: undefined;
+            ">="?: undefined;
+            or?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                status?: undefined;
+                acceptedAt?: undefined;
+            } | {
+                status: string;
+                acceptedAt: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+    } | {
+        from: "PROPOSED";
+        to: "REJECTED";
+        eventName: "reject";
+        guard: {
+            "===": {
+                var: string;
+            }[];
+            and?: undefined;
+            ">="?: undefined;
+            or?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                status?: undefined;
+                rejectedAt?: undefined;
+                rejectReason?: undefined;
+            } | {
+                status: string;
+                rejectedAt: {
+                    var: string;
+                };
+                rejectReason: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+    } | {
+        from: "PROPOSED";
+        to: "CANCELLED";
+        eventName: "cancel";
+        guard: {
+            "===": {
+                var: string;
+            }[];
+            and?: undefined;
+            ">="?: undefined;
+            or?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                status?: undefined;
+                cancelledAt?: undefined;
+            } | {
+                status: string;
+                cancelledAt: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+    } | {
+        from: "ACTIVE";
+        to: "ACTIVE";
+        eventName: "submit_completion";
+        guard: {
+            and: ({
+                or: {
+                    "===": {
+                        var: string;
+                    }[];
+                }[];
+                "!"?: undefined;
+            } | {
+                "!": {
+                    in: ({
+                        var: string;
+                        map?: undefined;
+                    } | {
+                        map: {
+                            var: string;
+                        }[];
+                        var?: undefined;
+                    })[];
+                }[];
+                or?: undefined;
+            })[];
+            "==="?: undefined;
+            ">="?: undefined;
+            or?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                completions?: undefined;
+            } | {
+                completions: {
+                    cat: ({
+                        var: string;
+                    } | {
+                        agent: {
+                            var: string;
+                        };
+                        proof: {
+                            var: string;
+                        };
+                        submittedAt: {
+                            var: string;
+                        };
+                    }[])[];
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+    } | {
+        from: "ACTIVE";
+        to: "COMPLETED";
+        eventName: "finalize";
+        guard: {
+            ">=": (number | {
+                size: {
+                    var: string;
+                };
+            })[];
+            "==="?: undefined;
+            and?: undefined;
+            or?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                status?: undefined;
+                completedAt?: undefined;
+            } | {
+                status: string;
+                completedAt: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+    } | {
+        from: "ACTIVE";
+        to: "DISPUTED";
+        eventName: "dispute";
+        guard: {
+            or: {
+                "===": {
+                    var: string;
+                }[];
+            }[];
+            "==="?: undefined;
+            and?: undefined;
+            ">="?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                status?: undefined;
+                disputedAt?: undefined;
+                disputeReason?: undefined;
+                disputedBy?: undefined;
+            } | {
+                status: string;
+                disputedAt: {
+                    var: string;
+                };
+                disputeReason: {
+                    var: string;
+                };
+                disputedBy: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+    } | {
+        from: "DISPUTED";
+        to: "COMPLETED";
+        eventName: "resolve";
+        guard: {
+            or: ({
+                var: string;
+                and?: undefined;
+            } | {
+                and: {
+                    "===": (boolean | {
+                        var: string;
+                    })[];
+                }[];
+                var?: undefined;
+            })[];
+            "==="?: undefined;
+            and?: undefined;
+            ">="?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                status?: undefined;
+                resolvedAt?: undefined;
+                resolution?: undefined;
+                rulingId?: undefined;
+            } | {
+                status: string;
+                resolvedAt: {
+                    var: string;
+                };
+                resolution: {
+                    var: string;
+                };
+                rulingId: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+    } | {
+        from: "ACTIVE";
+        to: "CANCELLED";
+        eventName: "cancel";
+        guard: {
+            or: {
+                "===": {
+                    var: string;
+                }[];
+            }[];
+            "==="?: undefined;
+            and?: undefined;
+            ">="?: undefined;
+        };
+        effect: {
+            merge: ({
+                var: string;
+                status?: undefined;
+                cancelledAt?: undefined;
+            } | {
+                status: string;
+                cancelledAt: {
+                    var: string;
+                };
+                var?: undefined;
+            })[];
+        };
+        dependencies: never[];
+    })[];
+};