(3) Settler: Proposal Lifecycle

packages/svm/programs/settler/src/instructions/add_instructions_to_proposal.rs

@@ -0,0 +1,45 @@
+use anchor_lang::prelude::*;
+
+use crate::{
+    errors::SettlerError,
+    state::{Proposal, ProposalInstruction},
+};
+
+#[derive(Accounts)]
+#[instruction(more_instructions: Vec<ProposalInstruction>)]
+pub struct AddInstructionsToProposal<'info> {
+    #[account(mut)]
+    pub creator: Signer<'info>,
+
+    #[account(
+        mut,
+        realloc = Proposal::extended_size(proposal.to_account_info().data_len(), &more_instructions)?,
+        realloc::payer = creator,
+        realloc::zero = true,
+        has_one = creator @ SettlerError::IncorrectProposalCreator
+    )]
+    // Any proposal
+    pub proposal: Box<Account<'info, Proposal>>,
+
+    pub system_program: Program<'info, System>,
+}
+
+pub fn add_instructions_to_proposal(
+    ctx: Context<AddInstructionsToProposal>,
+    more_instructions: Vec<ProposalInstruction>,
+    finalize: bool,
+) -> Result<()> {
+    let now = Clock::get()?.unix_timestamp as u64;
+    let proposal = &mut ctx.accounts.proposal;
+
+    require!(proposal.deadline > now, SettlerError::ProposalIsExpired);
+    require!(!proposal.is_final, SettlerError::ProposalIsFinal);
+
+    proposal.instructions.extend_from_slice(&more_instructions);
+
+    if finalize {
+        proposal.is_final = true;
+    }
+
+    Ok(())
+}

packages/svm/programs/settler/src/instructions/claim_stale_intent.rs

@@ -11,17 +11,11 @@ pub struct ClaimStaleIntent<'info> {
         mut,
         close = creator,
         has_one = creator @ SettlerError::IncorrectIntentCreator,
+        constraint = Clock::get()?.unix_timestamp as u64 > intent.deadline @ SettlerError::IntentNotYetExpired
     )]
     pub intent: Box<Account<'info, Intent>>,
 }
 
-pub fn claim_stale_intent(ctx: Context<ClaimStaleIntent>) -> Result<()> {
-    let now = Clock::get()?.unix_timestamp as u64;
-
-    require!(
-        ctx.accounts.intent.deadline < now,
-        SettlerError::IntentNotYetExpired
-    );
-
+pub fn claim_stale_intent(_ctx: Context<ClaimStaleIntent>) -> Result<()> {
     Ok(())
 }

packages/svm/programs/settler/src/instructions/claim_stale_proposal.rs

@@ -0,0 +1,21 @@
+use anchor_lang::prelude::*;
+
+use crate::{errors::SettlerError, state::Proposal};
+
+#[derive(Accounts)]
+pub struct ClaimStaleProposal<'info> {
+    #[account(mut)]
+    pub creator: Signer<'info>,
+
+    #[account(
+        mut,
+        close = creator,
+        has_one = creator @ SettlerError::IncorrectProposalCreator,
+        constraint = Clock::get()?.unix_timestamp as u64 > proposal.deadline @ SettlerError::ProposalNotYetExpired
+    )]
+    pub proposal: Box<Account<'info, Proposal>>,
+}
+
+pub fn claim_stale_proposal(_ctx: Context<ClaimStaleProposal>) -> Result<()> {
+    Ok(())
+}

packages/svm/programs/settler/src/instructions/create_proposal.rs

