feat: Impl RequestUndelegation and UndelegateWithRollbackAfterTimeout

.github/workflows/run-tests.yml

@@ -76,6 +76,9 @@ jobs:
           solana --version
           solana-keygen new --silent --no-bip39-passphrase
 
+      - name: log disk space
+        run: df -h
+
       - name: run build
         run: |
           cargo build

dlp-api/src/consts.rs

@@ -14,6 +14,10 @@ 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.
+/// Assuming 1 slot is roughly 400ms, then 9000 slots = 60min.
+pub const DEFAULT_UNDELEGATION_REQUEST_TIMEOUT_SLOTS: u64 = 9000;
+
 /// 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

@@ -62,6 +62,12 @@ 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,
+
+    /// See [crate::processor::process_undelegate_with_rollback_after_timeout] for docs.
+    UndelegateWithRollbackAfterTimeout = 27,
 }
 
 impl DlpDiscriminator {

dlp-api/src/error.rs

@@ -24,7 +24,7 @@ pub enum DlpError {
     #[error("Invalid Authority")]
     InvalidAuthority = 0,
 
-    #[error("Account cannot be undelegated, is_undelegatable is false")]
+    #[error("Account cannot be undelegated, no undelegation requester")]
     NotUndelegatable = 1,
 
     #[error("Unauthorized Operation")]
@@ -155,6 +155,42 @@ 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("Undelegation request timeout is below the minimum")]
+    UndelegationRequestTimeoutTooShort = 50,
+
+    #[error("Undelegation request has not expired")]
+    UndelegationRequestNotExpired = 51,
+
+    #[error("Invalid pending commit state for request-timeout undelegation")]
+    InvalidPendingCommitState = 52,
+
+    #[error("Commit id did not match undelegation request checkpoint")]
+    RollbackCommitIdMismatch = 53,
+
+    #[error("Undelegation request accounts are required")]
+    MissingUndelegationRequest = 54,
+
+    #[error("Owner program requested undelegation")]
+    OwnerRequestedUndelegation = 55,
+
     #[error("An infallible error is encountered possibly due to logic error")]
     InfallibleError = 100,
 }

dlp-api/src/instruction_builder/mod.rs

@@ -18,10 +18,12 @@ 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;
 mod undelegate_confined_account;
+mod undelegate_with_rollback_after_timeout;
 mod validator_claim_fees;
 mod whitelist_validator_for_program;
 
@@ -45,9 +47,11 @@ 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::*;
 pub use undelegate_confined_account::*;
+pub use undelegate_with_rollback_after_timeout::*;
 pub use validator_claim_fees::*;
 pub use whitelist_validator_for_program::*;

dlp-api/src/instruction_builder/request_undelegation.rs

@@ -0,0 +1,75 @@
+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.
+///
+/// `delegation_rent_payer` must match the rent payer stored in the delegation
+/// metadata PDA.
+/// See [dlp::processor::process_request_undelegation] for docs.
+pub fn request_undelegation(
+    delegation_rent_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(delegation_rent_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(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, // delegation_rent_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,
@@ -19,13 +20,53 @@ use solana_sdk_ids::system_program;
 use crate::compat::{Compatize, Modernize};
 
 /// Builds an undelegate instruction.
+///
+/// `delegation_rent_payer` must match the rent payer stored in the delegation
+/// metadata PDA.
 /// See [dlp::processor::process_undelegate] for docs.
 #[allow(clippy::too_many_arguments)]
 pub fn undelegate(
     validator: Pubkey,
     delegated_account: Pubkey,
     owner_program: Pubkey,
-    rent_reimbursement: Pubkey,
+    delegation_rent_payer: Pubkey,
+) -> Instruction {
+    build_undelegate(
+        validator,
+        delegated_account,
+        owner_program,
+        delegation_rent_payer,
+        false,
+    )
+}
+
+/// Builds an undelegate instruction that also closes a matching request.
+///
+/// `delegation_rent_payer` must match the rent payer stored in the delegation
+/// metadata PDA and undelegation request PDA.
+/// 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,
+    delegation_rent_payer: Pubkey,
+) -> Instruction {
+    build_undelegate(
+        validator,
+        delegated_account,
+        owner_program,
+        delegation_rent_payer,
+        true,
+    )
+}
+
+fn build_undelegate(
+    validator: Pubkey,
+    delegated_account: Pubkey,
+    owner_program: Pubkey,
+    delegation_rent_payer: Pubkey,
+    include_undelegation_request: bool,
 ) -> Instruction {
     let validator_compat = validator.compatize();
     let delegated_account_compat = delegated_account.compatize();
@@ -49,22 +90,33 @@ 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(delegation_rent_payer, false),
+        AccountMeta::new(fees_vault_pda, false),
+        AccountMeta::new(validator_fees_vault_pda, false),
+        AccountMeta::new_readonly(system_program::id(), false),
+    ];
+
+    if include_undelegation_request {
+        let undelegation_request_pda =
+            undelegation_request_pda_from_delegated_account(
+                &delegated_account_compat,
+            )
+            .modernize();
+        accounts.push(AccountMeta::new(undelegation_request_pda, 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(),
     }
 }
@@ -85,9 +137,36 @@ pub fn undelegate_size_budget(delegated_account: AccountSizeClass) -> u32 {
         AccountSizeClass::Tiny, // commit_record_pda
         AccountSizeClass::Tiny, // delegation_record_pda
         AccountSizeClass::Tiny, // delegation_metadata_pda
-        AccountSizeClass::Tiny, // rent_reimbursement
+        AccountSizeClass::Tiny, // delegation_rent_payer
+        AccountSizeClass::Tiny, // fees_vault_pda
+        AccountSizeClass::Tiny, // validator_fees_vault_pda
+        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, // delegation_rent_payer
         AccountSizeClass::Tiny, // fees_vault_pda
         AccountSizeClass::Tiny, // validator_fees_vault_pda
         AccountSizeClass::Tiny, // system_program
+        AccountSizeClass::Tiny, // undelegation_request_pda
     ])
 }