Mini-instructions (MVP)

Anchor.toml

@@ -47,7 +47,6 @@ v04-initialize-proposal = "yarn run tsx scripts/v0.4/initializeProposal.ts"
 v05-execute-proposal = "yarn run tsx scripts/v0.5/executeProposal.ts"
 v06-launch = "yarn run tsx scripts/v0.6/launch.ts"
 claim-launch = "yarn run tsx scripts/v0.6/claimAllLaunch.ts"
-v06-execute-proposal = "yarn run tsx scripts/v0.6/executeProposal.ts"
 v06-execute-general-proposal = "yarn run tsx scripts/v0.6/executeGeneralProposal.ts"
 v06-dump-daos-proposals = "yarn run tsx scripts/v0.6/dumpDaosProposals.ts"
 v06-migrate-daos-proposals = "yarn run tsx scripts/v0.6/migrateDaosProposals.ts"

programs/futarchy/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "futarchy"
-version = "0.6.1"
+version = "0.6.2"
 description = "SVM-based program for running futarchy"
 edition = "2021"
 
@@ -20,6 +20,8 @@ production = []
 anchor-lang = "=0.29.0"
 anchor-spl = "=0.29.0"
 solana-security-txt = "=1.1.1"
+spl-memo = { version = "=4.0.0", features = ["no-entrypoint"] }
 conditional_vault = { path = "../conditional_vault", features = ["cpi"] }
 squads-multisig-program = { git = "https://github.com/Squads-Protocol/v4", package = "squads-multisig-program", rev = "6d5235da621a2e9b7379ea358e48760e981053be", features = ["cpi"] }
 damm_v2_cpi = { path = "../damm_v2_cpi", features = ["cpi"] }
+mint_governor = { path = "../mint_governor", features = ["cpi"] }

programs/futarchy/src/error.rs

@@ -90,4 +90,46 @@ pub enum FutarchyError {
     InvalidSpendingLimitMint,
     #[msg("No active optimistic proposal")]
     NoActiveOptimisticProposal,
+    #[msg("This DAO has been liquidated")]
+    DaoLiquidated,
+    #[msg("A proposal of this kind finalized recently, so the cooldown must elapse first")]
+    ProposalKindCooldownActive,
+    #[msg("The DAO has no spending limit")]
+    NoSpendingLimit,
+    #[msg("Amount exceeds the cap of 3x the monthly spending limit")]
+    SpendCapExceeded,
+    #[msg("The base mint's authority is neither the treasury vault nor a mint governor")]
+    UnknownMintAuthority,
+    #[msg("This proposal kind must be team-sponsored before it can launch")]
+    ProposalNotTeamSponsored,
+    #[msg("The spending limit record hasn't changed, so there is nothing to sync")]
+    SpendingLimitNotDirty,
+    #[msg("Wrong proposal kind for this instruction")]
+    InvalidProposalKind,
+    #[msg("This DAO has already been liquidated")]
+    AlreadyLiquidated,
+    #[msg("A spending limit can have at most 10 members")]
+    TooManySpendingLimitMembers,
+    #[msg("Invalid liquidator")]
+    InvalidLiquidator,
+    #[msg("Pass threshold must be between -99.99% and 99.99%")]
+    InvalidProposalPassThreshold,
+    #[msg("A proposal params update must set at least one field")]
+    EmptyProposalParamsUpdate,
+    #[msg("Buyback amount exceeds 25% of the treasury")]
+    BuybackCapExceeded,
+    #[msg("The total must be an exact multiple of the non-zero per-cycle amount, at least twice over")]
+    InvalidBuybackAmount,
+    #[msg("Cycle frequency must be between 60 seconds and 1 year")]
+    InvalidBuybackCycleFrequency,
+    #[msg("Start delay must be at most 30 days")]
+    InvalidBuybackStartDelay,
+    #[msg("min_price must be no greater than max_price")]
+    InvalidBuybackPriceBand,
+    #[msg("A treasury account is neither a vault-owned quote account nor the treasury's AMM position")]
+    InvalidTreasuryAccount,
+    #[msg("Treasury accounts must be in strictly ascending key order")]
+    TreasuryAccountsNotSorted,
+    #[msg("This proposal kind's launch takes no extra accounts")]
+    UnexpectedLaunchAccounts,
 }

programs/futarchy/src/events.rs

@@ -1,6 +1,6 @@
 use anchor_lang::prelude::*;
 