@@ -0,0 +1,95 @@
+use anchor_lang::prelude::*;
+
+use crate::{
+    controller::{self, accounts::EntityRegistry, types::EntityType},
+    errors::SettlerError,
+    state::{Intent, Proposal, ProposalInstruction},
+    types::TokenFee,
+};
+
+#[derive(Accounts)]
+#[instruction(instructions: Vec<ProposalInstruction>, fees: Vec<TokenFee>,)]
+pub struct CreateProposal<'info> {
+    #[account(mut)]
+    pub solver: Signer<'info>,
+
+    #[account(
+        seeds = [b"entity-registry", &[EntityType::Solver as u8 + 1], solver.key().as_ref()],
+        bump = solver_registry.bump,
+        seeds::program = controller::ID,
+    )]
+    pub solver_registry: Box<Account<'info, EntityRegistry>>,
+
+    /// Any intent
+    pub intent: Box<Account<'info, Intent>>,
+
+    #[account(
+        seeds = [b"fulfilled-intent", intent.hash.as_ref()],
+        bump
+    )]
+    /// This PDA must be uninitialized (checked by SystemAccount type)
+    pub fulfilled_intent: SystemAccount<'info>,
+
+    #[account(
+        init,
+        seeds = [b"proposal", intent.key().as_ref(), solver.key().as_ref()],
+        bump,
+        payer = solver,
+        space = Proposal::total_size(&instructions, fees.len())?
+    )]
+    pub proposal: Box<Account<'info, Proposal>>,
+
+    pub system_program: Program<'info, System>,
+}
+
+pub fn create_proposal(
+    ctx: Context<CreateProposal>,
+    instructions: Vec<ProposalInstruction>,
+    fees: Vec<TokenFee>,
+    deadline: u64,
+    is_final: bool,
+) -> Result<()> {
+    let now = Clock::get()?.unix_timestamp as u64;
+    let intent = &ctx.accounts.intent;
+
+    require!(deadline > now, SettlerError::DeadlineIsInThePast);
+    require!(intent.deadline > now, SettlerError::IntentIsExpired);
+    require!(
+        deadline <= intent.deadline,
+        SettlerError::ProposalDeadlineExceedsIntentDeadline
+    );
+    require!(
+        intent.validators.len() >= intent.min_validations as usize,
+        SettlerError::InsufficientIntentValidations
+    );
+    require!(intent.is_final, SettlerError::IntentIsNotFinal);
+    require!(
+        fees.len() == intent.max_fees.len(),
+        SettlerError::InvalidFeeMint
+    );
+
+    fees.iter()
+        .zip(&intent.max_fees)
+        .try_for_each(|(fee, max_fee)| {
+            require_keys_eq!(fee.mint, max_fee.mint, SettlerError::InvalidFeeMint);
+            require_gte!(
+                max_fee.amount,
+                fee.amount,
+                SettlerError::FeeAmountExceedsMaxFee
+            );
+            Ok(())
+        })?;
+
+    let proposal = &mut ctx.accounts.proposal;
+
+    proposal.intent = intent.key();
+    proposal.creator = ctx.accounts.solver.key();
+    proposal.deadline = deadline;
+    proposal.is_final = is_final;
+    proposal.is_signed = false;
+    proposal.instructions = instructions;
+    proposal.fees = fees;
+    proposal.bump = ctx.bumps.proposal;
+
+    Ok(())
+}

packages/svm/programs/settler/src/instructions/execute_proposal.rs

@@ -0,0 +1,84 @@
+use anchor_lang::prelude::*;
+
+use crate::{
+    controller::{self, accounts::EntityRegistry, types::EntityType},
+    errors::SettlerError,
+    state::{FulfilledIntent, Intent, Proposal},
+    types::IntentEvent,
+};
+
+#[derive(Accounts)]
+pub struct ExecuteProposal<'info> {
+    #[account(mut)]
+    pub solver: Signer<'info>,
+
+    #[account(
+        seeds = [b"entity-registry", &[EntityType::Solver as u8 + 1], solver.key().as_ref()],
+        bump = solver_registry.bump,
+        seeds::program = controller::ID,
+    )]
+    pub solver_registry: Box<Account<'info, EntityRegistry>>,
+
+    /// CHECK: account defined in proposal
+    #[account(mut)]
+    pub proposal_creator: UncheckedAccount<'info>,
+
+    #[account(
+        mut,
+        has_one = intent @ SettlerError::IncorrectIntentForProposal,
+        constraint = proposal.creator == proposal_creator.key() @ SettlerError::IncorrectProposalCreator,
+        constraint = proposal.is_signed @ SettlerError::ProposalIsNotSigned,
+        close = proposal_creator
+    )]
+    pub proposal: Box<Account<'info, Proposal>>,
+
+    /// CHECK: account defined in intent
+    #[account(mut)]
+    pub intent_creator: UncheckedAccount<'info>,
+
+    #[account(
+        mut,
+        constraint = intent.creator == intent_creator.key() @ SettlerError::IncorrectIntentCreator,
+        close = intent_creator
+    )]
+    pub intent: Box<Account<'info, Intent>>,
+
+    #[account(
+        init,
+        seeds = [b"fulfilled-intent", intent.hash.as_ref()],
+        bump,
+        space = 8 + FulfilledIntent::INIT_SPACE,
+        payer = solver
+    )]
+    pub fulfilled_intent: Box<Account<'info, FulfilledIntent>>,
+
+    pub system_program: Program<'info, System>,
+}
+
+pub fn execute_proposal(ctx: Context<ExecuteProposal>) -> Result<()> {
+    let now = Clock::get()?.unix_timestamp as u64;
+    let proposal = &ctx.accounts.proposal;
+    let intent = &ctx.accounts.intent;
+
+    require!(proposal.deadline > now, SettlerError::ProposalIsExpired);
+
+    // TODO: Execute proposal
+
+    // TODO: Validate execution
+
+    // TODO: Emit events
+    intent.events.iter().for_each(|event| {
+        emit!(IntentEventEvent {
+            event: event.clone()
+        })
+    });
+
+    // TODO: Pay fees to Solver
+
+    Ok(())
+}
+
+#[event]
+pub struct IntentEventEvent {
+    event: IntentEvent,
+}

