@spectratools/assembly-cli 0.8.2 → 0.9.0

package/dist/cli.js

@@ -5622,6 +5622,7 @@ forum.command("stats", {
 });
 
 // src/commands/governance.ts
+import { TxError } from "@spectratools/tx-shared";
 import { Cli as Cli3, z as z4 } from "incur";
 var env3 = z4.object({
   ABSTRACT_RPC_URL: z4.string().optional().describe("Abstract RPC URL override")
@@ -5635,6 +5636,14 @@ var proposalStatusLabels = {
   4: "defeated",
   5: "cancelled"
 };
+var PROPOSAL_STATUS_PENDING = 0;
+var PROPOSAL_STATUS_ACTIVE = 1;
+var PROPOSAL_STATUS_PASSED = 2;
+var supportChoiceToValue = {
+  against: 0,
+  for: 1,
+  abstain: 2
+};
 function proposalStatus(status) {
   const statusCode = asNum(status);
   return {
@@ -5749,6 +5758,23 @@ function serializeProposal(proposal) {
     description: proposal.description
   };
 }
+async function readProposalCount(client) {
+  return await client.readContract({
+    abi: governanceAbi,
+    address: ABSTRACT_MAINNET_ADDRESSES.governance,
+    functionName: "proposalCount"
+  });
+}
+async function readProposalById(client, proposalId) {
+  return decodeProposal(
+    await client.readContract({
+      abi: governanceAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.governance,
+      functionName: "proposals",
+      args: [BigInt(proposalId)]
+    })
+  );
+}
 var governance = Cli3.create("governance", {
   description: "Inspect Assembly governance proposals, votes, and parameters."
 });
@@ -5806,7 +5832,10 @@ governance.command("proposals", {
           description: "Inspect or vote:",
           commands: [
             { command: "governance proposal", args: { id: "<id>" } },
-            { command: "governance vote", args: { id: "<id>" } }
+            {
+              command: "governance vote",
+              args: { proposalId: "<id>", support: "<for|against|abstain>" }
+            }
           ]
         }
       }
@@ -5940,9 +5969,381 @@ governance.command("params", {
     });
   }
 });
