feat: Impl V2 Delegate

src/lib.rs

@@ -34,6 +34,8 @@ pub mod state;
 
 mod account_size_class;
 
+mod v2;
+
 pub use account_size_class::*;
 
 #[cfg(not(feature = "sdk"))]
@@ -79,6 +81,8 @@ pub fn fast_process_instruction(
     accounts: &[pinocchio::AccountView],
     data: &[u8],
 ) -> Option<pinocchio::ProgramResult> {
+    use crate::v2::DlpInstruction;
+
     if data.len() < 8 {
         return Some(Err(
             pinocchio::error::ProgramError::InvalidInstructionData,
@@ -87,6 +91,11 @@ pub fn fast_process_instruction(
 
     let (discriminator_bytes, data) = data.split_at(8);
 
+    if discriminator_bytes[0] >= DlpInstruction::Delegate as u8 {
+        use crate::v2::v2_process_instruction;
+        return Some(v2_process_instruction(accounts, data));
+    }
+
     let discriminator = match DlpDiscriminator::try_from(discriminator_bytes[0])
     {
         Ok(discriminator) => discriminator,

src/processor/fast/mod.rs

@@ -8,7 +8,7 @@ mod delegate;
 mod finalize;
 mod undelegate;
 mod undelegate_confined_account;
-mod utils;
+pub mod utils;
 
 pub(crate) mod internal;
 

src/processor/mod.rs

@@ -7,7 +7,7 @@ mod init_protocol_fees_vault;
 mod init_validator_fees_vault;
 mod protocol_claim_fees;
 mod top_up_ephemeral_balance;
-mod utils;
+pub mod utils;
 mod validator_claim_fees;
 mod whitelist_validator_for_program;
 

src/v2/instruction.rs

@@ -0,0 +1,112 @@
+use num_enum::TryFromPrimitive;
+use pinocchio::{error::ProgramError, ProgramResult};
+use strum::IntoStaticStr;
+
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, TryFromPrimitive, IntoStaticStr)]
+#[rustfmt::skip]
+pub enum DlpInstruction {
+    ///
+    /// Delegate group: [101, 110] => 10 slots
+    ///
+    Delegate = 101,
+    DelegateWithAnyValidator = 102,
+
+    ///
+    /// Commit group: [111, 120] => 10 slots
+    ///
+    Commit = 111,
+    CommitFromBuffer = 112,
+    CommitFinalize = 113,
+    CommitFinalizeFromBuffer = 114,
+
+    ///
+    /// Finalize group: [121, 130] => 10 slots
+    ///
+    Finalize = 121,
+
+    ///
+    /// Undelegate group: [131, 140] => 10 slots
+    ///
+    Undelegate = 131,
+    UndelegateConfinedAccount = 132,
+
+    ///
+    /// User group: [141, 150] => 10 slots
+    ///
+    CallHandler = 141,
+
+    ///
+    /// Vaults group: [151, 160] => 10 slots
+    ///
+    InitProtocolFeesVault = 151,
+    ProtocolClaimFees = 152,
+    InitValidatorFeesVault = 153,
+    ValidatorClaimFees = 154,
+    CloseValidatorFeesVault = 155,
+
+    ///
+    /// Misc group: [161, 180] => 20 slots
+    ///
+    WhitelistValidatorForProgram = 161,
+    TopUpEphemeralBalance = 162,
+    DelegateEphemeralBalance = 163,
+    CloseEphemeralBalance = 164,
+}
+
+impl DlpInstruction {
+    pub fn to_vec(self) -> Vec<u8> {
+        let num = self as u64;
+        num.to_le_bytes().to_vec()
+    }
+
+    pub fn name(&self) -> &'static str {
+        self.into()
+    }
+}
+
+pub fn v2_process_instruction(
+    accounts: &[pinocchio::AccountView],
+    data: &[u8],
+) -> ProgramResult {
+    let (ix, data) = data.split_at(8);
+
+    let ix = match DlpInstruction::try_from(ix[0]) {
+        Ok(discriminator) => discriminator,
+        Err(_) => {
+            pinocchio_log::log!("Failed to read and parse discriminator");
+            return Err(pinocchio::error::ProgramError::InvalidInstructionData);
+        }
+    };
+
+    use super::processor::*;
+
+    let coming_soon = || {
+        solana_program::msg!("Instruction {:#?} not yet implemented", ix);
+        return Err(ProgramError::InvalidInstructionData);
+    };
+
+    match ix {
+        DlpInstruction::Delegate => process_delegate(accounts, data),
+        DlpInstruction::DelegateWithAnyValidator => {
+            process_delegate_with_any_validator(accounts, data)
+        }
+        DlpInstruction::Commit => coming_soon(),
+        DlpInstruction::CommitFromBuffer => coming_soon(),
+        DlpInstruction::CommitFinalize => coming_soon(),
+        DlpInstruction::CommitFinalizeFromBuffer => coming_soon(),
+        DlpInstruction::Finalize => coming_soon(),
+        DlpInstruction::Undelegate => coming_soon(),
+        DlpInstruction::UndelegateConfinedAccount => coming_soon(),
+        DlpInstruction::CallHandler => coming_soon(),
+        DlpInstruction::InitProtocolFeesVault => coming_soon(),
+        DlpInstruction::ProtocolClaimFees => coming_soon(),
+        DlpInstruction::InitValidatorFeesVault => coming_soon(),
+        DlpInstruction::ValidatorClaimFees => coming_soon(),
+        DlpInstruction::CloseValidatorFeesVault => coming_soon(),
+        DlpInstruction::WhitelistValidatorForProgram => coming_soon(),
+        DlpInstruction::TopUpEphemeralBalance => coming_soon(),
+        DlpInstruction::DelegateEphemeralBalance => coming_soon(),
+        DlpInstruction::CloseEphemeralBalance => coming_soon(),
+    }
+}

src/v2/mod.rs

@@ -0,0 +1,9 @@
+mod instruction;
+mod processor;
+mod requires;
+mod state;
+
+pub use instruction::*;
+pub use processor::*;
+pub use requires::*;
+pub use state::*;

src/v2/processor/delegate.rs

@@ -0,0 +1,20 @@
+use pinocchio::{AccountView, ProgramResult};
+
+use crate::v2::processor::internal::process_delegate_internal;
+
+pub fn process_delegate(
+    accounts: &[AccountView],
+    data: &[u8],
+) -> ProgramResult {
+    process_delegate_internal::<false>(accounts, data)
+}
+
+///
+/// delegates an account while allowing any validator identity
+///
+pub fn process_delegate_with_any_validator(
+    accounts: &[AccountView],
+    data: &[u8],
+) -> ProgramResult {
+    process_delegate_internal::<true>(accounts, data)
+}