feat: add CommitFinalizeFromBuffer

Author: snawaz

src/discriminator.rs

@@ -47,6 +47,9 @@ pub enum DlpDiscriminator {
 
     /// See [crate::processor::process_commit_finalize] for docs.
     CommitFinalize = 20,
+
+    /// See [crate::processor::process_commit_finalize_from_buffer] for docs.
+    CommitFinalizeFromBuffer = 21,
 }
 
 impl DlpDiscriminator {

src/instruction_builder/commit_finalize_from_buffer.rs

@@ -0,0 +1,97 @@
+use solana_program::instruction::Instruction;
+use solana_program::system_program;
+use solana_program::{instruction::AccountMeta, pubkey::Pubkey};
+
+use crate::args::{CommitBumps, CommitFinalizeArgs};
+use crate::discriminator::DlpDiscriminator;
+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,
+};
+
+/// Builds a commit state from buffer instruction.
+/// See [crate::processor::process_commit_diff_from_buffer] for docs.
+pub fn commit_finalize_from_buffer(
+    validator: Pubkey,
+    delegated_account: Pubkey,
+    delegated_account_owner: Pubkey,
+    data_buffer: Pubkey,
+    commit_args: &mut CommitFinalizeArgs,
+) -> (Instruction, super::CommitPDAs) {
+    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.bumps = CommitBumps {
+        delegation_record: delegation_record.1,
+        delegation_metadata: delegation_metadata.1,
+        validator_fees_vault: validator_fees_vault.1,
+        program_config: 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.0, false),
+                AccountMeta::new(delegation_metadata.0, false),
+                AccountMeta::new_readonly(data_buffer, 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::CommitFinalizeFromBuffer.to_vec(),
+                commit_args.to_bytes(),
+            ]
+            .concat(),
+        },
+        super::CommitPDAs {
+            delegation_record: delegation_record.0,
+            delegation_metadata: delegation_metadata.0,
+            validator_fees_vault: validator_fees_vault.0,
+            program_config: program_config.0,
+        },
+    )
+}
+
+///
+/// Returns accounts-data-size budget for commit_diff_from_buffer instruction.
+///
+/// This value can be used with ComputeBudgetInstruction::SetLoadedAccountsDataSizeLimit
+///
+pub fn commit_finalize_from_buffer_size_budget(delegated_account: AccountSizeClass) -> u32 {
+    total_size_budget(&[
+        DLP_PROGRAM_DATA_SIZE_CLASS,
+        AccountSizeClass::Tiny, // validator
+        delegated_account,      // delegated_account
+        AccountSizeClass::Tiny, // delegation_record_pda
+        AccountSizeClass::Tiny, // delegation_metadata_pda
+        delegated_account,      // data_buffer
+        AccountSizeClass::Tiny, // validator_fees_vault_pda
+        AccountSizeClass::Tiny, // program_config_pda
+        AccountSizeClass::Tiny, // system_program
+    ])
+}

src/instruction_builder/mod.rs

@@ -4,6 +4,7 @@ mod close_validator_fees_vault;
 mod commit_diff;
 mod commit_diff_from_buffer;
 mod commit_finalize;
+mod commit_finalize_from_buffer;
 mod commit_state;
 mod commit_state_from_buffer;
 mod delegate;
@@ -24,6 +25,7 @@ pub use close_validator_fees_vault::*;
 pub use commit_diff::*;
 pub use commit_diff_from_buffer::*;
 pub use commit_finalize::*;
+pub use commit_finalize_from_buffer::*;
 pub use commit_state::*;
 pub use commit_state_from_buffer::*;
 pub use delegate::*;

src/lib.rs

