feat: Impl RequestUndelegation and UndelegateWithRollbackAfterTimeout

dlp-api/src/discriminator.rs

@@ -62,6 +62,9 @@ pub enum DlpDiscriminator {
 
     /// See [crate::processor::process_delegate_magic_fee_vault] for docs.
     DelegateMagicFeeVault = 25,
+
+    /// See [crate::processor::process_request_undelegation] for docs.
+    RequestUndelegation = 26,
 }
 
 impl DlpDiscriminator {

dlp-api/src/error.rs

@@ -155,6 +155,24 @@ pub enum DlpError {
     )]
     InsufficientRent = 43,
 
+    #[error("Undelegation request PDA invalid seeds")]
+    UndelegationRequestInvalidSeeds = 44,
+
+    #[error("Undelegation request PDA invalid account owner")]
+    UndelegationRequestInvalidAccountOwner = 45,
+
+    #[error("Undelegation request PDA is already initialized")]
+    UndelegationRequestAlreadyInitialized = 46,
+
+    #[error("Undelegation request PDA immutable")]
+    UndelegationRequestImmutable = 47,
+
+    #[error("Invalid undelegation request")]
+    InvalidUndelegationRequest = 48,
+
+    #[error("Request undelegation is only supported for off-curve delegated accounts")]
+    RequestUndelegationOnCurveAccount = 49,
+
     #[error("An infallible error is encountered possibly due to logic error")]
     InfallibleError = 100,
 }

dlp-api/src/instruction_builder/mod.rs

@@ -18,6 +18,7 @@ mod init_magic_fee_vault;
 mod init_protocol_fees_vault;
 mod init_validator_fees_vault;
 mod protocol_claim_fees;
+mod request_undelegation;
 mod top_up_ephemeral_balance;
 mod types;
 mod undelegate;
@@ -45,6 +46,7 @@ pub use init_magic_fee_vault::*;
 pub use init_protocol_fees_vault::*;
 pub use init_validator_fees_vault::*;
 pub use protocol_claim_fees::*;
+pub use request_undelegation::*;
 pub use top_up_ephemeral_balance::*;
 pub use types::*;
 pub use undelegate::*;

dlp-api/src/instruction_builder/request_undelegation.rs

@@ -0,0 +1,73 @@
+use dlp::{
+    discriminator::DlpDiscriminator,
+    pda::{
+        delegation_metadata_pda_from_delegated_account,
+        delegation_record_pda_from_delegated_account,
+        undelegation_request_pda_from_delegated_account,
+    },
+    total_size_budget, AccountSizeClass, DLP_PROGRAM_DATA_SIZE_CLASS,
+};
+use solana_program::{
+    instruction::{AccountMeta, Instruction},
+    pubkey::Pubkey,
+};
+use solana_sdk_ids::system_program;
+
+use crate::compat::{Compatize, Modernize};
+
+/// Builds a request undelegation instruction.
+/// See [dlp::processor::process_request_undelegation] for docs.
+pub fn request_undelegation(
+    payer: Pubkey,
+    delegated_account: Pubkey,
+    owner_program: Pubkey,
+) -> Instruction {
+    let delegated_account_compat = delegated_account.compatize();
+    let undelegation_request_pda =
+        undelegation_request_pda_from_delegated_account(
+            &delegated_account_compat,
+        )
+        .modernize();
+    let delegation_record_pda =
+        delegation_record_pda_from_delegated_account(&delegated_account_compat)
+            .modernize();
+    let delegation_metadata_pda =
+        delegation_metadata_pda_from_delegated_account(
+            &delegated_account_compat,
+        )
+        .modernize();
+
+    Instruction {
+        program_id: dlp::id().modernize(),
+        accounts: vec![
+            AccountMeta::new(payer, true),
+            AccountMeta::new_readonly(delegated_account, true),
+            AccountMeta::new_readonly(owner_program, false),
+            AccountMeta::new(undelegation_request_pda, false),
+            AccountMeta::new_readonly(delegation_record_pda, false),
+            AccountMeta::new_readonly(delegation_metadata_pda, false),
+            AccountMeta::new_readonly(system_program::id(), false),
+        ],
+        data: DlpDiscriminator::RequestUndelegation.to_vec(),
+    }
+}
+
+///
+/// Returns accounts-data-size budget for request undelegation instruction.
+///
+/// This value can be used with ComputeBudgetInstruction::SetLoadedAccountsDataSizeLimit
+///
+pub fn request_undelegation_size_budget(
+    delegated_account: AccountSizeClass,
+) -> u32 {
+    total_size_budget(&[
+        DLP_PROGRAM_DATA_SIZE_CLASS,
+        AccountSizeClass::Tiny, // payer
+        delegated_account,      // delegated_account
+        AccountSizeClass::Tiny, // owner_program
+        AccountSizeClass::Tiny, // undelegation_request_pda
+        AccountSizeClass::Tiny, // delegation_record_pda
+        AccountSizeClass::Tiny, // delegation_metadata_pda
+        AccountSizeClass::Tiny, // system_program
+    ])
+}

