[message-buffer 10/X] - Message Buffer Admin IXs & variable length (#779)

* ok

* ok

* it runs

* add this stuff

* working on tests

* feat(message-buffer): finish create_buffer ix, update put_all

* feat: rename bufferheader to messageBuffer, add delete_buffer impl

* feat(message-buffer): remove unused code, add additional checks, update unit tests

* style(message-buffer): fix pre-commit, run fmt & clippy

* fix(message-buffer): add verification checks, fix ts test

* refactor(message-buffer): rename update_whitelist_authority to admin

* fix(message-buffer): address PR comments

---------

Co-authored-by: Jayant Krishnamurthy <[email protected]>

Author: swimricky

.pre-commit-config.yaml

@@ -71,13 +71,13 @@ repos:
         language: "rust"
         entry: cargo +nightly fmt --manifest-path ./message_buffer/Cargo.toml --all -- --config-path rustfmt.toml
         pass_filenames: false
-        files: accumulator_updater
+        files: message_buffer
       - id: cargo-clippy-message-buffer
         name: Cargo clippy for message buffer contract
         language: "rust"
         entry: cargo +nightly clippy --manifest-path ./message_buffer/Cargo.toml --tests --fix --allow-dirty --allow-staged -- -D warnings
         pass_filenames: false
-        files: accumulator_updater
+        files: message_buffer
       # Hooks for solana receiver contract
       - id: cargo-fmt-solana-receiver
         name: Cargo format for solana target chain contract

message_buffer/programs/message_buffer/src/instructions/create_buffer.rs

@@ -0,0 +1,152 @@
+use {
+    crate::{
+        instructions::is_uninitialized_account,
+        state::*,
+        MessageBufferError,
+        MESSAGE,
+    },
+    anchor_lang::{
+        prelude::*,
+        solana_program::entrypoint::MAX_PERMITTED_DATA_INCREASE,
+        system_program::{
+            self,
+            Allocate,
+            Assign,
+            Transfer,
+        },
+    },
+};
+
+pub fn create_buffer<'info>(
+    ctx: Context<'_, '_, '_, 'info, CreateBuffer<'info>>,
+    allowed_program_auth: Pubkey,
+    base_account_key: Pubkey,
+    target_size: u32,
+) -> Result<()> {
+    let buffer_account = ctx
+        .remaining_accounts
+        .first()
+        .ok_or(MessageBufferError::MessageBufferNotProvided)?;
+
+    ctx.accounts
+        .whitelist
+        .is_allowed_program_auth(&allowed_program_auth)?;
+
+    require_gte!(
+        target_size,
+        MessageBuffer::HEADER_LEN as u32,
+        MessageBufferError::MessageBufferTooSmall
+    );
+
+    require_gte!(
+        MAX_PERMITTED_DATA_INCREASE,
+        target_size as usize,
+        MessageBufferError::TargetSizeDeltaExceeded
+    );
+    if is_uninitialized_account(buffer_account) {
+        let (pda, bump) = Pubkey::find_program_address(
+            &[
+                allowed_program_auth.as_ref(),
+                MESSAGE.as_bytes(),
+                base_account_key.as_ref(),
+            ],
+            &crate::ID,
+        );
+        require_keys_eq!(buffer_account.key(), pda);
+        let signer_seeds = [
+            allowed_program_auth.as_ref(),
+            MESSAGE.as_bytes(),
+            base_account_key.as_ref(),
+            &[bump],
+        ];
+
+        CreateBuffer::create_account(
+            buffer_account,
+            target_size as usize,
+            &ctx.accounts.admin,
+            &[signer_seeds.as_slice()],
+            &ctx.accounts.system_program,
+        )?;
+
+        let loader =
+            AccountLoader::<MessageBuffer>::try_from_unchecked(&crate::ID, buffer_account)?;
+        {
+            let mut message_buffer = loader.load_init()?;
+            *message_buffer = MessageBuffer::new(bump);
+        }
+        loader.exit(&crate::ID)?;
+    }
+
+    Ok(())
+}
+
+
+#[derive(Accounts)]
+pub struct CreateBuffer<'info> {
+    #[account(
+    seeds = [b"message".as_ref(), b"whitelist".as_ref()],
+    bump = whitelist.bump,
+    has_one = admin,
+    )]
+    pub whitelist: Account<'info, Whitelist>,
+
+    // Also pays for account creation
+    #[account(mut)]
+    pub admin: Signer<'info>,
+
+    pub system_program: Program<'info, System>,
+    // remaining_accounts:  - [AccumulatorInput PDA]
+}
+
+
+impl<'info> CreateBuffer<'info> {
+    /// Manually invoke transfer, allocate & assign ixs to create an account
+    /// to handle situation where an account already has lamports
+    /// since system_program::create_account will fail in this case
+    fn create_account<'a>(
+        new_account_info: &AccountInfo<'a>,
+        space: usize,
+        payer: &Signer<'a>,
+        seeds: &[&[&[u8]]],
+        system_program: &AccountInfo<'a>,
+    ) -> Result<()> {
+        let target_rent = Rent::get()?.minimum_balance(space);
+        if new_account_info.lamports() < target_rent {
+            system_program::transfer(
+                CpiContext::new_with_signer(
+                    system_program.to_account_info(),
+                    Transfer {
+                        from: payer.to_account_info(),
+                        to:   new_account_info.to_account_info(),
+                    },
+                    seeds,
+                ),
+                target_rent - new_account_info.lamports(),
+            )?;
+        };
+
+        system_program::allocate(
+            CpiContext::new_with_signer(
+                system_program.to_account_info(),
+                Allocate {
+                    account_to_allocate: new_account_info.to_account_info(),
+                },
+                seeds,
+            ),
+            space.try_into().unwrap(),
+        )?;
+
+        system_program::assign(
+            CpiContext::new_with_signer(
+                system_program.to_account_info(),
+                Assign {
+                    account_to_assign: new_account_info.to_account_info(),
+                },
+                seeds,
+            ),
+            &crate::ID,
+        )?;
+
+        Ok(())
+    }
+}

