feat: Implement Undelegate for v2

.github/pull_request_template.md

@@ -1,45 +1,8 @@
+<!--
+Keep the PR description short. Summarize the change in one or two sentences.
+Do not repeat details already covered by the linked issue.
+-->
 
-> ⚠️ NOTE: Use notes like this to emphasize something important about the PR.
->
->  This could include other PRs this PR is built on top of; API breaking changes; reasons for why the PR is on hold; or anything else you would like to draw attention to.
+<Brief summary>
 
-| Status  | Type  | ⚠️ Core Change | Issue |
-| :---: | :---: | :---: | :--: |
-| Ready/Hold | Feature/Bug/Tooling/Refactor/Hotfix | Yes/No | [Link](<Issue link here>) |
-
-## Problem
-
-_What problem are you trying to solve?_
-
-
-## Solution
-
-_How did you solve the problem?_
-
-
-## Before & After Screenshots
-
-_Insert screenshots of example code output_
-
-**BEFORE**:
-[insert screenshot here]
-
-**AFTER**:
-[insert screenshot here]
-
-
-## Other changes (e.g. bug fixes, small refactors)
-
-
-## Deploy Notes
-
-_Notes regarding deployment of the contained body of work. These should note any
-new dependencies, new scripts, etc._
-
-**New scripts**:
-
-- `script` : script details
-
-**New dependencies**:
-
-- `dependency` : dependency details
+Closes #<issue>

interface/src/args/mod.rs

@@ -11,6 +11,7 @@ mod raise_challenge;
 mod register_operator;
 mod register_verifier;
 mod resolve_dispute;
+mod undelegate;
 mod update_delegation_cluster;
 mod update_verifier_registry;
 mod write_state_buffer;
@@ -25,6 +26,7 @@ pub use raise_challenge::*;
 pub use register_operator::*;
 pub use register_verifier::*;
 pub use resolve_dispute::*;
+pub use undelegate::*;
 pub use update_delegation_cluster::*;
 pub use update_verifier_registry::*;
 pub use write_state_buffer::*;

interface/src/args/propose_commitment.rs