dlp-api/src/instruction_builder/undelegate.rs

@@ -6,6 +6,7 @@ use dlp::{
         delegation_metadata_pda_from_delegated_account,
         delegation_record_pda_from_delegated_account, fees_vault_pda,
         undelegate_buffer_pda_from_delegated_account,
+        undelegation_request_pda_from_delegated_account,
         validator_fees_vault_pda_from_validator,
     },
     total_size_budget, AccountSizeClass, DLP_PROGRAM_DATA_SIZE_CLASS,
@@ -26,6 +27,41 @@ pub fn undelegate(
     delegated_account: Pubkey,
     owner_program: Pubkey,
     rent_reimbursement: Pubkey,
+) -> Instruction {
+    build_undelegate(
+        validator,
+        delegated_account,
+        owner_program,
+        rent_reimbursement,
+        None,
+    )
+}
+
+/// Builds an undelegate instruction that also closes a matching request.
+/// See [dlp::processor::process_undelegate] for docs.
+#[allow(clippy::too_many_arguments)]
+pub fn undelegate_with_request(
+    validator: Pubkey,
+    delegated_account: Pubkey,
+    owner_program: Pubkey,
+    rent_reimbursement: Pubkey,
+    request_rent_payer: Pubkey,
+) -> Instruction {
+    build_undelegate(
+        validator,
+        delegated_account,
+        owner_program,
+        rent_reimbursement,
+        Some(request_rent_payer),
+    )
+}
+
+fn build_undelegate(
+    validator: Pubkey,
+    delegated_account: Pubkey,
+    owner_program: Pubkey,
+    rent_reimbursement: Pubkey,
+    request_rent_payer: Option<Pubkey>,
 ) -> Instruction {
     let validator_compat = validator.compatize();
     let delegated_account_compat = delegated_account.compatize();
@@ -49,22 +85,34 @@ pub fn undelegate(
     let fees_vault_pda = fees_vault_pda().modernize();
     let validator_fees_vault_pda =
         validator_fees_vault_pda_from_validator(&validator_compat).modernize();
+    let mut accounts = vec![
+        AccountMeta::new(validator, true),
+        AccountMeta::new(delegated_account, false),
+        AccountMeta::new_readonly(owner_program, false),
+        AccountMeta::new(undelegate_buffer_pda, false),
+        AccountMeta::new_readonly(commit_state_pda, false),
+        AccountMeta::new_readonly(commit_record_pda, false),
+        AccountMeta::new(delegation_record_pda, false),
+        AccountMeta::new(delegation_metadata_pda, false),
+        AccountMeta::new(rent_reimbursement, false),
+        AccountMeta::new(fees_vault_pda, false),
+        AccountMeta::new(validator_fees_vault_pda, false),
+        AccountMeta::new_readonly(system_program::id(), false),
+    ];
+
+    if let Some(request_rent_payer) = request_rent_payer {
+        let undelegation_request_pda =
+            undelegation_request_pda_from_delegated_account(
+                &delegated_account_compat,
+            )
+            .modernize();
+        accounts.push(AccountMeta::new(undelegation_request_pda, false));
+        accounts.push(AccountMeta::new(request_rent_payer, false));
+    }
+
     Instruction {
         program_id: dlp::id().modernize(),
-        accounts: vec![
-            AccountMeta::new(validator, true),
-            AccountMeta::new(delegated_account, false),
-            AccountMeta::new_readonly(owner_program, false),
-            AccountMeta::new(undelegate_buffer_pda, false),
-            AccountMeta::new_readonly(commit_state_pda, false),
-            AccountMeta::new_readonly(commit_record_pda, false),
-            AccountMeta::new(delegation_record_pda, false),
-            AccountMeta::new(delegation_metadata_pda, false),
-            AccountMeta::new(rent_reimbursement, false),
-            AccountMeta::new(fees_vault_pda, false),
-            AccountMeta::new(validator_fees_vault_pda, false),
-            AccountMeta::new_readonly(system_program::id(), false),
-        ],
+        accounts,
         data: DlpDiscriminator::Undelegate.to_vec(),
     }
 }
@@ -91,3 +139,31 @@ pub fn undelegate_size_budget(delegated_account: AccountSizeClass) -> u32 {
         AccountSizeClass::Tiny, // system_program
     ])
 }