+var txResultOutput2 = z4.union([
+  z4.object({
+    status: z4.enum(["success", "reverted"]),
+    hash: z4.string(),
+    blockNumber: z4.number(),
+    gasUsed: z4.string(),
+    from: z4.string(),
+    to: z4.string().nullable(),
+    effectiveGasPrice: z4.string().optional()
+  }),
+  z4.object({
+    status: z4.literal("dry-run"),
+    estimatedGas: z4.string(),
+    simulationResult: z4.unknown()
+  })
+]);
+governance.command("vote", {
+  description: "Cast a governance vote on a proposal.",
+  hint: "Requires PRIVATE_KEY environment variable for signing.",
+  args: z4.object({
+    proposalId: z4.coerce.number().int().positive().describe("Proposal id (1-indexed)"),
+    support: z4.enum(["for", "against", "abstain"]).describe("Vote support: for, against, or abstain")
+  }),
+  options: writeOptions,
+  env: writeEnv,
+  output: z4.object({
+    proposalId: z4.number(),
+    proposalTitle: z4.string(),
+    support: z4.enum(["for", "against", "abstain"]),
+    supportValue: z4.number(),
+    tx: txResultOutput2
+  }),
+  examples: [
+    {
+      args: { proposalId: 1, support: "for" },
+      description: "Vote in favor of proposal #1"
+    },
+    {
+      args: { proposalId: 1, support: "abstain" },
+      options: { "dry-run": true },
+      description: "Simulate casting an abstain vote"
+    }
+  ],
+  async run(c) {
+    const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
+    const account = resolveAccount(c.env);
+    const proposalCount = await readProposalCount(client);
+    if (c.args.proposalId > Number(proposalCount)) {
+      return c.error({
+        code: "OUT_OF_RANGE",
+        message: `Proposal id ${c.args.proposalId} does not exist (proposalCount: ${proposalCount})`,
+        retryable: false
+      });
+    }
+    const proposal = await readProposalById(client, c.args.proposalId);
+    const status = proposalStatus(proposal.status);
+    if (status.statusCode !== PROPOSAL_STATUS_ACTIVE) {
+      return c.error({
+        code: "PROPOSAL_NOT_VOTING",
+        message: `Proposal ${c.args.proposalId} is ${status.status} and cannot be voted right now.`,
+        retryable: false
+      });
+    }
+    const hasVoted = await client.readContract({
+      abi: governanceAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.governance,
+      functionName: "hasVoted",
+      args: [BigInt(c.args.proposalId), account.address]
+    });
+    if (hasVoted) {
+      return c.error({
+        code: "ALREADY_VOTED",
+        message: `Address ${toChecksum(account.address)} has already voted on proposal ${c.args.proposalId}.`,
+        retryable: false
+      });
+    }
+    const supportValue = supportChoiceToValue[c.args.support];
+    try {
+      const txResult = await assemblyWriteTx({
+        env: c.env,
+        options: c.options,
+        address: ABSTRACT_MAINNET_ADDRESSES.governance,
+        abi: governanceAbi,
+        functionName: "castVote",
+        args: [BigInt(c.args.proposalId), supportValue]
+      });
+      return c.ok({
+        proposalId: c.args.proposalId,
+        proposalTitle: proposal.title,
+        support: c.args.support,
+        supportValue,
+        tx: txResult
+      });
+    } catch (error) {
+      if (error instanceof TxError) {
+        return c.error({
+          code: error.code,
+          message: error.message,
+          retryable: error.code === "NONCE_CONFLICT"
+        });
+      }
+      throw error;
+    }
+  }
+});
+governance.command("propose", {
+  description: "Create a new council-originated governance proposal.",
+  hint: "Requires PRIVATE_KEY environment variable for signing.",
+  options: writeOptions.extend({
+    title: z4.string().min(1).describe("Proposal title"),
+    description: z4.string().min(1).describe("Proposal description"),
+    kind: z4.coerce.number().int().nonnegative().max(255).describe("Proposal kind enum value"),
+    category: z4.string().default("governance").describe("Forum category label for the proposal"),
+    "risk-tier": z4.coerce.number().int().nonnegative().max(255).optional().describe("Optional max allowed intent risk tier (default: 0)"),
+    amount: z4.string().optional().describe("Optional treasury amount hint (currently unsupported for intent encoding)"),
+    recipient: z4.string().optional().describe("Optional treasury recipient hint (currently unsupported for intent encoding)")
+  }),
+  env: writeEnv,
+  output: z4.object({
+    proposer: z4.string(),
+    category: z4.string(),
+    kind: z4.number(),
+    title: z4.string(),
+    description: z4.string(),
+    expectedProposalId: z4.number(),
+    tx: txResultOutput2
+  }),
+  examples: [
+    {
+      options: {
+        title: "Increase quorum requirement",
+        description: "Raise quorum from 10% to 12% for governance votes.",
+        kind: 3
+      },
+      description: "Create a governance proposal from a council member account"
+    }
+  ],
+  async run(c) {
+    const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
+    const account = resolveAccount(c.env);
+    if (c.options.amount && !c.options.recipient || !c.options.amount && c.options.recipient) {
+      return c.error({
+        code: "INVALID_PROPOSAL_OPTIONS",
+        message: "Both --amount and --recipient must be provided together when setting transfer hints.",
+        retryable: false
+      });
+    }
+    if (c.options.amount || c.options.recipient) {
+      return c.error({
+        code: "UNSUPPORTED_TRANSFER_INTENT",
+        message: "Transfer intents are not yet supported by `governance propose`. Omit --amount/--recipient and use intent-specific tooling.",
+        retryable: false
+      });
+    }
+    const isCouncilMember = await client.readContract({
+      abi: councilSeatsAbi,
+      address: ABSTRACT_MAINNET_ADDRESSES.councilSeats,
+      functionName: "isCouncilMember",
+      args: [account.address]
+    });
+    if (!isCouncilMember) {
+      return c.error({
+        code: "NOT_COUNCIL_MEMBER",
+        message: `Address ${toChecksum(account.address)} is not an active council member and cannot create a council proposal.`,
+        retryable: false
+      });
+    }
+    const proposalCountBefore = await readProposalCount(client);
+    const expectedProposalId = Number(proposalCountBefore) + 1;
+    const proposalInput = {
+      kind: c.options.kind,
+      title: c.options.title,
+      description: c.options.description,
+      intentSteps: [],
+      intentConstraints: {
+        deadline: 0,
+        maxAllowedRiskTier: c.options["risk-tier"] ?? 0
+      },
+      configUpdates: []
+    };
+    try {
+      const txResult = await assemblyWriteTx({
+        env: c.env,
+        options: c.options,
+        address: ABSTRACT_MAINNET_ADDRESSES.forum,
+        abi: forumAbi,
+        functionName: "createCouncilProposal",
+        args: [c.options.category, proposalInput]
+      });
+      return c.ok({
+        proposer: toChecksum(account.address),
+        category: c.options.category,
+        kind: c.options.kind,
+        title: c.options.title,
+        description: c.options.description,
+        expectedProposalId,
+        tx: txResult
+      });
+    } catch (error) {
+      if (error instanceof TxError) {
+        return c.error({
+          code: error.code,
+          message: error.message,
+          retryable: error.code === "NONCE_CONFLICT"
+        });
+      }
+      throw error;
+    }
+  }
+});
+governance.command("queue", {
+  description: "Finalize voting and queue an eligible proposal into timelock.",
+  hint: "Requires PRIVATE_KEY environment variable for signing.",
+  args: z4.object({
+    proposalId: z4.coerce.number().int().positive().describe("Proposal id (1-indexed)")
+  }),
+  options: writeOptions,
+  env: writeEnv,
+  output: z4.object({
+    proposalId: z4.number(),
+    proposalTitle: z4.string(),
+    statusBefore: z4.string(),
+    tx: txResultOutput2
+  }),
+  examples: [
+    {
+      args: { proposalId: 1 },
+      description: "Finalize voting for proposal #1 and queue if passed"
+    }
+  ],
+  async run(c) {
+    const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
+    const proposalCount = await readProposalCount(client);
+    if (c.args.proposalId > Number(proposalCount)) {
+      return c.error({
+        code: "OUT_OF_RANGE",
+        message: `Proposal id ${c.args.proposalId} does not exist (proposalCount: ${proposalCount})`,
+        retryable: false
+      });
+    }
+    const proposal = await readProposalById(client, c.args.proposalId);
+    const status = proposalStatus(proposal.status);
+    if (status.statusCode === PROPOSAL_STATUS_PASSED) {
+      return c.error({
+        code: "ALREADY_QUEUED",
+        message: `Proposal ${c.args.proposalId} is already queued in timelock.`,
+        retryable: false
+      });
+    }
+    if (status.statusCode === PROPOSAL_STATUS_PENDING) {
+      return c.error({
+        code: "PROPOSAL_NOT_QUEUEABLE",
+        message: `Proposal ${c.args.proposalId} is still in deliberation and cannot be queued yet.`,
+        retryable: false
+      });
+    }
+    if (status.statusCode !== PROPOSAL_STATUS_ACTIVE) {
+      return c.error({
+        code: "PROPOSAL_NOT_QUEUEABLE",
+        message: `Proposal ${c.args.proposalId} is ${status.status} and cannot be queued.`,
+        retryable: false
+      });
+    }
+    const latestBlock = await client.getBlock({ blockTag: "latest" });
+    if (latestBlock.timestamp < proposal.voteEndAt) {
+      return c.error({
+        code: "VOTING_STILL_ACTIVE",
+        message: `Proposal ${c.args.proposalId} voting window is still open (ends ${relTime(proposal.voteEndAt)}).`,
+        retryable: false
+      });
+    }
+    try {
+      const txResult = await assemblyWriteTx({
+        env: c.env,
+        options: c.options,
+        address: ABSTRACT_MAINNET_ADDRESSES.governance,
+        abi: governanceAbi,
+        functionName: "finalizeVote",
+        args: [BigInt(c.args.proposalId)]
+      });
+      return c.ok({
+        proposalId: c.args.proposalId,
+        proposalTitle: proposal.title,
+        statusBefore: status.status,
+        tx: txResult
+      });
+    } catch (error) {
+      if (error instanceof TxError) {
+        return c.error({
+          code: error.code,
+          message: error.message,
+          retryable: error.code === "NONCE_CONFLICT"
+        });
+      }
+      throw error;
+    }
+  }
+});
+governance.command("execute", {
+  description: "Execute a queued governance proposal after timelock expiry.",
+  hint: "Requires PRIVATE_KEY environment variable for signing.",
+  args: z4.object({
+    proposalId: z4.coerce.number().int().positive().describe("Proposal id (1-indexed)")
+  }),
+  options: writeOptions,
+  env: writeEnv,
+  output: z4.object({
+    proposalId: z4.number(),
+    proposalTitle: z4.string(),
+    timelockEndsAt: timestampOutput3,
+    tx: txResultOutput2
+  }),
+  examples: [
+    {
+      args: { proposalId: 1 },
+      description: "Execute proposal #1 after timelock has expired"
+    }
+  ],
+  async run(c) {
+    const client = createAssemblyPublicClient(c.env.ABSTRACT_RPC_URL);
+    const proposalCount = await readProposalCount(client);
+    if (c.args.proposalId > Number(proposalCount)) {
+      return c.error({
+        code: "OUT_OF_RANGE",
+        message: `Proposal id ${c.args.proposalId} does not exist (proposalCount: ${proposalCount})`,
+        retryable: false
+      });
+    }
+    const proposal = await readProposalById(client, c.args.proposalId);
+    const status = proposalStatus(proposal.status);
+    if (status.statusCode !== PROPOSAL_STATUS_PASSED) {
+      return c.error({
+        code: "PROPOSAL_NOT_EXECUTABLE",
+        message: `Proposal ${c.args.proposalId} is ${status.status} and cannot be executed.`,
+        retryable: false
+      });
+    }
+    const latestBlock = await client.getBlock({ blockTag: "latest" });
+    if (latestBlock.timestamp < proposal.timelockEndsAt) {
+      return c.error({
+        code: "TIMELOCK_ACTIVE",
+        message: `Proposal ${c.args.proposalId} timelock has not expired yet (ends ${relTime(proposal.timelockEndsAt)}).`,
+        retryable: false
+      });
+    }
+    try {
+      const txResult = await assemblyWriteTx({
+        env: c.env,
+        options: c.options,
+        address: ABSTRACT_MAINNET_ADDRESSES.governance,
+        abi: governanceAbi,
+        functionName: "executeProposal",
+        args: [BigInt(c.args.proposalId)]
+      });
+      return c.ok({
+        proposalId: c.args.proposalId,
+        proposalTitle: proposal.title,
+        timelockEndsAt: timeValue(proposal.timelockEndsAt, c.format),
+        tx: txResult
+      });
+    } catch (error) {
+      if (error instanceof TxError) {
+        return c.error({
+          code: error.code,
+          message: error.message,
+          retryable: error.code === "NONCE_CONFLICT"
+        });
+      }
+      throw error;
+    }
+  }
+});
 
 // src/commands/members.ts