-use crate::{FutarchyAmm, InitialSpendingLimit, Market, ProposalState, SwapType};
+use crate::{FutarchyAmm, InitialSpendingLimit, Market, ProposalAction, ProposalState, SwapType};
 
 #[derive(AnchorSerialize, AnchorDeserialize)]
 pub struct CommonFields {
@@ -87,6 +87,7 @@ pub struct InitializeProposalEvent {
     pub squads_proposal: Pubkey,
     pub squads_multisig: Pubkey,
     pub squads_multisig_vault: Pubkey,
+    pub action: ProposalAction,
 }
 
 #[event]
@@ -200,6 +201,18 @@ pub struct RemoveProposalEvent {
     pub admin: Pubkey,
 }
 
+#[event]
+pub struct AdminUpdateProposalParamsEvent {
+    pub common: CommonFields,
+    pub dao: Pubkey,
+    pub proposal: Pubkey,
+    pub admin: Pubkey,
+    pub old_duration_in_seconds: u32,
+    pub new_duration_in_seconds: u32,
+    pub old_pass_threshold_bps: i16,
+    pub new_pass_threshold_bps: i16,
+}
+
 #[event]
 pub struct AdminCancelProposalEvent {
     pub common: CommonFields,
@@ -233,23 +246,30 @@ pub struct AdminFixPositionAuthorityEvent {
 }
 
 #[event]
-pub struct InitiateVaultSpendOptimisticProposalEvent {
+pub struct SetSpendingLimitEvent {
     pub common: CommonFields,
     pub dao: Pubkey,
-    pub proposer: Pubkey,
-    pub squads_proposal: Pubkey,
-    pub squads_multisig: Pubkey,
-    pub squads_multisig_vault: Pubkey,
-    pub amount: u64,
-    pub recipient: Pubkey,
-    pub dao_quote_vault_account: Pubkey,
-    pub recipient_quote_account: Pubkey,
-    pub enqueued_timestamp: i64,
+    pub config: Option<InitialSpendingLimit>,
 }
 
 #[event]
-pub struct FinalizeOptimisticProposalEvent {
+pub struct SyncSpendingLimitEvent {
     pub common: CommonFields,
     pub dao: Pubkey,
-    pub squads_proposal: Pubkey,
+    /// The Squads-side SpendingLimit PDA the record was projected onto.
+    pub spending_limit: Pubkey,
+    /// The projected record — the Squads-side end-state after the sync.
+    /// `None` = no limit (removed or never existed).
+    pub config: Option<InitialSpendingLimit>,
+}
+
+#[event]
+pub struct ApplyLiquidationEvent {
+    pub common: CommonFields,
+    pub dao: Pubkey,
+    pub proposal: Pubkey,
+    pub liquidator: Pubkey,
+    pub base_swept: u64,
+    pub quote_swept: u64,
+    pub post_amm_state: FutarchyAmm,
 }

programs/futarchy/src/instructions/admin_cancel_proposal.rs

@@ -69,6 +69,14 @@ pub struct AdminCancelProposal<'info> {
 
 impl AdminCancelProposal<'_> {
     pub fn validate(&self) -> Result<()> {
+        // Unblockable proposals are censorship-proof once live: nobody, including
+        // the council, can cancel them. Reads the create-time snapshot so a
+        // live proposal keeps the flag it launched with.
+        require!(
+            self.proposal.council_can_block,
+            FutarchyError::InvalidProposalKind
+        );
+
         #[cfg(feature = "production")]
         require_keys_eq!(self.admin.key(), admin::ID, FutarchyError::InvalidAdmin);
 

programs/futarchy/src/instructions/admin_enqueue_multisig_proposal_approval.rs

@@ -62,17 +62,28 @@ pub struct AdminEnqueueMultisigProposalApproval<'info> {
 
 impl AdminEnqueueMultisigProposalApproval<'_> {
     pub fn validate(&self, _args: &AdminEnqueueMultisigProposalApprovalArgs) -> Result<()> {
-        #[cfg(feature = "production")]
-        require_keys_eq!(self.admin.key(), admin::ID, FutarchyError::InvalidAdmin);
+        // On a liquidated DAO the liquidator replaces the admin id as the
+        // required signer. Enqueueing is the only capability the liquidator
+        // gains: the approve leg stays permissionless and execution is
+        // ordinary top-level Squads execution.
+        match self.dao.liquidator {
+            Some(liquidator) => {
+                require_keys_eq!(
+                    self.admin.key(),
+                    liquidator,
+                    FutarchyError::InvalidLiquidator
+                );
+            }
+            None => {
+                #[cfg(feature = "production")]
+                require_keys_eq!(self.admin.key(), admin::ID, FutarchyError::InvalidAdmin);
+            }
+        }
 
         if !matches!(self.dao.amm.state, PoolState::Spot { .. }) {
             return Err(FutarchyError::PoolNotInSpotState.into());
         }
 
-        if self.dao.optimistic_proposal.is_some() {
-            return Err(FutarchyError::ActiveOptimisticProposalAlreadyEnqueued.into());
-        }
-
         validate_squads_proposal(
             &self.squads_multisig_proposal,
             &self.squads_multisig,

programs/futarchy/src/instructions/admin_execute_multisig_proposal.rs

@@ -67,10 +67,6 @@ impl<'info, 'c: 'info> AdminExecuteMultisigProposal<'info> {
             return Err(FutarchyError::PoolNotInSpotState.into());
         }
 
-        if self.dao.optimistic_proposal.is_some() {
-            return Err(FutarchyError::ActiveOptimisticProposalAlreadyEnqueued.into());
-        }
-
         Ok(())
     }
 

programs/futarchy/src/instructions/admin_update_proposal_params.rs

@@ -0,0 +1,110 @@
+use super::*;
+
+mod admin {
+    use anchor_lang::prelude::declare_id;
+
+    // MetaDAO ops multisig — the same signer as the approval enqueue
+    declare_id!("6awyHMshBGVjJ3ozdSJdyyDE1CTAXUwrpNMaRGMsb4sf");
+}
+
+#[derive(Debug, Clone, AnchorSerialize, AnchorDeserialize)]
+pub struct AdminUpdateProposalParamsArgs {
+    pub duration_in_seconds: Option<u32>,
+    pub pass_threshold_bps: Option<i16>,
+}
+
+#[derive(Accounts)]
+#[event_cpi]
+pub struct AdminUpdateProposalParams<'info> {
+    #[account(mut)]
+    pub dao: Box<Account<'info, Dao>>,
+
+    #[account(mut, has_one = dao)]
+    pub proposal: Box<Account<'info, Proposal>>,
+
+    pub admin: Signer<'info>,
+}
+
+impl AdminUpdateProposalParams<'_> {
+    pub fn validate(&self, args: &AdminUpdateProposalParamsArgs) -> Result<()> {
+        #[cfg(feature = "production")]
+        require_keys_eq!(self.admin.key(), admin::ID, FutarchyError::InvalidAdmin);
+
+        require!(self.dao.liquidator.is_none(), FutarchyError::DaoLiquidated);
+
+        // Only arbitrary proposals can be modified
+        require!(
+            matches!(self.proposal.action, ProposalAction::ExecuteArbitrary),
+            FutarchyError::InvalidProposalKind
+        );
+
+        // A live proposal's terms never move: the snapshot exists so later
+        // changes can't shift the goalposts under it
+        require!(
+            matches!(self.proposal.state, ProposalState::Draft { .. }),
+            FutarchyError::ProposalNotInDraftState
+        );
+
+        // An admin transaction that does nothing should fail
+        require!(
+            args.duration_in_seconds.is_some() || args.pass_threshold_bps.is_some(),
+            FutarchyError::EmptyProposalParamsUpdate
+        );
+
+        if let Some(duration_in_seconds) = args.duration_in_seconds {
+            // The same comparison `launch_proposal` makes
+            require_gt!(
+                duration_in_seconds,
+                self.proposal.action.params().twap_start_delay_seconds,
+                FutarchyError::ProposalDurationTooShort
+            );
+        }
+
+        if let Some(pass_threshold_bps) = args.pass_threshold_bps {
+            require_gte!(
+                MAX_PROPOSAL_PASS_THRESHOLD_BPS,
+                pass_threshold_bps,
+                FutarchyError::InvalidProposalPassThreshold
+            );
+            require_gte!(
+                pass_threshold_bps,
+                MIN_PROPOSAL_PASS_THRESHOLD_BPS,
+                FutarchyError::InvalidProposalPassThreshold
+            );
+        }
+
+        Ok(())
+    }
+
+    pub fn handle(ctx: Context<Self>, args: AdminUpdateProposalParamsArgs) -> Result<()> {
+        let proposal = &mut ctx.accounts.proposal;
+        let dao = &mut ctx.accounts.dao;
+
+        let old_duration_in_seconds = proposal.duration_in_seconds;
+        let old_pass_threshold_bps = proposal.pass_threshold_bps;
+
+        if let Some(duration_in_seconds) = args.duration_in_seconds {
+            proposal.duration_in_seconds = duration_in_seconds;
+        }
+
+        if let Some(pass_threshold_bps) = args.pass_threshold_bps {
+            proposal.pass_threshold_bps = pass_threshold_bps;
+        }
+
+        dao.seq_num += 1;
+        let clock = Clock::get()?;
+
+        emit_cpi!(AdminUpdateProposalParamsEvent {
+            common: CommonFields::new(&clock, dao.seq_num),
+            dao: dao.key(),
+            proposal: proposal.key(),
+            admin: ctx.accounts.admin.key(),
+            old_duration_in_seconds,
+            new_duration_in_seconds: proposal.duration_in_seconds,
+            old_pass_threshold_bps,
+            new_pass_threshold_bps: proposal.pass_threshold_bps,
+        });
+
+        Ok(())
+    }
+}