Pass bumps

Author: snawaz

Cargo.lock

@@ -48,6 +48,8 @@ logging = []
 
 [dependencies]
 borsh = { version = "1.5.3", features = [ "derive" ] }
+const-crypto = "0.3.0"
+solana-sha256-hasher = "3.1.0"
 solana-program = { version = ">=1.16, <3.0.0" }
 bytemuck = { version = ">=1", features = [ "derive" ] }
 num_enum = "^0.7.2"

Cargo.toml

@@ -0,0 +1,31 @@
+use std::ops::Deref;
+
+use bytemuck::Pod;
+use pinocchio::program_error::ProgramError;
+
+pub struct ArgsWithBuffer<'a, H> {
+    header: &'a H,
+    pub buffer: &'a [u8],
+}
+
+impl<'a, H: Pod> ArgsWithBuffer<'a, H> {
+    pub fn from_bytes(input: &'a [u8]) -> Result<Self, ProgramError> {
+        let header_size = size_of::<H>();
+
+        if input.len() < header_size {
+            return Err(ProgramError::InvalidInstructionData);
+        }
+
+        let (header_bytes, buffer) = input.split_at(header_size);
+        let header = bytemuck::from_bytes::<H>(header_bytes);
+
+        Ok(Self { header, buffer })
+    }
+}
+
+impl<'a, H> Deref for ArgsWithBuffer<'a, H> {
+    type Target = H;
+    fn deref(&self) -> &Self::Target {
+        self.header
+    }
+}

src/args/args_with_buffer.rs

@@ -1,22 +1,35 @@
+use bytemuck::{Pod, Zeroable};
 use std::mem::size_of;
 
 use borsh::{BorshDeserialize, BorshSerialize};
 
-#[derive(Default, Debug, BorshSerialize, BorshDeserialize)]
+use crate::args::ArgsWithBuffer;
+
+#[repr(C)]
+#[derive(Copy, Clone, Pod, Zeroable)]
 pub struct CommitFinalizeArgs {
-    /// "Nonce" of an account. Updates are submitted historically and nonce incremented by 1
-    /// Deprecated: The ephemeral slot at which the account data is committed
-    pub nonce: u64,
+    pub commit_id: u64,
+
     /// The lamports that the account holds in the ephemeral validator
     pub lamports: u64,
+
     /// Whether the account can be undelegated after the commit completes
     pub allow_undelegation: u8,
+
     /// Whether the account can be undelegated after the commit completes
     pub data_is_diff: u8,
-    /// The account data
-    pub data: Vec<u8>,
+
+    /// bumps of the PDA accounts to be validated by the ix
+    pub delegation_record_bump: u8,
+    pub delegation_metadata_bump: u8,
+    pub validator_fees_vault_bump: u8,
+    pub program_config_bump: u8,
+
+    pub reserved_padding: [u8; 2],
 }
 
