Address bigz comments

Author: metaproph3t

programs/autocrat_v0/src/lib.rs

@@ -40,24 +40,24 @@ pub const MAX_BPS: u16 = 10_000;
 
 #[account]
 pub struct DAO {
+    // treasury needed even though DAO is PDA for this reason: https://solana.stackexchange.com/questions/7667/a-peculiar-problem-with-cpis
+    pub treasury_pda_bump: u8,
+    pub treasury: Pubkey,
     pub meta_mint: Pubkey,
     pub usdc_mint: Pubkey,
+    pub proposal_count: u32,
+    pub last_proposal_slot: u64,
     // the percentage, in basis points, the pass price needs to be above the
     // fail price in order for the proposal to pass
     pub pass_threshold_bps: u16,
-    pub proposal_count: u32,
     // for anti-spam, proposers need to burn some SOL. the amount that they need
     // to burn is inversely proportional to the amount of time that has passed
     // since the last proposal.
     // burn_amount = base_lamport_burn - (lamport_burn_decay_per_slot * slots_passed)
-    pub last_proposal_slot: u64,
     pub base_burn_lamports: u64,
     pub burn_decay_per_slot_lamports: u64,
     pub slots_per_proposal: u64,
     pub market_taker_fee: i64,
-    // treasury needed even though DAO is PDA for this reason: https://solana.stackexchange.com/questions/7667/a-peculiar-problem-with-cpis
-    pub treasury_pda_bump: u8,
-    pub treasury: Pubkey,
 }
 
 #[derive(Clone, Copy, AnchorSerialize, AnchorDeserialize, PartialEq, Eq)]
@@ -169,6 +169,10 @@ pub mod autocrat_v0 {
             openbook_pass_market.quote_lot_size == 100, // you can quote META in increments of a hundredth of a penny
             AutocratError::InvalidMarket
         );