@@ -11,6 +11,9 @@ pub struct ProposeCommitmentArgs {
 
     pub owner: Pubkey,
 
+    /// Whether finalization should make the account undelegatable.
+    pub allow_undelegation: bool,
+
     /// Hash of replay/data-availability pointer bytes.
     pub da_pointer_hash: [u8; 32],
 

interface/src/args/undelegate.rs

@@ -0,0 +1,9 @@
+use wheels::variable_offset_layout;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[variable_offset_layout(buffer_offset = 1)]
+pub struct UndelegateArgs {
+    /// Bump for the temporary DLP-owned undelegation buffer PDA.
+    /// Set by the instruction builder.
+    pub undelegate_buffer_bump: u8,
+}

interface/src/consts.rs

@@ -0,0 +1,3 @@
+/// Discriminator understood by owner programs during undelegation callbacks.
+pub const EXTERNAL_UNDELEGATE_DISCRIMINATOR: [u8; 8] =
+    [196, 28, 41, 206, 48, 37, 51, 167];

interface/src/error.rs

@@ -191,6 +191,9 @@ pub enum DlpError {
     #[error("Owner program requested undelegation")]
     OwnerRequestedUndelegation = 55,
 
+    #[error("Account data is too large for one-step undelegation")]
+    AccountDataTooLargeForUndelegation = 56,
+
     #[error("An infallible error is encountered possibly due to logic error")]
     InfallibleError = 100,
 }

interface/src/instruction.rs

@@ -41,6 +41,8 @@ pub enum DlpV2Instruction {
     CommitFinalizeFromBuffer = 114,
     /// Grows a delegated account by one step before a large direct finalization.
     PrepareCommitFinalize = 115,
+    /// Returns a delegated account to its original owner.
+    Undelegate = 116,
 }
 
 impl DlpV2Instruction {

interface/src/instruction_builder/mod.rs

@@ -10,6 +10,7 @@ mod raise_challenge;
 mod register_operator;
 mod register_verifier;
 mod resolve_dispute;
+mod undelegate;
 mod update_delegation_cluster;
 mod update_verifier_registry;
 mod write_state_buffer;
@@ -26,6 +27,7 @@ pub use raise_challenge::*;
 pub use register_operator::*;
 pub use register_verifier::*;
 pub use resolve_dispute::*;
+pub use undelegate::*;
 pub use update_delegation_cluster::*;
 pub use update_verifier_registry::*;
 pub use write_state_buffer::*;

interface/src/instruction_builder/undelegate.rs

@@ -0,0 +1,50 @@
+use solana_program::{
+    instruction::{AccountMeta, Instruction},
+    pubkey::Pubkey,
+};
+use solana_sdk_ids::system_program;
+use wheels::{layout::Encodable, DataLayoutError};
+
+use crate::{
+    compat::{Compatize, Modernize},
+    pda::{delegation_state_pda, undelegate_buffer_pda},
+    DlpV2Instruction, UndelegateArgs,
+};
+
+/// Builds the shared undelegation instruction.
+pub fn undelegate(
+    current_validator: Pubkey,
+    delegated_account: Pubkey,
+    original_owner: Pubkey,
+    delegation_cluster: Pubkey,
+    delegation_rent_payer: Pubkey,
+) -> Result<Instruction, DataLayoutError> {
+    let (undelegate_buffer, undelegate_buffer_bump) =
+        undelegate_buffer_pda(&delegated_account.compatize());
+
+    Ok(Instruction {
+        program_id: crate::id().modernize(),
+        accounts: vec![
+            AccountMeta::new(current_validator, true),
+            AccountMeta::new(delegated_account, false),
+            AccountMeta::new_readonly(original_owner, false),
+            AccountMeta::new(undelegate_buffer.modernize(), false),
+            AccountMeta::new(
+                delegation_state_pda(&delegated_account.compatize())
+                    .modernize(),
+                false,
+            ),
+            AccountMeta::new_readonly(delegation_cluster, false),
+            AccountMeta::new(delegation_rent_payer, false),
+            AccountMeta::new_readonly(system_program::id(), false),
+        ],
+        data: [
+            DlpV2Instruction::Undelegate.to_vec(),
+            UndelegateArgs {
+                undelegate_buffer_bump,
+            }
+            .encode()?,
+        ]
+        .concat(),
+    })
+}

interface/src/lib.rs

@@ -3,6 +3,7 @@ pub use ::solana_program;
 pub mod args;
 pub mod compact;
 pub mod compat;
+pub mod consts;
 
 #[cfg(feature = "diff")]
 pub mod diff;
@@ -18,6 +19,7 @@ pub mod state;
 pub mod instruction_builder;
 
 pub use args::*;
+pub use consts::*;
 pub use instruction::*;
 pub use pda::*;
 pub use state::*;

interface/src/pda.rs

@@ -8,6 +8,7 @@ pub const VERIFIER_REGISTRY_SEED: &[u8] = b"verifier-registry";
 pub const STATE_BUFFER_SEED: &[u8] = b"state-buffer";
 pub const PENDING_COMMITMENT_SEED: &[u8] = b"pending-commitment";
 pub const CHALLENGE_SEED: &[u8] = b"challenge";
+pub const UNDELEGATE_BUFFER_SEED: &[u8] = b"undelegate-buffer";
 
 // TODO (snawaz): Precompute these addresses if PDA derivation becomes const-safe.
 
@@ -103,3 +104,10 @@ pub fn challenge_pda(
     )
     .0
 }
+
+pub fn undelegate_buffer_pda(delegated_account: &Pubkey) -> (Pubkey, u8) {
+    Pubkey::find_program_address(
+        &[UNDELEGATE_BUFFER_SEED, delegated_account.as_ref()],
+        &crate::id(),
+    )
+}

interface/src/state/pending_commitment.rs

@@ -62,6 +62,12 @@ pub struct PendingCommitment {
     /// Owner committed by the operator.
     pub owner: Pubkey,
 
+    /// Whether finalization should make the account undelegatable.
+    pub allow_undelegation: bool,
+
+    /// Keeps the following fixed-width fields eight-byte aligned.
+    pub _pad_after_allow_undelegation: [u8; 7],
+
     /// Hash binding operator, account, commit sequence number, delegation, DA,
     /// and state.
     pub state_commitment_hash: [u8; 32],

program/src/processor/fraud_proofs/finalize_commitment.rs

@@ -257,6 +257,10 @@ pub fn process_finalize_commitment(
         let mut metadata =
             DelegationMetadataFast::from_account(delegation_metadata)?;
         metadata.set_last_commit_id(pending.commit_seq());
+        if pending.allow_undelegation() {
+            metadata
+                .set_undelegation_requester(UndelegationRequester::Validator);
+        }
     }
 
     drop(delegation_cluster_data);

program/src/processor/fraud_proofs/propose_commitment.rs

@@ -242,6 +242,7 @@ pub fn process_propose_commitment(
             delegation_record: delegation_record.address(),
             da_pointer_hash: args.da_pointer_hash(),
             account_state_hash: &account_state_hash,
+            allow_undelegation: args.allow_undelegation(),
             verifier_registry: verifier_registry.address(),
             challenge_window_id,
         });
@@ -260,6 +261,8 @@ pub fn process_propose_commitment(
         data_hash,
         lamports: args.lamports(),
         owner: *args.owner(),
+        allow_undelegation: args.allow_undelegation(),
+        _pad_after_allow_undelegation: [0; 7],
         state_commitment_hash,
         verifier_registry: verifier_registry.address().to_bytes().into(),
         challenge_window_id,
@@ -472,6 +475,7 @@ struct StateCommitmentHashInput<'a> {
     delegation_record: &'a Address,
     da_pointer_hash: &'a [u8; 32],
     account_state_hash: &'a [u8; 32],
+    allow_undelegation: bool,
     verifier_registry: &'a Address,
     challenge_window_id: u64,
 }
@@ -486,6 +490,7 @@ fn state_commitment_hash(input: StateCommitmentHashInput<'_>) -> [u8; 32] {
         input.delegation_record.as_ref(),
         input.da_pointer_hash,
         input.account_state_hash,
+        &[input.allow_undelegation as u8],
         input.verifier_registry.as_ref(),
         &input.challenge_window_id.to_le_bytes(),
     ])

program/src/processor/internal/mod.rs

@@ -1,3 +1,5 @@
 mod commit_finalize;
+mod undelegate;
 
 pub(crate) use commit_finalize::*;
+pub(crate) use undelegate::*;