@ottochain/sdk 2.3.0 → 2.5.0

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

@@ -1,210 +1,198 @@
-import { defineFiberApp } from "../../../schema/fiber-app.js";
+import { defineFiberApp } from '../../../schema/fiber-app.js';
+import { signerIsParty, signerIsAnyParty } from '../../../schema/guards.js';
 /**
  * Two-party agreement with mutual completion attestation and dispute resolution.
  */
 export const contractAgreementDef = defineFiberApp({
     metadata: {
-        name: "ContractAgreement",
-        app: "contracts",
-        type: "agreement",
-        version: "1.0.0",
-        description: "Two-party agreement with mutual completion attestation and dispute resolution",
+        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",
+                machine: 'identity-agent',
+                field: 'proposer',
                 description: "Links to proposer's AgentIdentity fiber",
             },
             counterpartyIdentityId: {
-                machine: "identity-agent",
-                field: "counterparty",
+                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",
+                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",
+                machine: 'arbitration-pool',
+                field: 'arbitrationPoolId',
+                description: 'Links to ArbitrationPool for dispute resolution',
             },
         },
     },
     createSchema: {
-        required: ["proposer", "counterparty"],
+        required: ['proposer', 'counterparty', 'arbitrator'],
         properties: {
             proposer: {
-                type: "address",
-                description: "DAG address of the proposer",
+                type: 'address',
+                description: 'DAG address of the proposer',
                 immutable: true,
             },
             counterparty: {
-                type: "address",
-                description: "DAG address of the counterparty",
+                type: 'address',
+                description: 'DAG address of the counterparty',
+                immutable: true,
+            },
+            arbitrator: {
+                type: 'address',
+                description: 'DAG address of the arbitrator authorized to resolve a dispute',
                 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 },
+            status: { type: 'string' },
+            proposer: { type: 'address' },
+            counterparty: { type: 'address' },
+            arbitrator: { type: 'address', immutable: true },
+            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" } } },
+        reject: { properties: { reason: { type: 'string' } } },
         cancel: {},
-        submit_completion: { properties: { proof: { type: "string" } } },
+        submit_completion: { properties: { proof: { type: 'string' } } },
         finalize: {},
-        dispute: { properties: { reason: { type: "string" } } },
+        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 },
+                resolution: { type: 'string' },
+                rulingId: { type: 'string', nullable: true },
             },
         },
     },
     states: {
         PROPOSED: {
-            id: "PROPOSED",
+            id: 'PROPOSED',
             isFinal: false,
             metadata: {
-                label: "Proposed",
-                description: "Agreement proposed; awaiting the counterparty",
-                category: "initial",
+                label: 'Proposed',
+                description: 'Agreement proposed; awaiting the counterparty',
+                category: 'initial',
             },
         },
         ACTIVE: {
-            id: "ACTIVE",
+            id: 'ACTIVE',
             isFinal: false,
             metadata: {
-                label: "Active",
-                description: "Agreement accepted and in effect",
-                category: "active",
+                label: 'Active',
+                description: 'Agreement accepted and in effect',
+                category: 'active',
             },
         },
         COMPLETED: {
-            id: "COMPLETED",
+            id: 'COMPLETED',
             isFinal: true,
             metadata: {
-                label: "Completed",
-                description: "Agreement completed and attested (terminal)",
-                category: "terminal",
+                label: 'Completed',
+                description: 'Agreement completed and attested (terminal)',
+                category: 'terminal',
             },
         },
         DISPUTED: {
-            id: "DISPUTED",
+            id: 'DISPUTED',
             isFinal: false,
             metadata: {
-                label: "Disputed",
-                description: "A party has raised a dispute; awaiting resolution",
-                category: "pending",
+                label: 'Disputed',
+                description: 'A party has raised a dispute; awaiting resolution',
+                category: 'pending',
             },
         },
         REJECTED: {
-            id: "REJECTED",
+            id: 'REJECTED',
             isFinal: true,
             metadata: {
-                label: "Rejected",
-                description: "Proposal rejected by the counterparty (terminal)",
-                category: "terminal",
+                label: 'Rejected',
+                description: 'Proposal rejected by the counterparty (terminal)',
+                category: 'terminal',
             },
         },
         CANCELLED: {
-            id: "CANCELLED",
+            id: 'CANCELLED',
             isFinal: true,
             metadata: {
-                label: "Cancelled",
-                description: "Agreement cancelled before completion (terminal)",
-                category: "terminal",
+                label: 'Cancelled',
+                description: 'Agreement cancelled before completion (terminal)',
+                category: 'terminal',
             },
         },
     },