+        require!(
+            openbook_pass_market.collect_fee_admin == dao.treasury,
+            AutocratError::InvalidMarket
+        );
 
         require!(
             openbook_fail_market.base_mint
@@ -204,6 +208,10 @@ pub mod autocrat_v0 {
             openbook_pass_market.quote_lot_size == 100,
             AutocratError::InvalidMarket
         );
+        require!(
+            openbook_fail_market.collect_fee_admin == dao.treasury,
+            AutocratError::InvalidMarket
+        );
         let clock = Clock::get()?;
 
         let openbook_twap_pass_market = &ctx.accounts.openbook_twap_pass_market;
@@ -380,45 +388,86 @@ pub mod autocrat_v0 {
         Ok(())
     }
 
-    pub fn set_pass_threshold_bps(ctx: Context<Auth>, pass_threshold_bps: u16) -> Result<()> {
-        let dao = &mut ctx.accounts.dao;
+    // pub fn set_pass_threshold_bps(ctx: Context<Auth>, pass_threshold_bps: u16) -> Result<()> {
+    //     let dao = &mut ctx.accounts.dao;
 
-        dao.pass_threshold_bps = pass_threshold_bps;
+    //     dao.pass_threshold_bps = pass_threshold_bps;
 
-        Ok(())
-    }
+    //     Ok(())
+    // }
 
-    pub fn set_base_burn_lamports(ctx: Context<Auth>, base_burn_lamports: u64) -> Result<()> {
-        let dao = &mut ctx.accounts.dao;
+    // pub fn set_base_burn_lamports(ctx: Context<Auth>, base_burn_lamports: u64) -> Result<()> {
+    //     let dao = &mut ctx.accounts.dao;
 
-        dao.base_burn_lamports = base_burn_lamports;
+    //     dao.base_burn_lamports = base_burn_lamports;
 
-        Ok(())
-    }
+    //     Ok(())
+    // }
 
-    pub fn set_burn_decay_per_slot_lamports(
-        ctx: Context<Auth>,
-        burn_decay_per_slot_lamports: u64,
-    ) -> Result<()> {
-        let dao = &mut ctx.accounts.dao;
+    // pub fn set_burn_decay_per_slot_lamports(
+    //     ctx: Context<Auth>,
+    //     burn_decay_per_slot_lamports: u64,
+    // ) -> Result<()> {
+    //     let dao = &mut ctx.accounts.dao;
 
-        dao.burn_decay_per_slot_lamports = burn_decay_per_slot_lamports;
+    //     dao.burn_decay_per_slot_lamports = burn_decay_per_slot_lamports;
 
-        Ok(())
-    }
+    //     Ok(())
+    // }
 
-    pub fn set_slots_per_proposal(ctx: Context<Auth>, slots_per_proposal: u64) -> Result<()> {
-        let dao = &mut ctx.accounts.dao;
+    // pub fn set_slots_per_proposal(ctx: Context<Auth>, slots_per_proposal: u64) -> Result<()> {
+    //     let dao = &mut ctx.accounts.dao;
 
-        dao.slots_per_proposal = slots_per_proposal;
+    //     dao.slots_per_proposal = slots_per_proposal;
 
-        Ok(())
+    //     Ok(())
+    // }
+
+    // pub fn set_market_taker_fee(ctx: Context<Auth>, market_taker_fee: i64) -> Result<()> {
+    //     let dao = &mut ctx.accounts.dao;
+
+    //     dao.market_taker_fee = market_taker_fee;
+
+    //     Ok(())
+    // }
+
+    #[derive(Clone, Copy, AnchorSerialize, AnchorDeserialize)]
+    pub enum Test {
+        Boo,
+        Foo,
     }
 
-    pub fn set_market_taker_fee(ctx: Context<Auth>, market_taker_fee: i64) -> Result<()> {
+    #[derive(Clone, Copy, AnchorSerialize, AnchorDeserialize, Eq, PartialEq, Debug)]
+    pub struct Testy {
+        pub thing: Option<u64>,
+    }
+
+
+    pub fn update_dao(
+        ctx: Context<UpdateDao>,
+        dao_params: UpdateDaoParams,
+    ) -> Result<()> {
         let dao = &mut ctx.accounts.dao;
 
-        dao.market_taker_fee = market_taker_fee;
+        if let Some(pass_threshold_bps) = dao_params.pass_threshold_bps {
+            dao.pass_threshold_bps = pass_threshold_bps;
+        }
+
+        if let Some(base_burn_lamports) = dao_params.base_burn_lamports {
+            dao.base_burn_lamports = base_burn_lamports;
+        }
+
+        if let Some(burn_decay_per_slot_lamports) = dao_params.burn_decay_per_slot_lamports {
+            dao.burn_decay_per_slot_lamports = burn_decay_per_slot_lamports;
+        }
+
+        if let Some(slots_per_proposal) = dao_params.slots_per_proposal {
+            dao.slots_per_proposal = slots_per_proposal;
+        }
+
+        if let Some(market_taker_fee) = dao_params.market_taker_fee {
+            dao.market_taker_fee = market_taker_fee;
+        }
 
         Ok(())
     }
@@ -513,11 +562,24 @@ pub struct FinalizeProposal<'info> {
     pub dao_treasury: UncheckedAccount<'info>,
 }
 
+#[derive(Debug, Clone, Copy, AnchorSerialize, AnchorDeserialize, PartialEq, Eq)]
+pub struct UpdateDaoParams {
+    pub pass_threshold_bps: Option<u16>,
+    pub base_burn_lamports: Option<u64>,
+    pub burn_decay_per_slot_lamports: Option<u64>,
+    pub slots_per_proposal: Option<u64>,
+    pub market_taker_fee: Option<i64>,
+}
+
 #[derive(Accounts)]
-pub struct Auth<'info> {
+pub struct UpdateDao<'info> {
     #[account(mut)]
     pub dao: Account<'info, DAO>,
     /// CHECK: never read
+    #[account(
+        seeds = [dao.key().as_ref()],
+        bump = dao.treasury_pda_bump,
+    )]
     pub dao_treasury: Signer<'info>,
 }
 

tests/autocratV0.ts

@@ -219,8 +219,14 @@ describe("autocrat_v0", async function () {
           isWritable: true,
         },
       ];
-      const data = autocrat.coder.instruction.encode("set_pass_threshold_bps", {
-        passThresholdBps: 1000,
+      const data = autocrat.coder.instruction.encode("update_dao", {
+        daoParams: {
+          passThresholdBps: 500,
+          baseBurnLamports: null,
+          burnDecayPerSlotLamports: null,
+          slotsPerProposal: null,
+          marketTakerFee: null,
+        }
       });
       const instruction = {
         programId: autocrat.programId,
@@ -1136,7 +1142,7 @@ describe("autocrat_v0", async function () {
           daoTreasury,
         })
         .remainingAccounts(
-          autocrat.instruction.setPassThresholdBps
+          autocrat.instruction.updateDao
             .accounts({
               dao,
               daoTreasury,
@@ -1447,7 +1453,8 @@ async function initializeProposal(
     null,
     openbookTwapPassMarket,
     { confFilter: 0.1, maxStalenessSlots: 100 },
-    openbookPassMarketKP
+    openbookPassMarketKP,
+    daoTreasury
   );
 
   await openbookTwap.methods
@@ -1484,7 +1491,8 @@ async function initializeProposal(
     null,
     openbookTwapFailMarket,
     { confFilter: 0.1, maxStalenessSlots: 100 },
-    openbookFailMarketKP
+    openbookFailMarketKP,
+    daoTreasury
   );
   await openbookTwap.methods
     .createTwapMarket(new BN(1000))