-import { TxError } from "@spectratools/tx-shared";
+import { TxError as TxError2 } from "@spectratools/tx-shared";
 import { Cli as Cli4, z as z5 } from "incur";
 var DEFAULT_MEMBER_SNAPSHOT_URL = "https://www.theaiassembly.org/api/indexer/members";
 var REGISTERED_EVENT_SCAN_STEP = 100000n;
@@ -6435,7 +6836,7 @@ members.command("register", {
         } : void 0
       );
     } catch (error) {
-      if (error instanceof TxError && error.code === "INSUFFICIENT_FUNDS") {
+      if (error instanceof TxError2 && error.code === "INSUFFICIENT_FUNDS") {
         return c.error({
           code: "INSUFFICIENT_FUNDS",
           message: `Insufficient funds to register. Required fee: ${eth(fee)} (${fee} wei). ${error.message}`,
@@ -6486,7 +6887,7 @@ members.command("heartbeat", {
         } : void 0
       );
     } catch (error) {
-      if (error instanceof TxError && error.code === "INSUFFICIENT_FUNDS") {
+      if (error instanceof TxError2 && error.code === "INSUFFICIENT_FUNDS") {
         return c.error({
           code: "INSUFFICIENT_FUNDS",
           message: `Insufficient funds for heartbeat. Required fee: ${eth(fee)} (${fee} wei). ${error.message}`,
@@ -6537,7 +6938,7 @@ members.command("renew", {
         } : void 0
       );
     } catch (error) {
-      if (error instanceof TxError && error.code === "INSUFFICIENT_FUNDS") {
+      if (error instanceof TxError2 && error.code === "INSUFFICIENT_FUNDS") {
         return c.error({
           code: "INSUFFICIENT_FUNDS",
           message: `Insufficient funds to renew. Required fee: ${eth(fee)} (${fee} wei). ${error.message}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spectratools/assembly-cli",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "description": "CLI for Assembly governance on Abstract (members, council, forum, proposals, and treasury).",
   "type": "module",
   "license": "MIT",
@@ -33,7 +33,7 @@
     "ox": "^0.14.0",
     "viem": "^2.47.0",
     "@spectratools/cli-shared": "0.1.1",
-    "@spectratools/tx-shared": "0.4.2"
+    "@spectratools/tx-shared": "0.4.3"
   },
   "devDependencies": {
     "typescript": "5.7.3",