packages/svm/programs/settler/src/instructions/mod.rs

@@ -1,9 +1,17 @@
+pub mod add_instructions_to_proposal;
 pub mod claim_stale_intent;
+pub mod claim_stale_proposal;
 pub mod create_intent;
+pub mod create_proposal;
+pub mod execute_proposal;
 pub mod extend_intent;
 pub mod initialize;
 
+pub use add_instructions_to_proposal::*;
 pub use claim_stale_intent::*;
+pub use claim_stale_proposal::*;
 pub use create_intent::*;
+pub use create_proposal::*;
+pub use execute_proposal::*;
 pub use extend_intent::*;
 pub use initialize::*;

packages/svm/programs/settler/src/lib.rs

@@ -10,16 +10,30 @@ pub mod state;
 pub mod types;
 pub mod utils;
 
-use crate::{instructions::*, types::*};
+use crate::{instructions::*, state::*, types::*};
 
 #[program]
 pub mod settler {
     use super::*;
 
+    pub fn add_instructions_to_proposal(
+        ctx: Context<AddInstructionsToProposal>,
+        more_instructions: Vec<ProposalInstruction>,
+        finalize: bool,
+    ) -> Result<()> {
+        instructions::add_instructions_to_proposal(ctx, more_instructions, finalize)
+    }
+
     pub fn claim_stale_intent(ctx: Context<ClaimStaleIntent>) -> Result<()> {
         instructions::claim_stale_intent(ctx)
     }
 
+    pub fn claim_stale_proposal<'info>(
+        ctx: Context<'_, '_, 'info, 'info, ClaimStaleProposal<'info>>,
+    ) -> Result<()> {
+        instructions::claim_stale_proposal(ctx)
+    }
+
     pub fn create_intent(
         ctx: Context<CreateIntent>,
         intent_hash: [u8; 32],
@@ -48,6 +62,20 @@ pub mod settler {
         )
     }
 
+    pub fn create_proposal(
+        ctx: Context<CreateProposal>,
+        instructions: Vec<ProposalInstruction>,
+        fees: Vec<TokenFee>,
+        deadline: u64,
+        is_final: bool,
+    ) -> Result<()> {
+        instructions::create_proposal(ctx, instructions, fees, deadline, is_final)
+    }
+
+    pub fn execute_proposal(ctx: Context<ExecuteProposal>) -> Result<()> {
+        instructions::execute_proposal(ctx)
+    }
+
     pub fn extend_intent(
         ctx: Context<ExtendIntent>,
         more_data: Option<Vec<u8>>,

packages/svm/programs/settler/src/state/mod.rs

@@ -1,7 +1,9 @@
 pub mod fulfilled_intent;
 pub mod intent;
+pub mod proposal;
 pub mod settler_settings;
 
 pub use fulfilled_intent::*;
 pub use intent::*;
+pub use proposal::*;
 pub use settler_settings::*;