@@ -121,6 +121,9 @@ pub fn fast_process_instruction(
         DlpDiscriminator::CommitFinalize => Some(processor::fast::process_commit_finalize(
             program_id, accounts, data,
         )),
+        DlpDiscriminator::CommitFinalizeFromBuffer => Some(
+            processor::fast::process_commit_finalize_from_buffer(program_id, accounts, data),
+        ),
         DlpDiscriminator::Finalize => Some(processor::fast::process_finalize(
             program_id, accounts, data,
         )),

src/processor/fast/commit_finalize_from_buffer.rs

@@ -0,0 +1,84 @@
+use pinocchio::{account_info::AccountInfo, pubkey::Pubkey, ProgramResult};
+use pinocchio_log::log;
+
+use crate::args::CommitFinalizeArgs;
+use crate::pod_view::PodView;
+use crate::processor::fast::internal::{
+    process_commit_finalize_internal, CommitFinalizeInternalArgs,
+};
+use crate::processor::fast::NewState;
+use crate::{require_n_accounts, DiffSet};
+
+/// Commit a new state of a delegated PDA
+///
+/// Accounts:
+///
+/// 0: `[signer]`   the validator requesting the commit
+/// 1: `[]`         the delegated account
+/// 2: `[writable]` the PDA storing the new state
+/// 3: `[writable]` the PDA storing the commit record
+/// 4: `[]`         the delegation record
+/// 5: `[writable]` the delegation metadata
+/// 6: `[]`         the validator fees vault
+/// 7: `[]`         the program config account
+///
+/// Instruction Data: CommitFinalizeArgs
+///
+/// Requirements:
+///
+/// - delegation record is initialized
+/// - delegation metadata is initialized
+/// - validator fees vault is initialized
+/// - program config is initialized
+/// - commit state is uninitialized
+/// - commit record is uninitialized
+/// - delegated account holds at least the lamports indicated in the delegation record
+/// - account was not committed at a later slot
+///
+/// Steps:
+/// 1. Check that the pda is delegated
+/// 2. Init a new PDA to store the new state
+/// 3. Copy the new state to the new PDA
+/// 4. Init a new PDA to store the record of the new state commitment
+pub fn process_commit_finalize_from_buffer(
+    _program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    data: &[u8],
+) -> ProgramResult {
+    let [
+        validator, // force multi-line
+        delegated_account,
+        delegation_record_account,
+        delegation_metadata_account,
+        data_account, // full bytes or diff 
+        validator_fees_vault,
+        program_config_account,
+        _system_program,
+    ] = require_n_accounts!(accounts, 8);
+
+    let args = CommitFinalizeArgs::try_view_from(data)?;
+
+    let data = data_account.try_borrow_data()?;
+    let commit_args = CommitFinalizeInternalArgs {
+        bumps: &args.bumps,
+        new_state: if args.data_is_diff.is_true() {
+            let diffset = DiffSet::try_new(data.as_ref())?;
+            if diffset.segments_count() == 0 {
+                log!("WARN: noop; empty diff sent");
+            }
+            NewState::Diff(diffset)
+        } else {
+            NewState::FullBytes(&data)
+        },
+        commit_id: args.commit_id,
+        allow_undelegation: args.allow_undelegation.is_true(),
+        validator,
+        delegated_account,
+        delegation_record_account,
+        delegation_metadata_account,
+        validator_fees_vault,
+        program_config_account,
+    };
+
+    process_commit_finalize_internal(commit_args)
+}

src/processor/fast/mod.rs

@@ -1,6 +1,7 @@
 mod commit_diff;
 mod commit_diff_from_buffer;
 mod commit_finalize;
+mod commit_finalize_from_buffer;
 mod commit_state;
 mod commit_state_from_buffer;
 mod delegate;
@@ -14,6 +15,7 @@ pub(crate) mod internal;
 pub use commit_diff::*;
 pub use commit_diff_from_buffer::*;
 pub use commit_finalize::*;
+pub use commit_finalize_from_buffer::*;
 pub use commit_state::*;
 pub use commit_state_from_buffer::*;
 pub use delegate::*;

src/processor/fast/utils/requires.rs

@@ -414,6 +414,8 @@ pub fn require_owned_pda(
     if !pubkey_eq(info.owner(), owner) {
         log!("Invalid account owner for {}:", label);
         pubkey::log(info.key());
+        pubkey::log(info.owner());
+        pubkey::log(owner);
         return Err(ProgramError::InvalidAccountOwner);
     }
     Ok(())

src/processor/init_validator_fees_vault.rs

@@ -16,7 +16,7 @@ use crate::validator_fees_vault_seeds_from_validator;
 /// Accounts:
 ///
 /// 0; `[signer]` payer
-/// 1; `[signer]` admin that controls the vault
+/// 1; `[signer]` magicblock admin that controls the vault
 /// 2; `[]`       validator_identity
 /// 3; `[]`       validator_fees_vault_pda
 /// 4; `[]`       system_program

tests/test_commit_finalize.rs

@@ -58,7 +58,7 @@ async fn test_commit_finalize_perf() {
 
         let metadata = metadata.unwrap();
 
-        assertables::assert_lt!(metadata.compute_units_consumed, 1100);
+        assertables::assert_lt!(metadata.compute_units_consumed, 1150);
 
         assert_eq!(
             metadata.log_messages.len(),