add CarryOverRequestedUndelegation

Author: snawaz

dlp-api/src/consts.rs

@@ -14,6 +14,9 @@ pub const COMMIT_FEE_LAMPORTS: u64 = 100_000;
 /// Fixed fee per delegation session (0.0003 SOL).
 pub const SESSION_FEE_LAMPORTS: u64 = 300_000;
 
+/// Default and minimum timeout for requested undelegation.
+pub const DEFAULT_UNDELEGATION_REQUEST_TIMEOUT_SLOTS: u64 = 300;
+
 /// The discriminator for the external undelegate instruction.
 pub const EXTERNAL_UNDELEGATE_DISCRIMINATOR: [u8; 8] =
     [196, 28, 41, 206, 48, 37, 51, 167];

dlp-api/src/discriminator.rs

@@ -65,6 +65,9 @@ pub enum DlpDiscriminator {
 
     /// See [crate::processor::process_request_undelegation] for docs.
     RequestUndelegation = 26,
+
+    /// See [crate::processor::process_carry_over_requested_undelegation] for docs.
+    CarryOverRequestedUndelegation = 27,
 }
 
 impl DlpDiscriminator {

dlp-api/src/error.rs

@@ -173,6 +173,15 @@ pub enum DlpError {
     #[error("Request undelegation is only supported for off-curve delegated accounts")]
     RequestUndelegationOnCurveAccount = 49,
 
+    #[error("Undelegation request timeout is below the minimum")]
+    UndelegationRequestTimeoutTooShort = 50,
+
+    #[error("Undelegation request has not expired")]
+    UndelegationRequestNotExpired = 51,
+
+    #[error("Invalid pending commit state for timeout carry-over")]
+    InvalidPendingCommitState = 52,
+
     #[error("An infallible error is encountered possibly due to logic error")]
     InfallibleError = 100,
 }

dlp-api/src/instruction_builder/carry_over_requested_undelegation.rs

@@ -0,0 +1,100 @@
+use dlp::{
+    discriminator::DlpDiscriminator,
+    pda::{
+        commit_record_pda_from_delegated_account,
+        commit_state_pda_from_delegated_account,
+        delegation_metadata_pda_from_delegated_account,
+        delegation_record_pda_from_delegated_account,
+        undelegate_buffer_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 timeout carry-over instruction for a requested undelegation.
+/// See [dlp::processor::process_carry_over_requested_undelegation] for docs.
+#[allow(clippy::too_many_arguments)]
+pub fn carry_over_requested_undelegation(
+    caller: Pubkey,
+    delegated_account: Pubkey,
+    owner_program: Pubkey,
+    request_rent_payer: Pubkey,
+    delegation_rent_payer: Pubkey,
+    commit_reimbursement: Pubkey,
+) -> Instruction {
+    let delegated_account_compat = delegated_account.compatize();
+    let undelegate_buffer_pda =
+        undelegate_buffer_pda_from_delegated_account(&delegated_account_compat)
+            .modernize();
+    let 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();
+    let commit_state_pda =
+        commit_state_pda_from_delegated_account(&delegated_account_compat)
+            .modernize();
+    let commit_record_pda =
+        commit_record_pda_from_delegated_account(&delegated_account_compat)
+            .modernize();
+
+    Instruction {
+        program_id: dlp::id().modernize(),
+        accounts: vec![
+            AccountMeta::new(caller, true),
+            AccountMeta::new(delegated_account, false),
+            AccountMeta::new_readonly(owner_program, false),
+            AccountMeta::new(undelegate_buffer_pda, false),
+            AccountMeta::new(request_pda, false),
+            AccountMeta::new(delegation_record_pda, false),
+            AccountMeta::new(delegation_metadata_pda, false),
+            AccountMeta::new(request_rent_payer, false),
+            AccountMeta::new(delegation_rent_payer, false),
+            AccountMeta::new(commit_state_pda, false),
+            AccountMeta::new(commit_record_pda, false),
+            AccountMeta::new(commit_reimbursement, false),
+            AccountMeta::new_readonly(system_program::id(), false),
+        ],
+        data: DlpDiscriminator::CarryOverRequestedUndelegation.to_vec(),
+    }
+}
+
+///
+/// Returns accounts-data-size budget for requested undelegation carry-over.
+///
+/// This value can be used with ComputeBudgetInstruction::SetLoadedAccountsDataSizeLimit
+///
+pub fn carry_over_requested_undelegation_size_budget(
+    delegated_account: AccountSizeClass,
+) -> u32 {
+    total_size_budget(&[
+        DLP_PROGRAM_DATA_SIZE_CLASS,
+        AccountSizeClass::Tiny, // caller
+        delegated_account,      // delegated_account
+        AccountSizeClass::Tiny, // owner_program
+        delegated_account,      // undelegate_buffer_pda
+        AccountSizeClass::Tiny, // undelegation_request_pda
+        AccountSizeClass::Tiny, // delegation_record_pda
+        AccountSizeClass::Tiny, // delegation_metadata_pda
+        AccountSizeClass::Tiny, // request_rent_payer
+        AccountSizeClass::Tiny, // delegation_rent_payer
+        delegated_account,      // commit_state_pda
+        AccountSizeClass::Tiny, // commit_record_pda
+        AccountSizeClass::Tiny, // commit_reimbursement
+        AccountSizeClass::Tiny, // system_program
+    ])
+}

dlp-api/src/instruction_builder/mod.rs

@@ -1,5 +1,6 @@
 mod call_handler;
 mod call_handler_v2;
+mod carry_over_requested_undelegation;
 mod close_ephemeral_balance;
 mod close_validator_fees_vault;
 mod commit_diff;
@@ -28,6 +29,7 @@ mod whitelist_validator_for_program;
 
 pub use call_handler::*;
 pub use call_handler_v2::*;
+pub use carry_over_requested_undelegation::*;
 pub use close_ephemeral_balance::*;
 pub use close_validator_fees_vault::*;
 pub use commit_diff::*;

dlp-api/src/instruction_builder/request_undelegation.rs

@@ -21,6 +21,31 @@ pub fn request_undelegation(
     payer: Pubkey,
     delegated_account: Pubkey,
     owner_program: Pubkey,
+) -> Instruction {
+    build_request_undelegation(payer, delegated_account, owner_program, None)
+}
+
+/// Builds a request undelegation instruction with a custom timeout.
+/// See [dlp::processor::process_request_undelegation] for docs.
+pub fn request_undelegation_with_timeout(
+    payer: Pubkey,
+    delegated_account: Pubkey,
+    owner_program: Pubkey,
+    timeout_slots: u64,
+) -> Instruction {
+    build_request_undelegation(
+        payer,
+        delegated_account,
+        owner_program,
+        Some(timeout_slots),
+    )
+}
+
+fn build_request_undelegation(
+    payer: Pubkey,
+    delegated_account: Pubkey,
+    owner_program: Pubkey,
+    timeout_slots: Option<u64>,
 ) -> Instruction {
     let delegated_account_compat = delegated_account.compatize();
     let undelegation_request_pda =
@@ -36,6 +61,10 @@ pub fn request_undelegation(
             &delegated_account_compat,
         )
         .modernize();
+    let mut data = DlpDiscriminator::RequestUndelegation.to_vec();
+    if let Some(timeout_slots) = timeout_slots {
+        data.extend_from_slice(&timeout_slots.to_le_bytes());
+    }
 
     Instruction {
         program_id: dlp::id().modernize(),
@@ -48,7 +77,7 @@ pub fn request_undelegation(
             AccountMeta::new_readonly(delegation_metadata_pda, false),
             AccountMeta::new_readonly(system_program::id(), false),
         ],
-        data: DlpDiscriminator::RequestUndelegation.to_vec(),
+        data,
     }
 }
 

dlp-api/src/state/undelegation_request.rs

@@ -23,6 +23,18 @@ pub struct UndelegationRequest {
 
     /// The slot at which the request was created.
     pub created_slot: u64,
+
+    /// The first slot at which timeout carry-over is allowed.
+    pub expires_at_slot: u64,
+
+    /// Delegation metadata nonce observed when the request was created.
+    pub delegation_nonce_at_request: u64,
+
+    /// PDA bump for this request.
+    pub bump: u8,
+
+    /// Explicit padding keeps this type Pod-safe with repr(C).
+    pub _padding: [u8; 7],
 }
 
 impl AccountWithDiscriminator for UndelegationRequest {

src/lib.rs

@@ -154,6 +154,11 @@ pub fn fast_process_instruction(
                 program_id, accounts, data,
             ))
         }
+        DlpDiscriminator::CarryOverRequestedUndelegation => {
+            Some(processor::fast::process_carry_over_requested_undelegation(
+                program_id, accounts, data,
+            ))
+        }
         _ => None,
     }
 }