+pub type CommitFinalizeArgsWithBuffer<'a> = ArgsWithBuffer<'a, CommitFinalizeArgs>;
+
 #[derive(Default, Debug, BorshSerialize, BorshDeserialize)]
 pub struct CommitStateArgs {
     /// "Nonce" of an account. Updates are submitted historically and nonce incremented by 1

src/args/commit_state.rs

@@ -1,3 +1,4 @@
+mod args_with_buffer;
 mod call_handler;
 mod commit_state;
 mod delegate;
@@ -6,6 +7,7 @@ mod top_up_ephemeral_balance;
 mod validator_claim_fees;
 mod whitelist_validator_for_program;
 
+pub use args_with_buffer::*;
 pub use call_handler::*;
 pub use commit_state::*;
 pub use delegate::*;

src/args/mod.rs

@@ -1,5 +1,6 @@
-use crate::{fast_process_instruction, slow_process_instruction};
+use crate::{error::DlpError, fast_process_instruction, slow_process_instruction};
 
+use pinocchio::program_error::ToStr;
 use solana_program::entrypoint;
 
 entrypoint::custom_heap_default!();
@@ -17,13 +18,17 @@ pub unsafe extern "C" fn entrypoint(input: *mut u8) -> u64 {
 
     let (program_id, count, data) =
         pinocchio::entrypoint::deserialize::<{ pinocchio::MAX_TX_ACCOUNTS }>(input, &mut accounts);
+
     match fast_process_instruction(
         program_id,
         core::slice::from_raw_parts(accounts.as_ptr() as _, count),
         data,
     ) {
         Some(Ok(())) => pinocchio::SUCCESS,
-        Some(Err(error)) => error.into(),
+        Some(Err(error)) => {
+            pinocchio_log::log!("fast_process_instruction: {}", error.to_str::<DlpError>());
+            error.into()
+        }
 
         // Fallback to the slow path that does not use pinocchio SDK.
         None => slow_entrypoint(input),
@@ -39,6 +44,9 @@ pub unsafe fn slow_entrypoint(input: *mut u8) -> u64 {
     let (program_id, accounts, instruction_data) = unsafe { entrypoint::deserialize(input) };
     match slow_process_instruction(program_id, &accounts, instruction_data) {
         Ok(()) => entrypoint::SUCCESS,
-        Err(error) => error.into(),
+        Err(error) => {
+            solana_program::msg!("slow_process_instruction: {}", error);
+            error.into()
+        }
     }
 }

src/entrypoint.rs

@@ -1,8 +1,11 @@
-use num_enum::IntoPrimitive;
+use num_enum::{IntoPrimitive, TryFromPrimitive};
 use solana_program::program_error::ProgramError;
+use strum::IntoStaticStr;
 use thiserror::Error;
 
-#[derive(Debug, Error, Clone, Copy, PartialEq, Eq, IntoPrimitive)]
+#[derive(
+    Debug, Error, Clone, Copy, PartialEq, Eq, IntoPrimitive, TryFromPrimitive, IntoStaticStr,
+)]
 #[repr(u32)]
 pub enum DlpError {
     #[error("Invalid Authority")]
@@ -147,3 +150,12 @@ impl From<DlpError> for pinocchio::program_error::ProgramError {
         pinocchio::program_error::ProgramError::Custom(e as u32)
     }
 }
+
+impl pinocchio::program_error::ToStr for DlpError {
+    fn to_str<E>(&self) -> &'static str
+    where
+        E: 'static + pinocchio::program_error::ToStr + TryFrom<u32>,
+    {
+        self.into()
+    }
+}

src/error.rs

@@ -1,42 +1,69 @@
-use borsh::to_vec;
 use solana_program::instruction::Instruction;
 use solana_program::system_program;
 use solana_program::{instruction::AccountMeta, pubkey::Pubkey};
 
 use crate::args::CommitFinalizeArgs;
 use crate::discriminator::DlpDiscriminator;
-use crate::pda::{
-    delegation_metadata_pda_from_delegated_account, delegation_record_pda_from_delegated_account,
-    program_config_from_program_id, validator_fees_vault_pda_from_validator,
+use crate::pod_view::PodView;
+use crate::{
+    delegation_metadata_seeds_from_delegated_account,
+    delegation_record_seeds_from_delegated_account, program_config_seeds_from_program_id,
+    total_size_budget, validator_fees_vault_seeds_from_validator, AccountSizeClass,
+    DLP_PROGRAM_DATA_SIZE_CLASS,
 };
-use crate::{total_size_budget, AccountSizeClass, DLP_PROGRAM_DATA_SIZE_CLASS};
 
 /// Builds a commit finalize instruction.
 /// See [crate::processor::process_commit_finalize] for docs.
 pub fn commit_finalize(
     validator: Pubkey,
     delegated_account: Pubkey,
     delegated_account_owner: Pubkey,
-    commit_args: CommitFinalizeArgs,
+    commit_args: &mut CommitFinalizeArgs,
+    data: &[u8],
 ) -> Instruction {
-    let commit_args = to_vec(&commit_args).unwrap();
-    let delegation_record_pda = delegation_record_pda_from_delegated_account(&delegated_account);
-    let validator_fees_vault_pda = validator_fees_vault_pda_from_validator(&validator);
-    let delegation_metadata_pda =
-        delegation_metadata_pda_from_delegated_account(&delegated_account);
-    let program_config_pda = program_config_from_program_id(&delegated_account_owner);
+    let delegation_record = Pubkey::find_program_address(
+        delegation_record_seeds_from_delegated_account!(delegated_account),
+        &crate::id(),
+    );
+
+    let validator_fees_vault = Pubkey::find_program_address(
+        validator_fees_vault_seeds_from_validator!(validator),
+        &crate::id(),
+    );
+
+    let delegation_metadata = Pubkey::find_program_address(
+        delegation_metadata_seeds_from_delegated_account!(delegated_account),
+        &crate::id(),
+    );
+
+    let program_config = Pubkey::find_program_address(
+        program_config_seeds_from_program_id!(delegated_account_owner),
+        &crate::id(),
+    );
+
+    // save the bumps in the args
+    commit_args.delegation_record_bump = delegation_record.1;
+    commit_args.delegation_metadata_bump = delegation_metadata.1;
+    commit_args.validator_fees_vault_bump = validator_fees_vault.1;
+    commit_args.program_config_bump = program_config.1;
+
     Instruction {
         program_id: crate::id(),
         accounts: vec![
             AccountMeta::new_readonly(validator, true),
             AccountMeta::new(delegated_account, false),
-            AccountMeta::new_readonly(delegation_record_pda, false),
-            AccountMeta::new(delegation_metadata_pda, false),
-            AccountMeta::new_readonly(validator_fees_vault_pda, false),
-            AccountMeta::new_readonly(program_config_pda, false),
+            AccountMeta::new_readonly(delegation_record.0, false),
+            AccountMeta::new(delegation_metadata.0, false),
+            AccountMeta::new_readonly(validator_fees_vault.0, false),
+            AccountMeta::new_readonly(program_config.0, false),
             AccountMeta::new_readonly(system_program::id(), false),
         ],
-        data: [DlpDiscriminator::CommitFinalize.to_vec(), commit_args].concat(),
+        data: [
+            DlpDiscriminator::CommitFinalize.to_vec(),
+            commit_args.to_bytes(),
+            data.to_vec(),
+        ]
+        .concat(),
     }
 }
 

src/instruction_builder/commit_finalize.rs

@@ -29,6 +29,7 @@ mod discriminator;
 pub mod error;
 pub mod instruction_builder;
 pub mod pda;
+pub mod pod_view;
 pub mod state;
 
 mod account_size_class;
@@ -37,6 +38,7 @@ pub use account_size_class::*;
 
 #[cfg(not(feature = "sdk"))]
 mod diff;
+
 #[cfg(not(feature = "sdk"))]
 mod processor;