@ottochain/sdk 2.3.0 → 2.5.0

package/dist/esm/apps/governance/state-machines/dao-token.js

@@ -1,196 +1,190 @@
-import { defineFiberApp } from "../../../schema/fiber-app.js";
+import { defineFiberApp } from '../../../schema/fiber-app.js';
+import { signerIsParty, actorIsSigner } from '../../../schema/guards.js';
 /**
  * Token-weighted voting. Voting power proportional to token holdings.
  */
 export const daoTokenDef = defineFiberApp({
     metadata: {
-        name: "TokenDAO",
-        app: "governance",
-        type: "daoToken",
-        version: "1.0.0",
-        description: "Token-weighted voting. Voting power proportional to token holdings.",
-        category: "governance/dao",
+        name: 'TokenDAO',
+        app: 'governance',
+        type: 'daoToken',
+        version: '1.0.0',
+        description: 'Token-weighted voting. Voting power proportional to token holdings.',
+        category: 'governance/dao',
         crossReferences: {
-            Identity: "voter verification",
-            Token: "balance snapshots",
-            Contract: "action execution",
-            Treasury: "fund management",
+            Identity: 'voter verification',
+            Token: 'balance snapshots',
+            Contract: 'action execution',
+            Treasury: 'fund management',
         },
     },
     createSchema: {
-        required: [
-            "balances",
-            "proposalThreshold",
-            "quorum",
-            "votingPeriodMs",
-            "timelockMs",
-        ],
+        required: ['balances', 'proposalThreshold', 'quorum', 'votingPeriodMs', 'timelockMs'],
         properties: {
             balances: {
-                type: "object",
-                description: "Initial token balances by address",
+                type: 'object',
+                description: 'Initial token balances by address',
             },
             proposalThreshold: {
-                type: "number",
-                description: "Min token balance to submit a proposal",
+                type: 'number',
+                description: 'Min token balance to submit a proposal',
             },
             quorum: {
-                type: "number",
-                description: "Min total votes (weighted) to pass",
+                type: 'number',
+                description: 'Min total votes (weighted) to pass',
             },
             votingPeriodMs: {
-                type: "number",
-                description: "Voting window in milliseconds",
+                type: 'number',
+                description: 'Voting window in milliseconds',
             },
             timelockMs: {
-                type: "number",
-                description: "Time-lock delay before execution",
+                type: 'number',
+                description: 'Time-lock delay before execution',
             },
         },
     },
     stateSchema: {
         properties: {
-            balances: { type: "object" },
-            delegations: { type: "object", computed: true },
-            proposalThreshold: { type: "number" },
-            quorum: { type: "number" },
-            votingPeriodMs: { type: "number" },
-            timelockMs: { type: "number" },
-            proposal: { type: "object" },
-            votes: { type: "object", computed: true },
-            executedProposals: { type: "array", computed: true },
-            rejectedProposals: { type: "array", computed: true },
-            cancelledProposals: { type: "array", computed: true },
+            balances: { type: 'object' },
+            delegations: { type: 'object', computed: true },
+            proposalThreshold: { type: 'number' },
+            quorum: { type: 'number' },
+            votingPeriodMs: { type: 'number' },
+            timelockMs: { type: 'number' },
+            proposal: { type: 'object' },
+            votes: { type: 'object', computed: true },
+            executedProposals: { type: 'array', computed: true },
+            rejectedProposals: { type: 'array', computed: true },
+            cancelledProposals: { type: 'array', computed: true },
         },
     },
     eventSchemas: {
         propose: {
-            description: "Submit a proposal (requires >= proposalThreshold tokens)",
-            required: [
-                "proposalId",
-                "title",
-                "description",
-                "actionType",
-                "payload",
-            ],
+            description: 'Submit a proposal (requires >= proposalThreshold tokens)',
+            required: ['proposalId', 'title', 'description', 'actionType', 'payload'],
             properties: {
-                agent: { type: "address" },
-                proposalId: { type: "string" },
-                title: { type: "string" },
-                description: { type: "string" },
-                actionType: { type: "string" },
-                payload: { type: "object" },
-                snapshotBlock: { type: "string" },
+                agent: { type: 'address' },
+                proposalId: { type: 'string' },
+                title: { type: 'string' },
+                description: { type: 'string' },
+                actionType: { type: 'string' },
+                payload: { type: 'object' },
+                snapshotBlock: { type: 'string' },
             },
         },
         vote: {
-            description: "Cast a token-weighted vote (must hold tokens, no double-vote, within window)",
-            required: ["vote"],
+            description: 'Cast a token-weighted vote (must hold tokens, no double-vote, within window)',
+            required: ['vote'],
             properties: {
-                agent: { type: "address" },
-                vote: { type: "string", description: '"for" | "against" | "abstain"' },
+                agent: { type: 'address' },
+                vote: { type: 'string', description: '"for" | "against" | "abstain"' },
             },
         },
         queue: {
-            description: "Queue passing proposal into timelock (voting ended, for > against, quorum met)",
+            description: 'Queue passing proposal into timelock (voting ended, for > against, quorum met)',
             properties: {},
         },
         execute: {
-            description: "Execute queued proposal after timelock expires",
+            description: 'Execute queued proposal after timelock expires',
             properties: {},
         },
         reject: {
-            description: "Formally reject a failed proposal (voting ended, failed conditions)",
+            description: 'Formally reject a failed proposal (voting ended, failed conditions)',
             properties: {},
         },
         cancel: {
-            description: "Cancel a queued proposal (proposer only)",
+            description: 'Cancel a queued proposal (proposer only)',
             properties: {
-                agent: { type: "address" },
+                agent: { type: 'address' },
             },
         },
         delegate: {
-            description: "Delegate voting power to another address",
-            required: ["delegateTo"],
+            description: 'Delegate voting power to another address',
+            required: ['delegateTo'],
             properties: {
-                agent: { type: "address" },
-                delegateTo: { type: "address" },
+                agent: { type: 'address' },
+                delegateTo: { type: 'address' },
             },
         },
         undelegate: {
-            description: "Revoke delegation",
+            description: 'Revoke delegation',
             properties: {
-                agent: { type: "address" },
+                agent: { type: 'address' },
             },
         },
     },
     states: {
         ACTIVE: {
-            id: "ACTIVE",
+            id: 'ACTIVE',
             isFinal: false,
             metadata: {
-                label: "Active",
-                description: "DAO is idle and ready to accept a proposal",
-                category: "initial",
+                label: 'Active',
+                description: 'DAO is idle and ready to accept a proposal',
+                category: 'initial',
             },
         },
         VOTING: {
-            id: "VOTING",
+            id: 'VOTING',
             isFinal: false,
             metadata: {
-                label: "Voting",
-                description: "Token holders are voting on the active proposal",
-                category: "pending",
+                label: 'Voting',
+                description: 'Token holders are voting on the active proposal',
+                category: 'pending',
             },
         },
         QUEUED: {
-            id: "QUEUED",
+            id: 'QUEUED',
             isFinal: false,
             metadata: {
-                label: "Queued",
-                description: "Passed proposal queued in timelock before execution",
-                category: "pending",
+                label: 'Queued',
+                description: 'Passed proposal queued in timelock before execution',
+                category: 'pending',
             },
         },
         DISSOLVED: {
-            id: "DISSOLVED",
+            id: 'DISSOLVED',
             isFinal: true,
             metadata: {
-                label: "Dissolved",
-                description: "Token DAO dissolved (terminal)",
-                category: "terminal",
+                label: 'Dissolved',
+                description: 'Token DAO dissolved (terminal)',
+                category: 'terminal',
             },
         },
     },
-    initialState: "ACTIVE",
+    initialState: 'ACTIVE',
     transitions: [
         // ACTIVE → VOTING: propose (enough tokens)
         {
-            from: "ACTIVE",
-            to: "VOTING",
-            eventName: "propose",
+            from: 'ACTIVE',
+            to: 'VOTING',
+            eventName: 'propose',
+            // S1/A2 coupled fix: a CHAIN-VERIFIED signer must hold >= proposalThreshold
+            // tokens. Iterate proofs[].address and read each balance via `get` (getKey is
+            // not a JLVM opcode); never trust the forgeable event.agent for the lookup.
             guard: {
-                ">=": [
-                    { getKey: [{ var: "state.balances" }, { var: "event.agent" }] },
-                    { var: "state.proposalThreshold" },
+                some: [
+                    { map: [{ var: 'proofs' }, { var: 'address' }] },
+                    {
+                        '>=': [{ get: [{ var: 'state.balances' }, { var: '' }] }, { var: 'state.proposalThreshold' }],
+                    },
                 ],
             },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { 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" },
+                            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: '$ordinal' },
                             votingEndsAt: {
-                                "+": [{ var: "$timestamp" }, { var: "state.votingPeriodMs" }],
+                                '+': [{ var: '$ordinal' }, { var: 'state.votingPeriodMs' }],
                             },
-                            snapshotBlock: { var: "event.snapshotBlock" },
+                            snapshotBlock: { var: 'event.snapshotBlock' },
                         },
                         votes: { for: 0, against: 0, abstain: 0, voters: {} },
                     },
@@ -200,78 +194,68 @@ export const daoTokenDef = defineFiberApp({
         },
         // VOTING → VOTING: vote (token holder, no double-vote, within window)
         {
-            from: "VOTING",
-            to: "VOTING",
-            eventName: "vote",
+            from: 'VOTING',
+            to: 'VOTING',
+            eventName: 'vote',
+            // S1+A2 coupled fix: bind event.agent to a verified signer (actorIsSigner) so the
+            // balance lookup, the no-double-vote check, and the voters write below all key on the
+            // CHAIN-VERIFIED actor — never a forgeable claim. getKey→get (value), getKey→has
+            // (presence), setKey→set are the rc.5 map opcodes (getKey/setKey do not exist).
             guard: {
                 and: [
+                    actorIsSigner(),
                     {
-                        ">": [
-                            { getKey: [{ var: "state.balances" }, { var: "event.agent" }] },
-                            0,
-                        ],
+                        '>': [{ get: [{ var: 'state.balances' }, { var: 'event.agent' }] }, 0],
                     },
                     {
-                        "!": [
+                        '!': [
                             {
-                                getKey: [{ var: "state.votes.voters" }, { var: "event.agent" }],
+                                has: [{ var: 'state.votes.voters' }, { var: 'event.agent' }],
                             },
                         ],
                     },
                     {
-                        "<=": [
-                            { var: "$timestamp" },
-                            { var: "state.proposal.votingEndsAt" },
-                        ],
+                        '<=': [{ var: '$ordinal' }, { var: 'state.proposal.votingEndsAt' }],
                     },
                 ],
             },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
                         votes: {
                             merge: [
-                                { var: "state.votes" },
+                                { var: 'state.votes' },
                                 {
                                     if: [
-                                        { "===": [{ var: "event.vote" }, "for"] },
+                                        { '===': [{ var: 'event.vote' }, 'for'] },
                                         {
                                             for: {
-                                                "+": [
-                                                    { var: "state.votes.for" },
+                                                '+': [
+                                                    { var: 'state.votes.for' },
                                                     {
-                                                        getKey: [
-                                                            { var: "state.balances" },
-                                                            { var: "event.agent" },
-                                                        ],
+                                                        get: [{ var: 'state.balances' }, { var: 'event.agent' }],
                                                     },
                                                 ],
                                             },
                                         },
-                                        { "===": [{ var: "event.vote" }, "against"] },
+                                        { '===': [{ var: 'event.vote' }, 'against'] },
                                         {
                                             against: {
-                                                "+": [
-                                                    { var: "state.votes.against" },
+                                                '+': [
+                                                    { var: 'state.votes.against' },
                                                     {
-                                                        getKey: [
-                                                            { var: "state.balances" },
-                                                            { var: "event.agent" },
-                                                        ],
+                                                        get: [{ var: 'state.balances' }, { var: 'event.agent' }],
                                                     },
                                                 ],
                                             },
                                         },
                                         {
                                             abstain: {
-                                                "+": [
-                                                    { var: "state.votes.abstain" },
+                                                '+': [
+                                                    { var: 'state.votes.abstain' },
                                                     {
-                                                        getKey: [
-                                                            { var: "state.balances" },
-                                                            { var: "event.agent" },
-                                                        ],
+                                                        get: [{ var: 'state.balances' }, { var: 'event.agent' }],
                                                     },
                                                 ],
                                             },
@@ -280,18 +264,15 @@ export const daoTokenDef = defineFiberApp({
                                 },
                                 {
                                     voters: {
-                                        setKey: [
-                                            { var: "state.votes.voters" },
-                                            { var: "event.agent" },
+                                        set: [
+                                            { var: 'state.votes.voters' },
+                                            { var: 'event.agent' },
                                             {
-                                                vote: { var: "event.vote" },
+                                                vote: { var: 'event.vote' },
                                                 weight: {
-                                                    getKey: [
-                                                        { var: "state.balances" },
-                                                        { var: "event.agent" },
-                                                    ],
+                                                    get: [{ var: 'state.balances' }, { var: 'event.agent' }],
                                                 },
-                                                votedAt: { var: "$timestamp" },
+                                                votedAt: { var: '$ordinal' },
                                             },
                                         ],
                                     },
@@ -305,43 +286,36 @@ export const daoTokenDef = defineFiberApp({
         },
         // VOTING → QUEUED: queue (voting ended, for > against, quorum met)
         {
-            from: "VOTING",
-            to: "QUEUED",
-            eventName: "queue",
+            from: 'VOTING',
+            to: 'QUEUED',
+            eventName: 'queue',
             guard: {
                 and: [
                     {
-                        ">": [
-                            { var: "$timestamp" },
-                            { var: "state.proposal.votingEndsAt" },
-                        ],
+                        '>': [{ var: '$ordinal' }, { var: 'state.proposal.votingEndsAt' }],
                     },
-                    { ">": [{ var: "state.votes.for" }, { var: "state.votes.against" }] },
+                    { '>': [{ var: 'state.votes.for' }, { var: 'state.votes.against' }] },
                     {
-                        ">=": [
+                        '>=': [
                             {
-                                "+": [
-                                    { var: "state.votes.for" },
-                                    { var: "state.votes.against" },
-                                    { var: "state.votes.abstain" },
-                                ],
+                                '+': [{ var: 'state.votes.for' }, { var: 'state.votes.against' }, { var: 'state.votes.abstain' }],
                             },
-                            { var: "state.quorum" },
+                            { var: 'state.quorum' },
                         ],
                     },
                 ],
             },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
                         proposal: {
                             merge: [
-                                { var: "state.proposal" },
+                                { var: 'state.proposal' },
                                 {
-                                    queuedAt: { var: "$timestamp" },
+                                    queuedAt: { var: '$ordinal' },
                                     executableAt: {
-                                        "+": [{ var: "$timestamp" }, { var: "state.timelockMs" }],
+                                        '+': [{ var: '$ordinal' }, { var: 'state.timelockMs' }],
                                     },
                                 },
                             ],
@@ -353,26 +327,26 @@ export const daoTokenDef = defineFiberApp({
         },
         // QUEUED → ACTIVE: execute (timelock expired)
         {
-            from: "QUEUED",
-            to: "ACTIVE",
-            eventName: "execute",
+            from: 'QUEUED',
+            to: 'ACTIVE',
+            eventName: 'execute',
             guard: {
-                ">=": [{ var: "$timestamp" }, { var: "state.proposal.executableAt" }],
+                '>=': [{ var: '$ordinal' }, { var: 'state.proposal.executableAt' }],
             },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
                         executedProposals: {
                             cat: [
-                                { var: "state.executedProposals" },
+                                { var: 'state.executedProposals' },
                                 [
                                     {
                                         merge: [
-                                            { var: "state.proposal" },
+                                            { var: 'state.proposal' },
                                             {
-                                                votes: { var: "state.votes" },
-                                                executedAt: { var: "$timestamp" },
+                                                votes: { var: 'state.votes' },
+                                                executedAt: { var: '$ordinal' },
                                             },
                                         ],
                                     },
@@ -381,43 +355,41 @@ export const daoTokenDef = defineFiberApp({
                         },
                         proposal: null,
                         votes: null,
+                        // A3 fix: transition-level `emits` is dropped by the chain; emit from INSIDE the effect
+                        // under the reserved `_emit` key (extracted as an EmittedEvent, stripped from state).
+                        _emit: [
+                            {
+                                name: 'proposal_executed',
+                                data: { proposalId: { var: 'state.proposal.id' } },
+                                destination: 'external',
+                            },
+                        ],
                     },
                 ],
             },
-            emits: [{ event: "proposal_executed", to: "external" }],
             dependencies: [],
         },
         // VOTING → ACTIVE: reject (voting ended, failed quorum or for <= against)
         {
-            from: "VOTING",
-            to: "ACTIVE",
-            eventName: "reject",
+            from: 'VOTING',
+            to: 'ACTIVE',
+            eventName: 'reject',
             guard: {
                 and: [
                     {
-                        ">": [
-                            { var: "$timestamp" },
-                            { var: "state.proposal.votingEndsAt" },
-                        ],
+                        '>': [{ var: '$ordinal' }, { var: 'state.proposal.votingEndsAt' }],
                     },
                     {
                         or: [
                             {
-                                "<=": [
-                                    { var: "state.votes.for" },
-                                    { var: "state.votes.against" },
-                                ],
+                                '<=': [{ var: 'state.votes.for' }, { var: 'state.votes.against' }],
                             },
                             {
-                                "<": [
+                                '<': [
                                     {
-                                        "+": [
-                                            { var: "state.votes.for" },
-                                            { var: "state.votes.against" },
-                                            { var: "state.votes.abstain" },
-                                        ],
+                                        '+': [{ var: 'state.votes.for' }, { var: 'state.votes.against' }, { var: 'state.votes.abstain' }],
                                     },
-                                    { var: "state.quorum" },
+                                    { var: 'state.quorum' },
                                 ],
                             },
                         ],
@@ -426,18 +398,18 @@ export const daoTokenDef = defineFiberApp({
             },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
                         rejectedProposals: {
                             cat: [
-                                { var: "state.rejectedProposals" },
+                                { var: 'state.rejectedProposals' },
                                 [
                                     {
                                         merge: [
-                                            { var: "state.proposal" },
+                                            { var: 'state.proposal' },
                                             {
-                                                votes: { var: "state.votes" },
-                                                rejectedAt: { var: "$timestamp" },
+                                                votes: { var: 'state.votes' },
+                                                rejectedAt: { var: '$ordinal' },
                                             },
                                         ],
                                     },
@@ -453,25 +425,20 @@ export const daoTokenDef = defineFiberApp({
         },
         // QUEUED → ACTIVE: cancel (proposer only)
         {
-            from: "QUEUED",
-            to: "ACTIVE",
-            eventName: "cancel",
-            guard: {
-                "===": [{ var: "event.agent" }, { var: "state.proposal.proposer" }],
-            },
+            from: 'QUEUED',
+            to: 'ACTIVE',
+            eventName: 'cancel',
+            guard: signerIsParty('state.proposal.proposer'),
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
                         cancelledProposals: {
                             cat: [
-                                { var: "state.cancelledProposals" },
+                                { var: 'state.cancelledProposals' },
                                 [
                                     {
-                                        merge: [
-                                            { var: "state.proposal" },
-                                            { cancelledAt: { var: "$timestamp" } },
-                                        ],
+                                        merge: [{ var: 'state.proposal' }, { cancelledAt: { var: '$ordinal' } }],
                                     },
                                 ],
                             ],
@@ -485,25 +452,25 @@ export const daoTokenDef = defineFiberApp({
         },
         // ACTIVE → ACTIVE: delegate
         {
-            from: "ACTIVE",
-            to: "ACTIVE",
-            eventName: "delegate",
+            from: 'ACTIVE',
+            to: 'ACTIVE',
+            eventName: 'delegate',
+            // S1+A2: bind event.agent to a verified signer so the delegation is written under the
+            // CHAIN-VERIFIED delegator's key (set), keyed on the same actor whose balance is checked (get).
             guard: {
-                ">": [
-                    { getKey: [{ var: "state.balances" }, { var: "event.agent" }] },
-                    0,
+                and: [
+                    actorIsSigner(),
+                    {
+                        '>': [{ get: [{ var: 'state.balances' }, { var: 'event.agent' }] }, 0],
+                    },
                 ],
             },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
                         delegations: {
-                            setKey: [
-                                { var: "state.delegations" },
-                                { var: "event.agent" },
-                                { var: "event.delegateTo" },
-                            ],
+                            set: [{ var: 'state.delegations' }, { var: 'event.agent' }, { var: 'event.delegateTo' }],
                         },
                     },
                 ],
@@ -512,16 +479,21 @@ export const daoTokenDef = defineFiberApp({
         },
         // ACTIVE → ACTIVE: undelegate
         {
-            from: "ACTIVE",
-            to: "ACTIVE",
-            eventName: "undelegate",
-            guard: { getKey: [{ var: "state.delegations" }, { var: "event.agent" }] },
+            from: 'ACTIVE',
+            to: 'ACTIVE',
+            eventName: 'undelegate',
+            // S1+A2: bind event.agent to a verified signer; presence via has, removal via unset (the rc.5
+            // map opcodes — getKey/deleteKey do not exist). Only the verified delegator can clear their own
+            // delegation.
+            guard: {
+                and: [actorIsSigner(), { has: [{ var: 'state.delegations' }, { var: 'event.agent' }] }],
+            },
             effect: {
                 merge: [
-                    { var: "state" },
+                    { var: 'state' },
                     {
                         delegations: {
-                            deleteKey: [{ var: "state.delegations" }, { var: "event.agent" }],
+                            unset: [{ var: 'state.delegations' }, { var: 'event.agent' }],
                         },
                     },
                 ],