@ottochain/sdk 1.7.0-beta.2 → 2.1.0

package/dist/cjs/apps/governance/state-machines/dao-reputation.js

@@ -0,0 +1,458 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.daoReputationDef = void 0;
+const fiber_app_js_1 = require("../../../schema/fiber-app.js");
+/**
+ * Reputation-based governance. Minimum reputation required for participation.
+ */
+exports.daoReputationDef = (0, fiber_app_js_1.defineFiberApp)({
+    metadata: {
+        name: "DAOReputation",
+        app: "governance",
+        type: "daoReputation",
+        version: "1.0.0",
+        description: "Reputation-based governance. Minimum reputation required for participation.",
+        category: "governance/dao",
+        crossReferences: {
+            Identity: "member verification",
+            Reputation: "threshold checks",
+            Contract: "action execution",
+        },
+    },
+    createSchema: {
+        required: [
+            "memberThreshold",
+            "voteThreshold",
+            "proposeThreshold",
+            "quorum",
+            "votingPeriodMs",
+        ],
+        properties: {
+            memberThreshold: {
+                type: "number",
+                description: "Min reputation to join as a member",
+            },
+            voteThreshold: { type: "number", description: "Min reputation to vote" },
+            proposeThreshold: {
+                type: "number",
+                description: "Min reputation to submit a proposal",
+            },
+            quorum: {
+                type: "number",
+                description: "Min total votes (count) to execute",
+            },
+            votingPeriodMs: {
+                type: "number",
+                description: "Voting window in milliseconds",
+            },
+        },
+    },
+    stateSchema: {
+        properties: {
+            members: { type: "array", computed: true },
+            memberJoinedAt: { type: "object", computed: true },
+            memberThreshold: { type: "number" },
+            voteThreshold: { type: "number" },
+            proposeThreshold: { type: "number" },
+            quorum: { type: "number" },
+            votingPeriodMs: { type: "number" },
+            proposal: { type: "object" },
+            votes: { type: "object", computed: true },
+            history: { type: "array", computed: true },
+        },
+    },
+    eventSchemas: {
+        propose: {
+            description: "Submit a proposal (requires >= proposeThreshold reputation)",
+            required: [
+                "proposalId",
+                "title",
+                "description",
+                "actionType",
+                "payload",
+                "agentReputation",
+            ],
+            properties: {
+                agent: { type: "address" },
+                agentReputation: { type: "number" },
+                proposalId: { type: "string" },
+                title: { type: "string" },
+                description: { type: "string" },
+                actionType: { type: "string" },
+                payload: { type: "object" },
+            },
+        },
+        vote: {
+            description: "Cast a vote (requires >= voteThreshold, no double-vote, within window)",
+            required: ["vote", "agentReputation"],
+            properties: {
+                agent: { type: "address" },
+                agentReputation: { type: "number" },
+                vote: { type: "string", description: '"for" | "against" | "abstain"' },
+            },
+        },
+        execute: {
+            description: "Execute a passing proposal after voting ends",
+            properties: {},
+        },
+        reject: {
+            description: "Formally reject a failed proposal",
+            properties: {},
+        },
+        join: {
+            description: "Join the DAO (requires >= memberThreshold reputation)",
+            required: ["agentReputation"],
+            properties: {
+                agent: { type: "address" },
+                agentReputation: { type: "number" },
+            },
+        },
+        leave: {
+            description: "Leave the DAO voluntarily",
+            properties: {
+                agent: { type: "address" },
+            },
+        },
+        propose_threshold_change: {
+            description: "Propose changing reputation thresholds",
+            required: ["proposalId", "agentReputation"],
+            properties: {
+                agent: { type: "address" },
+                agentReputation: { type: "number" },
+                proposalId: { type: "string" },
+                memberThreshold: { type: "number" },
+                voteThreshold: { type: "number" },
+                proposeThreshold: { type: "number" },
+            },
+        },
+    },
+    states: {
+        ACTIVE: { id: "ACTIVE", isFinal: false, metadata: null },
+        VOTING: { id: "VOTING", isFinal: false, metadata: null },
+        DISSOLVED: { id: "DISSOLVED", isFinal: true, metadata: null },
+    },
+    initialState: "ACTIVE",
+    transitions: [
+        // ACTIVE → VOTING: propose (reputation check)
+        {
+            from: "ACTIVE",
+            to: "VOTING",
+            eventName: "propose",
+            guard: {
+                ">=": [
+                    { var: "event.agentReputation" },
+                    { var: "state.proposeThreshold" },
+                ],
+            },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        proposal: {
+                            id: { var: "event.proposalId" },
+                            title: { var: "event.title" },
+                            description: { var: "event.description" },
+                            actionType: { var: "event.actionType" },
+                            payload: { var: "event.payload" },
+                            proposer: { var: "event.agent" },
+                            proposedAt: { var: "$timestamp" },
+                            deadline: {
+                                "+": [{ var: "$timestamp" }, { var: "state.votingPeriodMs" }],
+                            },
+                        },
+                        votes: { for: [], against: [], abstain: [] },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        // VOTING → VOTING: vote (reputation check, no double-vote, within window)
+        {
+            from: "VOTING",
+            to: "VOTING",
+            eventName: "vote",
+            guard: {
+                and: [
+                    {
+                        ">=": [
+                            { var: "event.agentReputation" },
+                            { var: "state.voteThreshold" },
+                        ],
+                    },
+                    {
+                        "!": [{ in: [{ var: "event.agent" }, { var: "state.votes.for" }] }],
+                    },
+                    {
+                        "!": [
+                            { in: [{ var: "event.agent" }, { var: "state.votes.against" }] },
+                        ],
+                    },
+                    {
+                        "!": [
+                            { in: [{ var: "event.agent" }, { var: "state.votes.abstain" }] },
+                        ],
+                    },
+                    { "<=": [{ var: "$timestamp" }, { var: "state.proposal.deadline" }] },
+                ],
+            },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        votes: {
+                            if: [
+                                { "===": [{ var: "event.vote" }, "for"] },
+                                {
+                                    merge: [
+                                        { var: "state.votes" },
+                                        {
+                                            for: {
+                                                cat: [
+                                                    { var: "state.votes.for" },
+                                                    [{ var: "event.agent" }],
+                                                ],
+                                            },
+                                        },
+                                    ],
+                                },
+                                { "===": [{ var: "event.vote" }, "against"] },
+                                {
+                                    merge: [
+                                        { var: "state.votes" },
+                                        {
+                                            against: {
+                                                cat: [
+                                                    { var: "state.votes.against" },
+                                                    [{ var: "event.agent" }],
+                                                ],
+                                            },
+                                        },
+                                    ],
+                                },
+                                {
+                                    merge: [
+                                        { var: "state.votes" },
+                                        {
+                                            abstain: {
+                                                cat: [
+                                                    { var: "state.votes.abstain" },
+                                                    [{ var: "event.agent" }],
+                                                ],
+                                            },
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        // VOTING → ACTIVE: execute (voting ended, for > against, quorum met)
+        {
+            from: "VOTING",
+            to: "ACTIVE",
+            eventName: "execute",
+            guard: {
+                and: [
+                    { ">": [{ var: "$timestamp" }, { var: "state.proposal.deadline" }] },
+                    {
+                        ">": [
+                            { size: { var: "state.votes.for" } },
+                            { size: { var: "state.votes.against" } },
+                        ],
+                    },
+                    {
+                        ">=": [
+                            {
+                                "+": [
+                                    { size: { var: "state.votes.for" } },
+                                    { size: { var: "state.votes.against" } },
+                                ],
+                            },
+                            { var: "state.quorum" },
+                        ],
+                    },
+                ],
+            },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        history: {
+                            cat: [
+                                { var: "state.history" },
+                                [
+                                    {
+                                        type: "executed",
+                                        proposal: { var: "state.proposal" },
+                                        votes: { var: "state.votes" },
+                                        at: { var: "$timestamp" },
+                                    },
+                                ],
+                            ],
+                        },
+                        proposal: null,
+                        votes: null,
+                    },
+                ],
+            },
+            emits: [
+                {
+                    event: "proposal_executed",
+                    to: "Reputation",
+                    payload: { action: "increase", agents: { var: "state.votes.for" } },
+                },
+            ],
+            dependencies: [],
+        },
+        // VOTING → ACTIVE: reject (voting ended, for <= against or quorum not met)
+        {
+            from: "VOTING",
+            to: "ACTIVE",
+            eventName: "reject",
+            guard: {
+                and: [
+                    { ">": [{ var: "$timestamp" }, { var: "state.proposal.deadline" }] },
+                    {
+                        or: [
+                            {
+                                "<=": [
+                                    { size: { var: "state.votes.for" } },
+                                    { size: { var: "state.votes.against" } },
+                                ],
+                            },
+                            {
+                                "<": [
+                                    {
+                                        "+": [
+                                            { size: { var: "state.votes.for" } },
+                                            { size: { var: "state.votes.against" } },
+                                        ],
+                                    },
+                                    { var: "state.quorum" },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        history: {
+                            cat: [
+                                { var: "state.history" },
+                                [
+                                    {
+                                        type: "rejected",
+                                        proposal: { var: "state.proposal" },
+                                        votes: { var: "state.votes" },
+                                        at: { var: "$timestamp" },
+                                    },
+                                ],
+                            ],
+                        },
+                        proposal: null,
+                        votes: null,
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        // ACTIVE → ACTIVE: join (reputation check, not already member)
+        {
+            from: "ACTIVE",
+            to: "ACTIVE",
+            eventName: "join",
+            guard: {
+                and: [
+                    {
+                        ">=": [
+                            { var: "event.agentReputation" },
+                            { var: "state.memberThreshold" },
+                        ],
+                    },
+                    { "!": [{ in: [{ var: "event.agent" }, { var: "state.members" }] }] },
+                ],
+            },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        members: {
+                            cat: [{ var: "state.members" }, [{ var: "event.agent" }]],
+                        },
+                        memberJoinedAt: {
+                            setKey: [
+                                { var: "state.memberJoinedAt" },
+                                { var: "event.agent" },
+                                { var: "$timestamp" },
+                            ],
+                        },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        // ACTIVE → ACTIVE: leave (member only)
+        {
+            from: "ACTIVE",
+            to: "ACTIVE",
+            eventName: "leave",
+            guard: { in: [{ var: "event.agent" }, { var: "state.members" }] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        members: {
+                            filter: [
+                                { var: "state.members" },
+                                { "!==": [{ var: "" }, { var: "event.agent" }] },
+                            ],
+                        },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        // ACTIVE → VOTING: propose_threshold_change
+        {
+            from: "ACTIVE",
+            to: "VOTING",
+            eventName: "propose_threshold_change",
+            guard: {
+                ">=": [
+                    { var: "event.agentReputation" },
+                    { var: "state.proposeThreshold" },
+                ],
+            },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        proposal: {
+                            id: { var: "event.proposalId" },
+                            title: "Threshold Change",
+                            actionType: "threshold_change",
+                            payload: {
+                                memberThreshold: { var: "event.memberThreshold" },
+                                voteThreshold: { var: "event.voteThreshold" },
+                                proposeThreshold: { var: "event.proposeThreshold" },
+                            },
+                            proposer: { var: "event.agent" },
+                            proposedAt: { var: "$timestamp" },
+                            deadline: {
+                                "+": [{ var: "$timestamp" }, { var: "state.votingPeriodMs" }],
+                            },
+                        },
+                        votes: { for: [], against: [], abstain: [] },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+    ],
+});

package/dist/cjs/apps/governance/state-machines/dao-single.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.daoSingleDef = void 0;
+const fiber_app_js_1 = require("../../../schema/fiber-app.js");
+/**
+ * Single owner controls all actions. Simplest governance model.
+ */
+exports.daoSingleDef = (0, fiber_app_js_1.defineFiberApp)({
+    metadata: {
+        name: "SingleOwnerDAO",
+        app: "governance",
+        type: "daoSingle",
+        version: "1.0.0",
+        description: "Single owner controls all actions. Simplest governance model.",
+        category: "governance/dao",
+        crossReferences: {
+            Identity: "owner registration",
+            Contract: "action execution targets",
+            Treasury: "fund management",
+        },
+    },
+    createSchema: {
+        required: ["owner"],
+        properties: {
+            owner: {
+                type: "address",
+                description: "DAG address of the initial owner",
+                immutable: false,
+            },
+        },
+    },
+    stateSchema: {
+        properties: {
+            owner: { type: "address" },
+            pendingOwner: { type: "address" },
+            transferInitiatedAt: { type: "timestamp" },
+            ownershipHistory: { type: "array", computed: true },
+            actions: { type: "array", computed: true },
+            status: { type: "string", computed: true },
+        },
+    },
+    eventSchemas: {
+        execute: {
+            description: "Execute an action (owner only)",
+            required: ["actionId", "actionType", "payload"],
+            properties: {
+                agent: { type: "address" },
+                actionId: { type: "string" },
+                actionType: { type: "string" },
+                payload: { type: "object" },
+            },
+        },
+        transfer_ownership: {
+            description: "Initiate ownership transfer (owner only)",
+            required: ["newOwner"],
+            properties: {
+                agent: { type: "address" },
+                newOwner: { type: "address" },
+            },
+        },
+        accept_ownership: {
+            description: "Accept ownership (pending owner only)",
+            properties: {
+                agent: { type: "address" },
+            },
+        },
+        cancel_transfer: {
+            description: "Cancel pending ownership transfer (owner only)",
+            properties: {
+                agent: { type: "address" },
+            },
+        },
+        dissolve: {
+            description: "Dissolve the DAO (owner only)",
+            properties: {
+                agent: { type: "address" },
+            },
+        },
+    },
+    states: {
+        ACTIVE: { id: "ACTIVE", isFinal: false, metadata: null },
+        TRANSFERRING: { id: "TRANSFERRING", isFinal: false, metadata: null },
+        DISSOLVED: { id: "DISSOLVED", isFinal: true, metadata: null },
+    },
+    initialState: "ACTIVE",
+    transitions: [
+        // ACTIVE → ACTIVE: execute (owner only)
+        {
+            from: "ACTIVE",
+            to: "ACTIVE",
+            eventName: "execute",
+            guard: { "===": [{ var: "event.agent" }, { var: "state.owner" }] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        actions: {
+                            cat: [
+                                { var: "state.actions" },
+                                [
+                                    {
+                                        id: { var: "event.actionId" },
+                                        type: { var: "event.actionType" },
+                                        payload: { var: "event.payload" },
+                                        executedAt: { var: "$timestamp" },
+                                    },
+                                ],
+                            ],
+                        },
+                    },
+                ],
+            },
+            emits: [{ event: "action_executed", to: "external" }],
+            dependencies: [],
+        },
+        // ACTIVE → TRANSFERRING: transfer_ownership (owner only)
+        {
+            from: "ACTIVE",
+            to: "TRANSFERRING",
+            eventName: "transfer_ownership",
+            guard: { "===": [{ var: "event.agent" }, { var: "state.owner" }] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        pendingOwner: { var: "event.newOwner" },
+                        transferInitiatedAt: { var: "$timestamp" },
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        // TRANSFERRING → ACTIVE: accept_ownership (pending owner only)
+        {
+            from: "TRANSFERRING",
+            to: "ACTIVE",
+            eventName: "accept_ownership",
+            guard: { "===": [{ var: "event.agent" }, { var: "state.pendingOwner" }] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        owner: { var: "state.pendingOwner" },
+                        pendingOwner: null,
+                        transferInitiatedAt: null,
+                        ownershipHistory: {
+                            cat: [
+                                { var: "state.ownershipHistory" },
+                                [
+                                    {
+                                        from: { var: "state.owner" },
+                                        to: { var: "state.pendingOwner" },
+                                        at: { var: "$timestamp" },
+                                    },
+                                ],
+                            ],
+                        },
+                    },
+                ],
+            },
+            emits: [{ event: "ownership_transferred", to: "Identity" }],
+            dependencies: [],
+        },
+        // TRANSFERRING → ACTIVE: cancel_transfer (owner only)
+        {
+            from: "TRANSFERRING",
+            to: "ACTIVE",
+            eventName: "cancel_transfer",
+            guard: { "===": [{ var: "event.agent" }, { var: "state.owner" }] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        pendingOwner: null,
+                        transferInitiatedAt: null,
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+        // ACTIVE → DISSOLVED: dissolve (owner only)
+        {
+            from: "ACTIVE",
+            to: "DISSOLVED",
+            eventName: "dissolve",
+            guard: { "===": [{ var: "event.agent" }, { var: "state.owner" }] },
+            effect: {
+                merge: [
+                    { var: "state" },
+                    {
+                        dissolvedAt: { var: "$timestamp" },
+                        status: "DISSOLVED",
+                    },
+                ],
+            },
+            dependencies: [],
+        },
+    ],
+});