Continuation fixes (#441)

* allow init of price_based performance package with min unlock start in past

* ensure dao's CURRENT proposal duration in seconds is applied to launched proposal's duration

* prevent initialization of launch that has multiple same spending limit members, or no spending limit members

* handle single aggregator wrap in price based performance package unlocks

* add proper wrapping arithmetic instead of saturating to TWAP aggregator calculations and projections

* ppv2 - futarchy oracle - add check for at least one oracle update after twap_start_timestamp

* mark squads vault as writable signer to match Squads SDK payer semantics

* remove event_cpi

* launchpad v6 & v7 - additional constraints

* launchpad v6 - proper time boundary

* ppv2 - proper staleness checks for change requests

* remove proposer_type in favor of direct comparison

* ppv2 - add test for stale change request (targets old PP)

* remove unused accounts

* remove mut from accounts that are not mutated

* nit - update comment with correct amount of days

* ppv2 - remove start_value from CliffLinear reward function

* ppv2 - use specific require macros where possible

* bump sdk, release

* unstake_from_proposal should include init_if_needed for staker base account

* bump sdk version

Author: pileks

programs/bid_wall/src/instructions/close_bid_wall.rs

@@ -19,9 +19,6 @@ pub struct CloseBidWall<'info> {
     )]
     pub bid_wall: Account<'info, BidWall>,
 
-    #[account(mut)]
-    pub payer: Signer<'info>,
-
     /// CHECK: used for constraints
     #[account(mut, address = bid_wall.authority)]
     pub authority: UncheckedAccount<'info>,

programs/bid_wall/src/instructions/collect_fees.rs

@@ -34,7 +34,6 @@ pub struct CollectFees<'info> {
     pub quote_mint: Account<'info, Mint>,
 
     pub token_program: Program<'info, Token>,
-    pub system_program: Program<'info, System>,
 }
 
 impl CollectFees<'_> {

programs/bid_wall/src/instructions/sell_tokens.rs

@@ -20,7 +20,6 @@ pub struct SellTokens<'info> {
     #[account(mut, has_one = base_mint)]
     pub bid_wall: Account<'info, BidWall>,
 
-    #[account(mut)]
     pub user: Signer<'info>,
 
     #[account(mut, associated_token::mint = base_mint, associated_token::authority = user)]
@@ -46,7 +45,6 @@ pub struct SellTokens<'info> {
     pub quote_mint: Account<'info, Mint>,
 
     pub token_program: Program<'info, Token>,
-    pub system_program: Program<'info, System>,
 }
 
 // User sells tokens into the bid wall at the initial NAV per token, adjusted for treasury balance changes.

programs/futarchy/src/instructions/admin_cancel_proposal.rs

@@ -64,7 +64,6 @@ pub struct AdminCancelProposal<'info> {
     #[account(mut, address = base_vault.underlying_token_account)]
     pub base_vault_underlying_token_account: Box<Account<'info, TokenAccount>>,
 
-    #[account(mut)]
     pub admin: Signer<'info>,
 }
 

programs/futarchy/src/instructions/collect_meteora_damm_fees.rs

@@ -42,7 +42,7 @@ pub struct CollectMeteoraDammFees<'info> {
     #[account(mut, seeds = [squads_multisig_program::SEED_PREFIX, squads_multisig_program::SEED_MULTISIG, dao.key().as_ref()], bump, seeds::program = squads_program)]
     pub squads_multisig: Account<'info, squads_multisig_program::Multisig>,
     /// CHECK: signer for the squads transaction, checked by squads program
-    #[account(seeds = [squads_multisig_program::SEED_PREFIX, squads_multisig.key().as_ref(), squads_multisig_program::SEED_VAULT, 0_u8.to_le_bytes().as_ref()], bump, seeds::program = squads_program)]
+    #[account(mut, seeds = [squads_multisig_program::SEED_PREFIX, squads_multisig.key().as_ref(), squads_multisig_program::SEED_VAULT, 0_u8.to_le_bytes().as_ref()], bump, seeds::program = squads_program)]
     pub squads_multisig_vault: UncheckedAccount<'info>,
     /// CHECK: squads transaction, initialized by squads multisig program, checked by squads multisig program
     #[account(mut)]