+
+///
+/// Returns accounts-data-size budget for undelegate instruction with request
+/// accounts.
+///
+/// This value can be used with ComputeBudgetInstruction::SetLoadedAccountsDataSizeLimit
+///
+pub fn undelegate_with_request_size_budget(
+    delegated_account: AccountSizeClass,
+) -> u32 {
+    total_size_budget(&[
+        DLP_PROGRAM_DATA_SIZE_CLASS,
+        AccountSizeClass::Tiny, // validator
+        delegated_account,      // delegated_account
+        AccountSizeClass::Tiny, // owner_program
+        delegated_account,      // undelegate_buffer_pda
+        delegated_account,      // commit_state_pda
+        AccountSizeClass::Tiny, // commit_record_pda
+        AccountSizeClass::Tiny, // delegation_record_pda
+        AccountSizeClass::Tiny, // delegation_metadata_pda
+        AccountSizeClass::Tiny, // rent_reimbursement
+        AccountSizeClass::Tiny, // fees_vault_pda
+        AccountSizeClass::Tiny, // validator_fees_vault_pda
+        AccountSizeClass::Tiny, // system_program
+        AccountSizeClass::Tiny, // undelegation_request_pda
+        AccountSizeClass::Tiny, // request_rent_payer
+    ])
+}

dlp-api/src/pda.rs

@@ -60,6 +60,17 @@ macro_rules! undelegate_buffer_seeds_from_delegated_account {
     };
 }
 
