✨ link processor to dispatcher

Author: vincentberthier

src/account/mod.rs

@@ -35,7 +35,7 @@ mod types;
 pub use error::Error;
 pub use meta::AccountMeta;
 pub use onchain::wallet::Wallet;
-pub use transaction::{Accounts, TransactionAccount};
+pub use transaction::TransactionAccount;
 pub use types::Writable;
 
 /// The result for the accounts module.

src/account/transaction.rs

@@ -36,6 +36,7 @@ use super::{AccountMeta, Error, Result, Wallet};
 
 /// Stores all data regarding an account needed by an instruction
 /// to allow it to access or modify its data.
+#[derive(Clone)]
 pub struct TransactionAccount<'a> {
     /// The public key of the account
     pub key: Pubkey,
@@ -128,61 +129,6 @@ impl<'a> TransactionAccount<'a> {
     }
 }
 
-/// List of accounts use in an instruction.
-pub struct Accounts<'a> {
-    accounts: &'a [TransactionAccount<'a>],
-    current: RefCell<usize>,
-}
-
-impl<'a> Accounts<'a> {
-    /// Program utility to access the instruction's accounts.
-    ///
-    /// # Parameters
-    /// * `accounts` - the accounts in an instruction,
-    ///
-    /// # Example
-    /// ```rust
-    /// # use bifrost::Error;
-    /// # use bifrost::{crypto::Keypair, account::{Writable, Wallet, AccountMeta, TransactionAccount, Accounts}};
-    /// let key1 = Keypair::generate().pubkey();
-    /// let key2 = Keypair::generate().pubkey();
-    /// let meta1 = AccountMeta::signing(key1, Writable::Yes)?;
-    /// let meta2 = AccountMeta::wallet(key2, Writable::Yes)?;
-    /// let mut wallet1 = Wallet { prisms: 1_000 };
-    /// let mut wallet2 = Wallet { prisms: 0 };
-    ///
-    /// let accounts_vec = vec![
-    ///     TransactionAccount::new(&meta1, &mut wallet1),
-    ///     TransactionAccount::new(&meta2, &mut wallet2),
-    /// ];
-    /// let accounts = Accounts::new(accounts_vec.as_slice());
-    /// # Ok::<(), Error>(())
-    /// ```
-    #[must_use]
-    pub const fn new(accounts: &'a [TransactionAccount<'a>]) -> Self {
-        Self {
-            accounts,
-            current: RefCell::new(0),
-        }
-    }
-
-    /// Get the next account in the list.
-    ///
-    /// # Errors
-    /// If there are no next account.
-    #[must_use]
-    #[instrument(skip(self), fields(current = *self.current.borrow(), len = self.accounts.len()))]
-    pub fn next(&self) -> Result<&'a TransactionAccount> {
-        debug!("getting account");
-        let res = self
-            .accounts
-            .get(*self.current.borrow())
-            .ok_or(Error::MissingAccounts)?;
-        *self.current.borrow_mut() += 1;
-        Ok(res)
-    }
-}
-
 #[cfg(test)]
 #[cfg_attr(coverage_nightly, coverage(off))]
 mod tests {

src/io/index.rs

@@ -66,11 +66,14 @@ impl Index {
         read_from_file(index_path).await
     }
 
+    #[instrument(skip(self))]
     pub async fn load(&self, key: &Pubkey) -> Result<Option<Wallet>> {
         let Some(loc) = self.find(key) else {
+            trace!("account was not found in the index");
             return Ok(None);
         };
 
+        trace!("account was found, reading it from the disk");
         Some(loc.read().await).transpose()
     }
 

src/io/mod.rs

@@ -36,7 +36,7 @@ mod vault;
 pub use error::Error;
 type Result<T> = core::result::Result<T, Error>;
 
-pub use vault::Vault;
+pub use vault::{set_vault_path, Vault};
 
 /// Maximum size for an account file.
 #[cfg(test)]

src/io/support.rs

@@ -32,7 +32,7 @@ use borsh::{BorshDeserialize, BorshSerialize};
 use memmap2::MmapOptions;
 use tokio::{
     fs::{self, File, OpenOptions},
-    io::AsyncWriteExt as _,
+    io::AsyncWriteExt,
     sync::Semaphore,
 };
 use tracing::{debug, instrument, trace};
@@ -105,7 +105,9 @@ where
         .truncate(true)
         .open(path.into())
         .await?;
-    Ok(file.write_all(&data).await?)
+    file.write_all(&data).await?;
+    file.flush().await?;
+    Ok(())
 }
 
 #[expect(clippy::unwrap_used)]