@@ -411,9 +411,8 @@ fn compile_transaction_message(
     // Track account metadata: (is_signer, is_writable)
     let mut key_meta_map: BTreeMap<Pubkey, (bool, bool)> = BTreeMap::new();
 
-    // Add vault as a signer (it will sign the vault transaction)
-    // Writability is determined by whether it appears as writable in instruction accounts
-    key_meta_map.insert(*vault_key, (true, false));
+    // Add vault as a writable signer (matches Squads SDK payer semantics)
+    key_meta_map.insert(*vault_key, (true, true));
 
     // Collect all accounts from instructions, merging their flags with OR
     for ix in instructions {
@@ -435,14 +434,14 @@ fn compile_transaction_message(
 
     for (pubkey, (is_signer, is_writable)) in &key_meta_map {
         if *is_signer && *is_writable {
-            writable_signers.push(*pubkey);
-        } else if *is_signer {
-            // Vault key should be first among readonly signers
+            // Vault key should be first among writable signers (matches Squads SDK)
             if *pubkey == *vault_key {
-                readonly_signers.insert(0, *pubkey);
+                writable_signers.insert(0, *pubkey);
             } else {
-                readonly_signers.push(*pubkey);
+                writable_signers.push(*pubkey);
             }
+        } else if *is_signer {
+            readonly_signers.push(*pubkey);
         } else if *is_writable {
             writable_non_signers.push(*pubkey);
         } else {

programs/futarchy/src/instructions/execute_spending_limit_change.rs

@@ -4,7 +4,6 @@ use anchor_lang::Discriminator;
 use squads_multisig_program::program::SquadsMultisigProgram;
 
 #[derive(Accounts)]
-#[event_cpi]
 pub struct ExecuteSpendingLimitChange<'info> {
     #[account(
         mut, has_one = dao, has_one = squads_proposal,
@@ -40,8 +39,6 @@ impl<'info, 'c: 'info> ExecuteSpendingLimitChange<'info> {
             squads_multisig,
             squads_multisig_program,
             vault_transaction,
-            event_authority: _,
-            program: _,
         } = ctx.accounts;
 
         let message = &vault_transaction.message;

programs/futarchy/src/instructions/launch_proposal.rs

@@ -157,6 +157,8 @@ impl LaunchProposal<'_> {
         // Update proposal state to Pending and set timestamp enqueued
         proposal.state = ProposalState::Pending;
         proposal.timestamp_enqueued = clock.unix_timestamp;
+        // Additionally, set the duration once more in case it was updated since the proposal was created
+        proposal.duration_in_seconds = dao.seconds_per_proposal;
 
         dao.seq_num += 1;
 

programs/futarchy/src/instructions/stake_to_proposal.rs

@@ -37,7 +37,6 @@ pub struct StakeToProposal<'info> {
     #[account(mut)]
     pub payer: Signer<'info>,
     pub token_program: Program<'info, Token>,
-    pub associated_token_program: Program<'info, AssociatedToken>,
     pub system_program: Program<'info, System>,
 }
 
@@ -71,7 +70,6 @@ impl StakeToProposal<'_> {
             staker,
             payer: _,
             token_program,
-            associated_token_program: _,
             system_program: _,
             event_authority: _,
             program: _,

programs/futarchy/src/instructions/unstake_from_proposal.rs

@@ -9,19 +9,26 @@ pub struct UnstakeFromProposalParams {
 #[instruction(args: UnstakeFromProposalParams)]
 #[event_cpi]
 pub struct UnstakeFromProposal<'info> {
-    #[account(mut)]
+    #[account(
+        mut,
+        has_one = dao,
+    )]
     pub proposal: Box<Account<'info, Proposal>>,
-    #[account(mut)]
-    pub dao: Box<Account<'info, Dao>>,
     #[account(
         mut,
-        associated_token::mint = dao.base_mint,
+        has_one = base_mint,
+    )]
+    pub dao: Box<Account<'info, Dao>>,
+    #[account(
+        init_if_needed,
+        payer = staker,
+        associated_token::mint = base_mint,
         associated_token::authority = staker,
     )]
     pub staker_base_account: Box<Account<'info, TokenAccount>>,
     #[account(
         mut,
-        associated_token::mint = dao.base_mint,
+        associated_token::mint = base_mint,
         associated_token::authority = proposal,
     )]
     pub proposal_base_account: Box<Account<'info, TokenAccount>>,
@@ -31,8 +38,12 @@ pub struct UnstakeFromProposal<'info> {
         bump = stake_account.bump,
     )]
     pub stake_account: Box<Account<'info, StakeAccount>>,
+    #[account(address = dao.base_mint)]
+    pub base_mint: Account<'info, Mint>,
+    #[account(mut)]
     pub staker: Signer<'info>,
     pub token_program: Program<'info, Token>,
+    pub system_program: Program<'info, System>,
     pub associated_token_program: Program<'info, AssociatedToken>,
 }
 
@@ -61,9 +72,11 @@ impl UnstakeFromProposal<'_> {
             stake_account,
             staker,
             token_program,
-            associated_token_program: _,
             event_authority: _,
             program: _,
+            system_program: _,
+            associated_token_program: _,
+            base_mint: _,
         } = ctx.accounts;
 
         let UnstakeFromProposalParams { amount } = params;

programs/futarchy/src/state/futarchy_amm.rs

@@ -272,7 +272,7 @@ pub struct TwapOracle {
     ///
     /// Assuming latest observations are as big as possible (u64::MAX * 1e12),
     /// we can store 18 million seconds worth of observations, which turns out to
-    /// be ~208 days.
+    /// be ~213 days.
     ///
     /// Assuming that latest observations are 100x smaller than they could theoretically
     /// be, we can store ~57 years worth of them. Even this is a very
@@ -404,9 +404,9 @@ impl Pool {
                 .try_into()
                 .unwrap();
 
-            // if this saturates, the aggregator will wrap back to 0, so this value doesn't
-            // really matter. we just can't panic.
-            let weighted_observation = last_observation.saturating_mul(time_difference);
+            // wrapping_mul ensures we don't panic in case of overflow
+            // Theoretically, wrapping can occur, but it's astronomically unlikely
+            let weighted_observation = last_observation.wrapping_mul(time_difference);
 
             oracle.aggregator.wrapping_add(weighted_observation)
         };
@@ -462,7 +462,9 @@ impl Pool {
 
         // include the final interval that hasn't been accumulated yet
         let final_interval = (current_timestamp - self.oracle.last_updated_timestamp) as u128;
-        let final_contribution = self.oracle.last_observation.saturating_mul(final_interval);
+        // wrapping_mul ensures we don't panic in case of overflow
+        // Theoretically, wrapping can occur, but it's astronomically unlikely
+        let final_contribution = self.oracle.last_observation.wrapping_mul(final_interval);
         let total_aggregator = self.oracle.aggregator.wrapping_add(final_contribution);
 
         Ok(total_aggregator / seconds_passed)