message_buffer/programs/message_buffer/src/instructions/delete_buffer.rs

@@ -0,0 +1,65 @@
+use {
+    crate::{
+        instructions::verify_message_buffer,
+        state::*,
+        MessageBufferError,
+        MESSAGE,
+    },
+    anchor_lang::prelude::*,
+};
+
+pub fn delete_buffer<'info>(
+    ctx: Context<'_, '_, '_, 'info, DeleteBuffer<'info>>,
+    allowed_program_auth: Pubkey,
+    base_account_key: Pubkey,
+    bump: u8,
+) -> Result<()> {
+    let message_buffer_account_info = ctx
+        .remaining_accounts
+        .first()
+        .ok_or(MessageBufferError::MessageBufferNotProvided)?;
+
+    ctx.accounts
+        .whitelist
+        .is_allowed_program_auth(&allowed_program_auth)?;
+
+    verify_message_buffer(message_buffer_account_info)?;
+
+    let expected_key = Pubkey::create_program_address(
+        &[
+            allowed_program_auth.as_ref(),
+            MESSAGE.as_bytes(),
+            base_account_key.as_ref(),
+            &[bump],
+        ],
+        &crate::ID,
+    )
+    .map_err(|_| MessageBufferError::InvalidPDA)?;
+
+    require_keys_eq!(
+        message_buffer_account_info.key(),
+        expected_key,
+        MessageBufferError::InvalidPDA
+    );
+    let loader = AccountLoader::<MessageBuffer>::try_from_unchecked(
+        &crate::ID,
+        message_buffer_account_info,
+    )?;
+    loader.close(ctx.accounts.admin.to_account_info())?;
+    Ok(())
+}
+
+#[derive(Accounts)]
+pub struct DeleteBuffer<'info> {
+    #[account(
+        seeds = [b"message".as_ref(), b"whitelist".as_ref()],
+        bump = whitelist.bump,
+        has_one = admin,
+    )]
+    pub whitelist: Account<'info, Whitelist>,
+
+    // Also the recipient of the lamports from closing the buffer account
+    #[account(mut)]
+    pub admin: Signer<'info>,
+    // remaining_account:  - [AccumulatorInput PDA]
+}

message_buffer/programs/message_buffer/src/instructions/mod.rs

@@ -1,3 +1,56 @@
-pub use put_all::*;
+use {
+    crate::{
+        state::MessageBuffer,
+        MessageBufferError,
+    },
+    anchor_lang::{
+        prelude::*,
+        system_program,
+        Discriminator,
+    },
+};
+pub use {
+    create_buffer::*,
+    delete_buffer::*,
+    put_all::*,
+    resize_buffer::*,
+};
 
+
+mod create_buffer;
+mod delete_buffer;
 mod put_all;
+mod resize_buffer;
+
+// String constants for deriving PDAs.
+// An authorized program's message buffer will have PDA seeds [authorized_program_pda, MESSAGE, base_account_key],
+// where authorized_program_pda is the
+pub const MESSAGE: &str = "message";
+pub const FUND: &str = "fund";
+
+
+pub fn is_uninitialized_account(ai: &AccountInfo) -> bool {
+    ai.data_is_empty() && ai.owner == &system_program::ID
+}
+
+/// Verify message buffer account is initialized and has the correct discriminator.
+///
+/// Note: manually checking because using anchor's `AccountLoader.load()`
+/// will panic since the `AccountInfo.data_len()` will not match the
+/// size of the `MessageBuffer` since the `MessageBuffer` struct does not
+/// include the messages.
+pub fn verify_message_buffer(message_buffer_account_info: &AccountInfo) -> Result<()> {
+    if is_uninitialized_account(message_buffer_account_info) {
+        return err!(MessageBufferError::MessageBufferUninitialized);
+    }
+    let data = message_buffer_account_info.try_borrow_data()?;
+    if data.len() < MessageBuffer::discriminator().len() {
+        return Err(ErrorCode::AccountDiscriminatorNotFound.into());
+    }
+
+    let disc_bytes = &data[0..8];
+    if disc_bytes != &MessageBuffer::discriminator() {
+        return Err(ErrorCode::AccountDiscriminatorMismatch.into());
+    }
+    Ok(())
+}