-    initialState: "PROPOSED",
+    initialState: 'PROPOSED',
     transitions: [
         {
-            from: "PROPOSED",
-            to: "ACTIVE",
-            eventName: "accept",
-            guard: { "===": [{ var: "event.agent" }, { var: "state.counterparty" }] },
+            from: 'PROPOSED',
+            to: 'ACTIVE',
+            eventName: 'accept',
+            guard: signerIsParty('state.counterparty'),
             effect: {
-                merge: [
-                    { var: "state" },
-                    { status: "ACTIVE", acceptedAt: { var: "$timestamp" } },
-                ],
+                merge: [{ var: 'state' }, { status: 'ACTIVE', acceptedAt: { var: '$ordinal' } }],
             },
             dependencies: [],
         },
         {
-            from: "PROPOSED",
-            to: "REJECTED",
-            eventName: "reject",
-            guard: { "===": [{ var: "event.agent" }, { var: "state.counterparty" }] },
+            from: 'PROPOSED',
+            to: 'REJECTED',
+            eventName: 'reject',
+            guard: signerIsParty('state.counterparty'),
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        status: "REJECTED",
-                        rejectedAt: { var: "$timestamp" },
-                        rejectReason: { var: "event.reason" },
+                        status: 'REJECTED',
+                        rejectedAt: { var: '$ordinal' },
+                        rejectReason: { var: 'event.reason' },
                     },
                 ],
             },
             dependencies: [],
         },
         {
-            from: "PROPOSED",
-            to: "CANCELLED",
-            eventName: "cancel",
-            guard: { "===": [{ var: "event.agent" }, { var: "state.proposer" }] },
+            from: 'PROPOSED',
+            to: 'CANCELLED',
+            eventName: 'cancel',
+            guard: signerIsParty('state.proposer'),
             effect: {
-                merge: [
-                    { var: "state" },
-                    { status: "CANCELLED", cancelledAt: { var: "$timestamp" } },
-                ],
+                merge: [{ var: 'state' }, { status: 'CANCELLED', cancelledAt: { var: '$ordinal' } }],
             },
             dependencies: [],
         },
         {
-            from: "ACTIVE",
-            to: "ACTIVE",
-            eventName: "submit_completion",
+            from: 'ACTIVE',
+            to: 'ACTIVE',
+            eventName: 'submit_completion',
             guard: {
                 and: [
+                    signerIsAnyParty(['state.proposer', 'state.counterparty']),
                     {
-                        or: [
-                            { "===": [{ var: "event.agent" }, { var: "state.proposer" }] },
+                        '!': [
                             {
-                                "===": [{ var: "event.agent" }, { var: "state.counterparty" }],
-                            },
-                        ],
-                    },
-                    {
-                        "!": [
-                            {
-                                in: [
-                                    { var: "event.agent" },
-                                    { map: [{ var: "state.completions" }, { var: "agent" }] },
-                                ],
+                                in: [{ var: 'event.agent' }, { map: [{ var: 'state.completions' }, { var: 'agent' }] }],
                             },
                         ],
                     },
@@ -212,16 +200,16 @@ export const contractAgreementDef = defineFiberApp({
             },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
                         completions: {
                             cat: [
-                                { var: "state.completions" },
+                                { var: 'state.completions' },
                                 [
                                     {
-                                        agent: { var: "event.agent" },
-                                        proof: { var: "event.proof" },
-                                        submittedAt: { var: "$timestamp" },
+                                        agent: { var: 'event.agent' },
+                                        proof: { var: 'event.proof' },
+                                        submittedAt: { var: '$ordinal' },
                                     },
                                 ],
                             ],
@@ -232,84 +220,69 @@ export const contractAgreementDef = defineFiberApp({
             dependencies: [],
         },
         {
-            from: "ACTIVE",
-            to: "COMPLETED",
-            eventName: "finalize",
-            guard: { ">=": [{ size: { var: "state.completions" } }, 2] },
+            from: 'ACTIVE',
+            to: 'COMPLETED',
+            eventName: 'finalize',
+            guard: { '>=': [{ length: [{ var: 'state.completions' }] }, 2] },
             effect: {
-                merge: [
-                    { var: "state" },
-                    { status: "COMPLETED", completedAt: { var: "$timestamp" } },
-                ],
+                merge: [{ var: 'state' }, { status: 'COMPLETED', completedAt: { var: '$ordinal' } }],
             },
             dependencies: [],
         },
         {
-            from: "ACTIVE",
-            to: "DISPUTED",
-            eventName: "dispute",
-            guard: {
-                or: [
-                    { "===": [{ var: "event.agent" }, { var: "state.proposer" }] },
-                    { "===": [{ var: "event.agent" }, { var: "state.counterparty" }] },
-                ],
-            },
+            from: 'ACTIVE',
+            to: 'DISPUTED',
+            eventName: 'dispute',
+            guard: signerIsAnyParty(['state.proposer', 'state.counterparty']),
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        status: "DISPUTED",
-                        disputedAt: { var: "$timestamp" },
-                        disputeReason: { var: "event.reason" },
-                        disputedBy: { var: "event.agent" },
+                        status: 'DISPUTED',
+                        disputedAt: { var: '$ordinal' },
+                        disputeReason: { var: 'event.reason' },
+                        disputedBy: { var: 'event.agent' },
                     },
                 ],
             },
             dependencies: [],
         },
         {
-            from: "DISPUTED",
-            to: "COMPLETED",
-            eventName: "resolve",
+            from: 'DISPUTED',
+            to: 'COMPLETED',
+            eventName: 'resolve',
+            // authority gate — an ARBITER/SLASHER attestation check layers on additively when the identity registry lands (see docs/design/app-hardening-identity-integration.md §4.2)
             guard: {
                 or: [
-                    { var: "event.judicialRuling" },
+                    signerIsParty('state.arbitrator'),
                     {
-                        and: [
-                            { "===": [{ var: "event.proposerApproves" }, true] },
-                            { "===": [{ var: "event.counterpartyApproves" }, true] },
-                        ],
+                        and: [signerIsParty('state.proposer'), signerIsParty('state.counterparty')],
                     },
                 ],
             },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
-                        status: "COMPLETED",
-                        resolvedAt: { var: "$timestamp" },
-                        resolution: { var: "event.resolution" },
-                        rulingId: { var: "event.rulingId" },
+                        status: 'COMPLETED',
+                        resolvedAt: { var: '$ordinal' },
+                        resolution: { var: 'event.resolution' },
+                        // rulingId is recorded only on the arbitrator-resolved path
+                        rulingId: {
+                            if: [signerIsParty('state.arbitrator'), { var: 'event.rulingId' }, null],
+                        },
                     },
                 ],
             },
             dependencies: [],
         },
         {
-            from: "ACTIVE",
-            to: "CANCELLED",
-            eventName: "cancel",
-            guard: {
-                or: [
-                    { "===": [{ var: "event.agent" }, { var: "state.proposer" }] },
-                    { "===": [{ var: "event.agent" }, { var: "state.counterparty" }] },
-                ],
-            },
+            from: 'ACTIVE',
+            to: 'CANCELLED',
+            eventName: 'cancel',
+            guard: signerIsAnyParty(['state.proposer', 'state.counterparty']),
             effect: {
-                merge: [
-                    { var: "state" },
-                    { status: "CANCELLED", cancelledAt: { var: "$timestamp" } },
-                ],
+                merge: [{ var: 'state' }, { status: 'CANCELLED', cancelledAt: { var: '$ordinal' } }],
             },
             dependencies: [],
         },