+pub const UNDELEGATION_REQUEST_TAG: &[u8] = b"undelegation-request";
+#[macro_export]
+macro_rules! undelegation_request_seeds_from_delegated_account {
+    ($delegated_account: expr) => {
+        &[
+            $crate::pda::UNDELEGATION_REQUEST_TAG,
+            &$delegated_account.as_ref(),
+        ]
+    };
+}
+
 #[macro_export]
 macro_rules! fees_vault_seeds {
     () => {
@@ -172,6 +183,16 @@ pub fn undelegate_buffer_pda_from_delegated_account(
     .0
 }
 
+pub fn undelegation_request_pda_from_delegated_account(
+    delegated_account: &Pubkey,
+) -> Pubkey {
+    Pubkey::find_program_address(
+        undelegation_request_seeds_from_delegated_account!(delegated_account),
+        &crate::id(),
+    )
+    .0
+}
+
 pub fn fees_vault_pda() -> Pubkey {
     Pubkey::find_program_address(fees_vault_seeds!(), &crate::id()).0
 }

dlp-api/src/requires.rs

@@ -758,6 +758,16 @@ define_uninitialized_ctx!(
     immutable = DlpError::CommitRecordImmutable
 );
 
+define_uninitialized_ctx!(
+    UndelegationRequestCtx,
+    label = "undelegation request",
+    invalid_seeds = DlpError::UndelegationRequestInvalidSeeds,
+    invalid_account_owner = DlpError::UndelegationRequestInvalidAccountOwner,
+    account_already_initialized =
+        DlpError::UndelegationRequestAlreadyInitialized,
+    immutable = DlpError::UndelegationRequestImmutable
+);
+
 define_uninitialized_ctx!(
     DelegationRecordCtx,
     label = "delegation record",

dlp-api/src/state/mod.rs

@@ -2,10 +2,12 @@ mod commit_record;
 mod delegation_metadata;
 mod delegation_record;
 mod program_config;
+mod undelegation_request;
 mod utils;
 
 pub use commit_record::*;
 pub use delegation_metadata::*;
 pub use delegation_record::*;
 pub use program_config::*;
+pub use undelegation_request::*;
 pub use utils::*;

dlp-api/src/state/undelegation_request.rs

@@ -0,0 +1,41 @@
+use std::mem::size_of;
+
+use bytemuck::{Pod, Zeroable};
+
+use super::discriminator::{AccountDiscriminator, AccountWithDiscriminator};
+use crate::{
+    compat::Pubkey, impl_to_bytes_with_discriminator_zero_copy,
+    impl_try_from_bytes_with_discriminator_zero_copy,
+};
+
+/// Request for the validator to undelegate one delegated account.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable)]
+pub struct UndelegationRequest {
+    /// The delegated account this request targets.
+    pub delegated_account: Pubkey,
+
+    /// The original owner program recorded for the delegated account.
+    pub owner_program: Pubkey,
+
+    /// The account that paid rent for this request PDA.
+    pub rent_payer: Pubkey,
+
+    /// The slot at which the request was created.
+    pub created_slot: u64,
+}
+
+impl AccountWithDiscriminator for UndelegationRequest {
+    fn discriminator() -> AccountDiscriminator {
+        AccountDiscriminator::UndelegationRequest
+    }
+}
+
+impl UndelegationRequest {
+    pub fn size_with_discriminator() -> usize {
+        8 + size_of::<UndelegationRequest>()
+    }
+}
+
+impl_to_bytes_with_discriminator_zero_copy!(UndelegationRequest);
+impl_try_from_bytes_with_discriminator_zero_copy!(UndelegationRequest);

dlp-api/src/state/utils/discriminator.rs

@@ -9,6 +9,7 @@ pub enum AccountDiscriminator {
     DelegationMetadata = 102,
     CommitRecord = 101,
     ProgramConfig = 103,
+    UndelegationRequest = 104,
 }
 
 impl AccountDiscriminator {

src/lib.rs

@@ -19,6 +19,7 @@ pub(crate) use dlp_api::{
     ephemeral_balance_seeds_from_payer, fees_vault_seeds,
     magic_fee_vault_seeds_from_validator, program_config_seeds_from_program_id,
     undelegate_buffer_seeds_from_delegated_account,
+    undelegation_request_seeds_from_delegated_account,
     validator_fees_vault_seeds_from_validator,
 };
 pub use dlp_api::{id, ID};
@@ -148,6 +149,11 @@ pub fn fast_process_instruction(
                 program_id, accounts, data,
             ))
         }
+        DlpDiscriminator::RequestUndelegation => {
+            Some(processor::fast::process_request_undelegation(
+                program_id, accounts, data,
+            ))
+        }
         _ => None,
     }
 }