@ottochain/sdk 2.0.0 → 2.2.0

package/dist/cjs/apps/contracts/index.js

@@ -50,7 +50,7 @@ exports.CONTRACTS_DEFINITIONS = {
  * Get a contract state machine definition by type.
  * @param type - 'universal' | 'agreement' | 'escrow' (default: 'agreement')
  */
-function getContractDefinition(type = 'agreement') {
+function getContractDefinition(type = "agreement") {
     return exports.CONTRACTS_DEFINITIONS[type];
 }
 exports.getContractDefinition = getContractDefinition;

package/dist/cjs/apps/contracts/state-machines/contract-agreement.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contractAgreementDef = void 0;
+const fiber_app_js_1 = require("../../../schema/fiber-app.js");
+/**
+ * Two-party agreement with mutual completion attestation and dispute resolution.
+ */
+exports.contractAgreementDef = (0, fiber_app_js_1.defineFiberApp)({
+    metadata: {
+        name: "ContractAgreement",
+        app: "contracts",
+        type: "agreement",
+        version: "1.0.0",
+        description: "Two-party agreement with mutual completion attestation and dispute resolution",
+        crossReferences: {
+            proposerIdentityId: {
+                machine: "identity-agent",
+                field: "proposer",
+                description: "Links to proposer's AgentIdentity fiber",
+            },
+            counterpartyIdentityId: {
+                machine: "identity-agent",
+                field: "counterparty",
+                description: "Links to counterparty's AgentIdentity fiber",
+            },
+            escrowId: {
+                machine: "contract-escrow",
+                field: "escrowId",
+                description: "Links to Escrow if payment is escrowed",
+            },
+            arbitrationPoolId: {
+                machine: "arbitration-pool",
+                field: "arbitrationPoolId",
+                description: "Links to ArbitrationPool for dispute resolution",
+            },
+        },
+    },
+    createSchema: {
+        required: ["proposer", "counterparty"],
+        properties: {
+            proposer: {
+                type: "address",
+                description: "DAG address of the proposer",
+                immutable: true,
+            },
+            counterparty: {
+                type: "address",
+                description: "DAG address of the counterparty",
+                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: "PROPOSED", isFinal: false, metadata: null },
+        ACTIVE: { id: "ACTIVE", isFinal: false, metadata: null },
+        COMPLETED: { id: "COMPLETED", isFinal: true, metadata: null },
+        DISPUTED: { id: "DISPUTED", isFinal: false, metadata: null },
+        REJECTED: { id: "REJECTED", isFinal: true, metadata: null },
+        CANCELLED: { id: "CANCELLED", isFinal: true, metadata: null },
+    },
+    initialState: "PROPOSED",
+    transitions: [
+        {
+            from: "PROPOSED",
+            to: "ACTIVE",
+            eventName: "accept",
+            guard: { "===": [{ var: "event.agent" }, { var: "state.counterparty" }] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    { status: "ACTIVE", acceptedAt: { var: "$timestamp" } },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "PROPOSED",
+            to: "REJECTED",
+            eventName: "reject",
+            guard: { "===": [{ var: "event.agent" }, { var: "state.counterparty" }] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        status: "REJECTED",
+                        rejectedAt: { var: "$timestamp" },
+                        rejectReason: { var: "event.reason" },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "PROPOSED",
+            to: "CANCELLED",
+            eventName: "cancel",
+            guard: { "===": [{ var: "event.agent" }, { var: "state.proposer" }] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    { status: "CANCELLED", cancelledAt: { var: "$timestamp" } },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "ACTIVE",
+            to: "ACTIVE",
+            eventName: "submit_completion",
+            guard: {
+                and: [
+                    {
+                        or: [
+                            { "===": [{ var: "event.agent" }, { var: "state.proposer" }] },
+                            {
+                                "===": [{ var: "event.agent" }, { var: "state.counterparty" }],
+                            },
+                        ],
+                    },
+                    {
+                        "!": [
+                            {
+                                in: [
+                                    { var: "event.agent" },
+                                    { map: [{ var: "state.completions" }, { var: "agent" }] },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        completions: {
+                            cat: [
+                                { var: "state.completions" },
+                                [
+                                    {
+                                        agent: { var: "event.agent" },
+                                        proof: { var: "event.proof" },
+                                        submittedAt: { var: "$timestamp" },
+                                    },
+                                ],
+                            ],
+                        },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "ACTIVE",
+            to: "COMPLETED",
+            eventName: "finalize",
+            guard: { ">=": [{ size: { var: "state.completions" } }, 2] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    { status: "COMPLETED", completedAt: { var: "$timestamp" } },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "ACTIVE",
+            to: "DISPUTED",
+            eventName: "dispute",
+            guard: {
+                or: [
+                    { "===": [{ var: "event.agent" }, { var: "state.proposer" }] },
+                    { "===": [{ var: "event.agent" }, { var: "state.counterparty" }] },
+                ],
+            },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        status: "DISPUTED",
+                        disputedAt: { var: "$timestamp" },
+                        disputeReason: { var: "event.reason" },
+                        disputedBy: { var: "event.agent" },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "DISPUTED",
+            to: "COMPLETED",
+            eventName: "resolve",
+            guard: {
+                or: [
+                    { var: "event.judicialRuling" },
+                    {
+                        and: [
+                            { "===": [{ var: "event.proposerApproves" }, true] },
+                            { "===": [{ var: "event.counterpartyApproves" }, true] },
+                        ],
+                    },
+                ],
+            },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        status: "COMPLETED",
+                        resolvedAt: { var: "$timestamp" },
+                        resolution: { var: "event.resolution" },
+                        rulingId: { var: "event.rulingId" },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "ACTIVE",
+            to: "CANCELLED",
+            eventName: "cancel",
+            guard: {
+                or: [
+                    { "===": [{ var: "event.agent" }, { var: "state.proposer" }] },
+                    { "===": [{ var: "event.agent" }, { var: "state.counterparty" }] },
+                ],
+            },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    { status: "CANCELLED", cancelledAt: { var: "$timestamp" } },
+                ],
+            },
+            dependencies: [],
+        },
+    ],
+});

package/dist/cjs/apps/contracts/state-machines/contract-escrow.js

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contractEscrowDef = void 0;
+const fiber_app_js_1 = require("../../../schema/fiber-app.js");
+/**
+ * Asset custody with conditional release, dispute resolution, and split payments.
+ */
+exports.contractEscrowDef = (0, fiber_app_js_1.defineFiberApp)({
+    metadata: {
+        name: "ContractEscrow",
+        app: "contracts",
+        type: "escrow",
+        version: "1.0.0",
+        description: "Asset custody with conditional release, dispute resolution, and split payments",
+        crossReferences: {
+            contractId: {
+                machine: "contract-agreement",
+                field: "contractId",
+                description: "Links to Contract SM that created this escrow",
+            },
+            marketId: {
+                machine: "market-universal",
+                field: "marketId",
+                description: "Links to Market SM for market-based escrow",
+            },
+            insuranceId: {
+                machine: "insurance",
+                field: "insuranceId",
+                description: "Links to Insurance SM for protected escrow",
+            },
+            arbitrationPoolId: {
+                machine: "arbitration-pool",
+                field: "arbitrationPoolId",
+                description: "Links to ArbitrationPool for dispute resolution",
+            },
+            treasuryId: {
+                machine: "treasury",
+                field: "treasuryId",
+                description: "Links to Treasury for fee collection",
+            },
+        },
+    },
+    createSchema: {
+        required: ["depositor", "beneficiary", "requiredAmount"],
+        properties: {
+            depositor: {
+                type: "address",
+                description: "DAG address of the depositor",
+            },
+            beneficiary: {
+                type: "address",
+                description: "DAG address of the beneficiary",
+            },
+            requiredAmount: {
+                type: "number",
+                minimum: 0,
+                description: "Required escrow amount",
+            },
+            releaseWindowMs: {
+                type: "integer",
+                description: "Time window for dispute before auto-release",
+                nullable: true,
+            },
+            expiresAt: {
+                type: "integer",
+                description: "Timestamp when escrow expires",
+                nullable: true,
+            },
+            autoActivate: {
+                type: "boolean",
+                description: "Whether to auto-activate on funding",
+                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: "CREATED", isFinal: false, metadata: null },
+        FUNDED: { id: "FUNDED", isFinal: false, metadata: null },
+        ACTIVE: { id: "ACTIVE", isFinal: false, metadata: null },
+        RELEASING: { id: "RELEASING", isFinal: false, metadata: null },
+        DISPUTED: { id: "DISPUTED", isFinal: false, metadata: null },
+        RELEASED: { id: "RELEASED", isFinal: true, metadata: null },
+        REFUNDED: { id: "REFUNDED", isFinal: true, metadata: null },
+        SPLIT: { id: "SPLIT", isFinal: true, metadata: null },
+    },
+    initialState: "CREATED",
+    transitions: [
+        {
+            from: "CREATED",
+            to: "FUNDED",
+            eventName: "deposit",
+            guard: {
+                and: [
+                    { "===": [{ var: "event.agent" }, { var: "state.depositor" }] },
+                    { ">=": [{ var: "event.amount" }, { var: "state.requiredAmount" }] },
+                ],
+            },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    { balance: { var: "event.amount" }, fundedAt: { var: "$timestamp" } },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "FUNDED",
+            to: "ACTIVE",
+            eventName: "activate",
+            guard: {
+                or: [
+                    { "===": [{ var: "event.agent" }, { var: "state.beneficiary" }] },
+                    { var: "state.autoActivate" },
+                ],
+            },
+            effect: {
+                merge: [{ var: "state" }, { activatedAt: { var: "$timestamp" } }],
+            },
+            dependencies: [],
+        },
+        {
+            from: "ACTIVE",
+            to: "RELEASING",
+            eventName: "request_release",
+            guard: { "===": [{ var: "event.agent" }, { var: "state.beneficiary" }] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        releaseRequest: {
+                            requestedBy: { var: "event.agent" },
+                            amount: { var: "event.amount" },
+                            reason: { var: "event.reason" },
+                            requestedAt: { var: "$timestamp" },
+                        },
+                        releaseDeadline: {
+                            "+": [{ var: "$timestamp" }, { var: "state.releaseWindowMs" }],
+                        },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "RELEASING",
+            to: "RELEASED",
+            eventName: "approve_release",
+            guard: {
+                or: [
+                    { "===": [{ var: "event.agent" }, { var: "state.depositor" }] },
+                    { ">=": [{ var: "$timestamp" }, { var: "state.releaseDeadline" }] },
+                ],
+            },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        releasedAt: { var: "$timestamp" },
+                        releasedTo: { var: "state.beneficiary" },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "RELEASING",
+            to: "DISPUTED",
+            eventName: "dispute",
+            guard: {
+                and: [
+                    { "===": [{ var: "event.agent" }, { var: "state.depositor" }] },
+                    { "<": [{ var: "$timestamp" }, { var: "state.releaseDeadline" }] },
+                ],
+            },
+            effect: {
+                merge: [{ var: "state" }, { disputedAt: { var: "$timestamp" } }],
+            },
+            spawns: {
+                sm: "Judiciary",
+                initialData: {
+                    caseType: "escrow_dispute",
+                    plaintiff: { var: "state.depositor" },
+                    defendant: { var: "state.beneficiary" },
+                    claim: {
+                        escrowId: { var: "fiberId" },
+                        amount: { var: "state.balance" },
+                    },
+                },
+            },
+            dependencies: [],
+        },
+        {
+            from: "DISPUTED",
+            to: "SPLIT",
+            eventName: "ruling",
+            guard: { var: "event.judicialRuling" },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        splits: { var: "event.splits" },
+                        rulingId: { var: "event.rulingId" },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "ACTIVE",
+            to: "REFUNDED",
+            eventName: "refund",
+            guard: {
+                or: [
+                    { var: "event.mutualConsent" },
+                    { ">=": [{ var: "$timestamp" }, { var: "state.expiresAt" }] },
+                ],
+            },
+            effect: {
+                merge: [{ var: "state" }, { refundedAt: { var: "$timestamp" } }],
+            },
+            dependencies: [],
+        },
+        {
+            from: "CREATED",
+            to: "REFUNDED",
+            eventName: "cancel",
+            guard: { "===": [{ var: "event.agent" }, { var: "state.depositor" }] },
+            effect: {
+                merge: [{ var: "state" }, { refundedAt: { var: "$timestamp" } }],
+            },
+            dependencies: [],
+        },
+    ],
+});

package/dist/cjs/apps/contracts/state-machines/contract-universal.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contractUniversalDef = void 0;
+const fiber_app_js_1 = require("../../../schema/fiber-app.js");
+/**
+ * Minimal contract state machine - extend for custom use cases.
+ */
+exports.contractUniversalDef = (0, fiber_app_js_1.defineFiberApp)({
+    metadata: {
+        name: "ContractUniversal",
+        app: "contracts",
+        type: "universal",
+        version: "1.0.0",
+        description: "Minimal contract state machine - extend for custom use cases",
+    },
+    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: "PROPOSED", isFinal: false, metadata: null },
+        ACTIVE: { id: "ACTIVE", isFinal: false, metadata: null },
+        COMPLETED: { id: "COMPLETED", isFinal: true, metadata: null },
+        CANCELLED: { id: "CANCELLED", isFinal: true, metadata: null },
+    },
+    initialState: "PROPOSED",
+    transitions: [
+        {
+            from: "PROPOSED",
+            to: "ACTIVE",
+            eventName: "accept",
+            guard: { "==": [1, 1] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    { status: "ACTIVE", acceptedAt: { var: "$timestamp" } },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "PROPOSED",
+            to: "CANCELLED",
+            eventName: "cancel",
+            guard: { "==": [1, 1] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    { status: "CANCELLED", cancelledAt: { var: "$timestamp" } },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "ACTIVE",
+            to: "COMPLETED",
+            eventName: "complete",
+            guard: { "==": [1, 1] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    { status: "COMPLETED", completedAt: { var: "$timestamp" } },
+                ],
+            },
+            dependencies: [],
+        },
+        {
+            from: "ACTIVE",
+            to: "CANCELLED",
+            eventName: "cancel",
+            guard: { "==": [1, 1] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    { status: "CANCELLED", cancelledAt: { var: "$timestamp" } },
+                ],
+            },
+            dependencies: [],
+        },
+    ],
+});