@@ -125,6 +127,7 @@ where
     let _guard = SEMAPHORE.acquire().await?;
     let offset = file.metadata().await?.len();
     file.write_all(&data).await?;
+    file.flush().await?;
     Ok((data.len() as u64, offset))
 }
 

src/io/vault.rs

@@ -43,6 +43,13 @@ use super::{
 
 pub static VAULT_PATH: OnceLock<PathBuf> = OnceLock::new();
 
+/// Sets the path where the vault will be stored on disk.
+///
+/// # Parameters
+/// * `path` - Path to the on-disk vault.
+///
+/// # Errors
+/// if the vault can not be created on the given path.
 #[mutants::skip]
 #[expect(clippy::unwrap_used)]
 pub fn set_vault_path<P>(path: P)

src/program/dispatcher.rs

@@ -1,20 +1,32 @@
 use tracing::{debug, instrument};
 
-use crate::{account::Accounts, transaction::Instruction};
+use crate::{account::TransactionAccount, crypto::Pubkey};
 
 use super::{
     system::{self, SYSTEM_PROGRAM},
     Error, Result,
 };
 
+/// Dispatches an instruction to the program handling it.
+///
+/// # Parameters
+/// * `instruction` - The instruction to execute,
+/// * `accounts` - The accounts referenced by the instruction.
+///
+/// # Errors
+/// If the program is unknown or failed to run.
 #[instrument(skip_all)]
-fn dispatch<'a>(instruction: &Instruction, accounts: &'a Accounts<'a>) -> Result<()> {
+pub fn dispatch<'a>(
+    program: &Pubkey,
+    accounts: &[TransactionAccount],
+    payload: &[u8],
+) -> Result<()> {
     debug!(
-        program = %instruction.program(),
+        %program,
         "received new instruction to handle"
     );
-    match *instruction.program() {
-        SYSTEM_PROGRAM => system::execute_instruction(accounts, instruction.data()),
+    match *program {
+        SYSTEM_PROGRAM => system::execute_instruction(accounts, payload),
         key => Err(Error::UnknownProgram { key }),
     }
 }
@@ -27,9 +39,10 @@ mod tests {
 
     use test_log::test;
 
-    use crate::account::{AccountMeta, Accounts, TransactionAccount, Wallet, Writable};
+    use crate::account::{AccountMeta, TransactionAccount, Wallet, Writable};
     use crate::crypto::Keypair;
     use crate::program::system;
+    use crate::transaction::Instruction;
 
     // use super::super::Error;
     use super::*;
@@ -50,12 +63,11 @@ mod tests {
             TransactionAccount::new(&meta1, &mut wallet1),
             TransactionAccount::new(&meta2, &mut wallet2),
         ];
-        let accounts = Accounts::new(accounts_vec.as_slice());
 
         let instruction = system::instruction::transfer(key1, key2, AMOUNT)?;
 
         // When
-        dispatch(&instruction, &accounts)?;
+        dispatch(&SYSTEM_PROGRAM, &accounts_vec, instruction.data())?;
 
         // Then
         assert_eq!(wallet1.prisms, 0);
@@ -80,12 +92,11 @@ mod tests {
             TransactionAccount::new(&meta1, &mut wallet1),
             TransactionAccount::new(&meta2, &mut wallet2),
         ];
-        let accounts = Accounts::new(accounts_vec.as_slice());
 
         let instruction = Instruction::new(program, [meta1, meta2], &Vec::<u8>::new());
 
         // When
-        let res = dispatch(&instruction, &accounts);
+        let res = dispatch(&program, &accounts_vec, instruction.data());
 
         // Then
         assert_matches!(res, Err(err) if matches!(err, Error::UnknownProgram { key } if key == program));

src/program/system.rs

@@ -29,14 +29,14 @@
 use borsh::{BorshDeserialize, BorshSerialize};
 use tracing::{debug, instrument};
 
-use crate::{account::Accounts, crypto::Pubkey};
+use crate::{account::TransactionAccount, crypto::Pubkey};
 
 use super::{Error, Result};
 
 /// The System's program id (`BifrostSystemProgram111111111111111111111111`)
 pub const SYSTEM_PROGRAM: Pubkey = Pubkey::from_bytes(&[
-    159, 65, 158, 196, 5, 83, 96, 13, 242, 56, 2, 138, 167, 225, 20, 157, 169, 199, 82, 249, 248,
-    91, 220, 170, 46, 53, 235, 98, 98, 0, 0, 0,
+    2, 190, 236, 171, 26, 147, 23, 185, 158, 168, 176, 152, 117, 167, 48, 232, 60, 78, 120, 154,
+    96, 248, 193, 153, 0, 203, 246, 209, 37, 0, 0, 0,
 ]);
 
 #[derive(Debug, BorshSerialize, BorshDeserialize)]
@@ -53,24 +53,28 @@ enum SystemInstruction {
 /// # Errors
 /// if the instruction fails to complete (missing accounts, arithmetic overflows, *etc.*).
 #[instrument(skip_all)]
-pub fn execute_instruction<'a>(accounts: &'a Accounts<'a>, payload: &[u8]) -> Result<()> {
+pub fn execute_instruction<'a>(accounts: &'a [TransactionAccount], payload: &[u8]) -> Result<()> {
     debug!("received system insruction");
     match borsh::from_slice(payload)? {
         SystemInstruction::Transfer(amount) => transfer(accounts, amount),
     }
 }
 
 #[instrument(skip(accounts))]
-fn transfer<'a>(accounts: &'a Accounts<'a>, amount: u64) -> Result<()> {
+fn transfer<'a>(accounts: &'a [TransactionAccount], amount: u64) -> Result<()> {
     debug!("transferring prisms");
-    let payer = accounts.next()?;
+    if accounts.len() != 2 {
+        return Err(Error::Account(crate::account::Error::MissingAccounts));
+    }
+    assert!(accounts.len() > 1, "missing accounts");
+    let payer = &accounts[0];
     if !payer.is_signer {
         return Err(Error::Custom(format!(
             "{} must be a signing account",
             payer.key
         )));
     }
-    let receiver = accounts.next()?;
+    let receiver = &accounts[1];
     debug!("from {} to {}", payer.key, receiver.key);
     payer.sub_prisms(amount)?;
     receiver.add_prisms(amount)?;
@@ -140,12 +144,11 @@ mod tests {
             TransactionAccount::new(&meta1, &mut wallet1),
             TransactionAccount::new(&meta2, &mut wallet2),
         ];
-        let accounts = Accounts::new(accounts_vec.as_slice());
 
         let payload = borsh::to_vec(&SystemInstruction::Transfer(100)).unwrap();
 
         // When
-        execute_instruction(&accounts, &payload)?;
+        execute_instruction(&accounts_vec, &payload)?;
 
         // Then
         assert_eq!(wallet1.prisms, AMOUNT - 100);
@@ -163,13 +166,12 @@ mod tests {
         let mut wallet1 = Wallet { prisms: AMOUNT };
 
         let accounts_vec = vec![TransactionAccount::new(&meta1, &mut wallet1)];
-        let accounts = Accounts::new(accounts_vec.as_slice());
 
         #[expect(clippy::unwrap_used)]
         let payload = borsh::to_vec(&SystemInstruction::Transfer(100)).unwrap();
 
         // When
-        let res = execute_instruction(&accounts, &payload);
+        let res = execute_instruction(&accounts_vec, &payload);
 
         // Then
         assert_matches!(res, Err(error) if matches!(error, Error::Account(_)));
@@ -192,13 +194,12 @@ mod tests {
             TransactionAccount::new(&meta1, &mut wallet1),
             TransactionAccount::new(&meta2, &mut wallet2),
         ];
-        let accounts = Accounts::new(accounts_vec.as_slice());
 
         #[expect(clippy::unwrap_used)]
         let payload = borsh::to_vec(&SystemInstruction::Transfer(100)).unwrap();
 
         // When
-        let res = execute_instruction(&accounts, &payload);
+        let res = execute_instruction(&accounts_vec, &payload);
 
         // Then
         assert_matches!(res, Err(error) if matches!(error, Error::Custom { .. }));

src/transaction/instruction.rs

@@ -30,11 +30,15 @@ use borsh::{BorshDeserialize, BorshSerialize};
 
 use crate::{account::AccountMeta, crypto::Pubkey};
 
+/// An instruction compiled and ready to be executed on the blockchain.
 #[derive(Clone, Debug, Default, BorshSerialize, BorshDeserialize)]
 pub struct CompiledInstruction {
-    program_account_id: u8,
-    data: Vec<u8>,
-    accounts: Vec<u8>,
+    /// The id in the message's accounts of the program executing this instruction.
+    pub program_account_id: u8,
+    /// The payload for the instruction.
+    pub data: Vec<u8>,
+    /// The id in the message's accounts of the accounts referenced by the instruction.
+    pub accounts: Vec<u8>,
 }
 
 /// An instruction to execute on the blockchain.
@@ -110,6 +114,13 @@ impl Instruction {
 }
 
 impl CompiledInstruction {
+    /// Creates a new compiled instruction.
+    ///
+    /// # Parameters
+    /// * `program_account_id` - The id of the program in the [`Message`]'s accounts.
+    /// * `data` - The instruction's payload,
+    /// * `accounts` - The id of the accounts referenced by the instruction in the [`Message`]'s accounts.
+    #[must_use]
     pub const fn new(program_account_id: u8, data: Vec<u8>, accounts: Vec<u8>) -> Self {
         Self {
             program_account_id,

src/transaction/message.rs

@@ -44,9 +44,9 @@ pub struct Message {
     /// Slot at which the transaction was created
     slot: u64,
     /// The instruction of a transaction.
-    instructions: Vec<CompiledInstruction>,
+    pub instructions: Vec<CompiledInstruction>,
     /// List of accounts referenced by the transaction's instructions.
-    accounts: Vec<AccountMeta>,
+    pub accounts: Vec<AccountMeta>,
 }
 
 impl Message {

src/transaction/mod.rs

@@ -34,5 +34,5 @@ mod transaction;
 pub use error::Error;
 type Result<T> = core::result::Result<T, Error>;
 
-pub use instruction::Instruction;
+pub use instruction::{CompiledInstruction, Instruction};
 pub use transaction::Transaction;

src/transaction/transaction.rs

@@ -199,6 +199,12 @@ impl Transaction {
             .collect::<Vec<_>>()
     }
 
+    /// Get the message for the transaction.
+    #[must_use]
+    pub const fn message(&self) -> &Message {
+        &self.message
+    }
+
     #[instrument(skip_all)]
     fn validate_signers(&self, signers: &[Pubkey]) -> Result<()> {
         debug!("check that there’s a 1 to 1 match between signatures and signers");

src/validator/error.rs

@@ -35,6 +35,15 @@ pub enum Error {
     /// The transaction's signatures are missing or do not match the expectation.
     #[display("the transaction’s signatures are invalid")]
     InvalidTransactionSignatures,
+    /// When the lock on the vault could not be obtained.
+    #[display("the lock on the vault could not be obtained")]
+    VaultLock,
+    /// An error occurred in the vault
+    #[from]
+    Io(crate::io::Error),
+    /// An error occurred while running a program.
+    #[from]
+    Program(crate::program::Error),
 }
 
 impl core::error::Error for Error {}