minor refactor

nssa/core/src/account/mod.rs

@@ -44,7 +44,7 @@ mod tests {
     fn test_empty_data_account_data_creation() {
         let new_acc = Account::default();
 
-        assert_eq!(new_acc.data, vec![]);
+        assert!(new_acc.data.is_empty());
     }
 
     #[test]

nssa/program_methods/guest/src/bin/authenticated_transfer.rs

@@ -1,12 +1,14 @@
 use nssa_core::program::read_nssa_inputs;
 use risc0_zkvm::guest::env;
 
+type Instruction = u128;
+
 /// A transfer of balance program.
 /// To be used both in public and private contexts.
 fn main() {
     // Read input accounts.
     // It is expected to receive only two accounts: [sender_account, receiver_account]
-    let (input_accounts, balance_to_move) = read_nssa_inputs::<u128>();
+    let (input_accounts, balance_to_move) = read_nssa_inputs::<Instruction>();
 
     // Continue only if input_accounts is an array of two elements
     let [sender, receiver] = match input_accounts.try_into() {

nssa/src/program.rs

@@ -4,7 +4,7 @@ use nssa_core::{
 };
 use program_methods::{AUTHENTICATED_TRANSFER_ELF, AUTHENTICATED_TRANSFER_ID};
 use risc0_zkvm::{ExecutorEnv, ExecutorEnvBuilder, default_executor, serde::to_vec};
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
 
 use crate::error::NssaError;
 

nssa/src/public_transaction/message.rs

@@ -4,7 +4,7 @@ use nssa_core::{
 };
 use serde::{Deserialize, Serialize};
 
-use crate::Address;
+use crate::{Address, program::Program};
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct Message {
@@ -15,12 +15,13 @@ pub struct Message {
 }
 
 impl Message {
-    pub fn new(
+    pub fn new<T: Serialize>(
         program_id: ProgramId,
         addresses: Vec<Address>,
         nonces: Vec<Nonce>,
-        instruction_data: InstructionData,
+        instruction: T,
     ) -> Self {
+        let instruction_data = Program::serialize_instruction_data(instruction).unwrap();
         Self {
             program_id,
             addresses,

nssa/src/tests/state_tests.rs

@@ -14,8 +14,7 @@ fn transfer_transaction(
     let addresses = vec![from, to];
     let nonces = vec![nonce];
     let program_id = Program::authenticated_transfer_program().id();
-    let instruction_data = Program::serialize_instruction_data(&balance).unwrap();
-    let message = public_transaction::Message::new(program_id, addresses, nonces, instruction_data);
+    let message = public_transaction::Message::new(program_id, addresses, nonces, balance);
     let witness_set = public_transaction::WitnessSet::for_message(&message, &[&from_key]);
     PublicTransaction::new(message, witness_set)
 }

nssa/src/tests/valid_execution_tests.rs

@@ -10,7 +10,7 @@ fn test_program_should_fail_if_modifies_nonces() {
     let mut state = V01State::new_with_genesis_accounts(&initial_data).with_test_programs();
     let addresses = vec![Address::new([1; 32])];
     let program_id = Program::nonce_changer_program().id();
-    let message = public_transaction::Message::new(program_id, addresses, vec![], vec![]);
+    let message = public_transaction::Message::new(program_id, addresses, vec![], ());
     let witness_set = public_transaction::WitnessSet::for_message(&message, &[]);
     let tx = PublicTransaction::new(message, witness_set);
 
@@ -25,7 +25,7 @@ fn test_program_should_fail_if_output_accounts_exceed_inputs() {
     let mut state = V01State::new_with_genesis_accounts(&initial_data).with_test_programs();
     let addresses = vec![Address::new([1; 32])];
     let program_id = Program::extra_output_program().id();
-    let message = public_transaction::Message::new(program_id, addresses, vec![], vec![]);
+    let message = public_transaction::Message::new(program_id, addresses, vec![], ());
     let witness_set = public_transaction::WitnessSet::for_message(&message, &[]);
     let tx = PublicTransaction::new(message, witness_set);
 
@@ -40,7 +40,7 @@ fn test_program_should_fail_with_missing_output_accounts() {
     let mut state = V01State::new_with_genesis_accounts(&initial_data).with_test_programs();
     let addresses = vec![Address::new([1; 32]), Address::new([2; 32])];
     let program_id = Program::missing_output_program().id();
-    let message = public_transaction::Message::new(program_id, addresses, vec![], vec![]);
+    let message = public_transaction::Message::new(program_id, addresses, vec![], ());
     let witness_set = public_transaction::WitnessSet::for_message(&message, &[]);
     let tx = PublicTransaction::new(message, witness_set);
 
@@ -61,7 +61,7 @@ fn test_program_should_fail_if_modifies_program_owner_with_only_non_default_prog
     assert_eq!(account.nonce, Account::default().nonce);
     assert_eq!(account.data, Account::default().data);
     let program_id = Program::program_owner_changer().id();
-    let message = public_transaction::Message::new(program_id, vec![address], vec![], vec![]);
+    let message = public_transaction::Message::new(program_id, vec![address], vec![], ());
     let witness_set = public_transaction::WitnessSet::for_message(&message, &[]);
     let tx = PublicTransaction::new(message, witness_set);
 
@@ -84,7 +84,7 @@ fn test_program_should_fail_if_modifies_program_owner_with_only_non_default_bala
     assert_eq!(account.nonce, Account::default().nonce);
     assert_eq!(account.data, Account::default().data);
     let program_id = Program::program_owner_changer().id();
-    let message = public_transaction::Message::new(program_id, vec![address], vec![], vec![]);
+    let message = public_transaction::Message::new(program_id, vec![address], vec![], ());
     let witness_set = public_transaction::WitnessSet::for_message(&message, &[]);
     let tx = PublicTransaction::new(message, witness_set);
 
@@ -107,7 +107,7 @@ fn test_program_should_fail_if_modifies_program_owner_with_only_non_default_nonc
     assert_ne!(account.nonce, Account::default().nonce);
     assert_eq!(account.data, Account::default().data);
     let program_id = Program::program_owner_changer().id();
-    let message = public_transaction::Message::new(program_id, vec![address], vec![], vec![]);
+    let message = public_transaction::Message::new(program_id, vec![address], vec![], ());
     let witness_set = public_transaction::WitnessSet::for_message(&message, &[]);
     let tx = PublicTransaction::new(message, witness_set);
 
@@ -130,7 +130,7 @@ fn test_program_should_fail_if_modifies_program_owner_with_only_non_default_data
     assert_eq!(account.nonce, Account::default().nonce);
     assert_ne!(account.data, Account::default().data);
     let program_id = Program::program_owner_changer().id();
-    let message = public_transaction::Message::new(program_id, vec![address], vec![], vec![]);
+    let message = public_transaction::Message::new(program_id, vec![address], vec![], ());
     let witness_set = public_transaction::WitnessSet::for_message(&message, &[]);
     let tx = PublicTransaction::new(message, witness_set);
 
@@ -147,7 +147,6 @@ fn test_program_should_fail_if_transfers_balance_from_non_owned_account() {
     let receiver_address = Address::new([2; 32]);
     let balance_to_move: u128 = 1;
     let program_id = Program::simple_balance_transfer().id();
-    let instruction_data = Program::serialize_instruction_data(balance_to_move).unwrap();
     assert_ne!(
         state.get_account_by_address(&sender_address).program_owner,
         program_id
@@ -156,13 +155,12 @@ fn test_program_should_fail_if_transfers_balance_from_non_owned_account() {
         program_id,
         vec![sender_address, receiver_address],
         vec![],
-        instruction_data,
+        balance_to_move,
     );
     let witness_set = public_transaction::WitnessSet::for_message(&message, &[]);
     let tx = PublicTransaction::new(message, witness_set);
 
     let result = state.transition_from_public_transaction(&tx);
-    println!("{:?}", result);
 
     assert!(matches!(result, Err(NssaError::InvalidProgramBehavior)));
 }
@@ -180,7 +178,7 @@ fn test_program_should_fail_if_modifies_data_of_non_owned_account() {
         state.get_account_by_address(&address).program_owner,
         program_id
     );
-    let message = public_transaction::Message::new(program_id, vec![address], vec![], vec![]);
+    let message = public_transaction::Message::new(program_id, vec![address], vec![], ());
     let witness_set = public_transaction::WitnessSet::for_message(&message, &[]);
     let tx = PublicTransaction::new(message, witness_set);
 
@@ -196,7 +194,7 @@ fn test_program_should_fail_if_does_not_preserve_total_balance_by_minting() {
     let address = Address::new([1; 32]);
     let program_id = Program::minter().id();
 
-    let message = public_transaction::Message::new(program_id, vec![address], vec![], vec![]);
+    let message = public_transaction::Message::new(program_id, vec![address], vec![], ());
     let witness_set = public_transaction::WitnessSet::for_message(&message, &[]);
     let tx = PublicTransaction::new(message, witness_set);
 
@@ -217,12 +215,11 @@ fn test_program_should_fail_if_does_not_preserve_total_balance_by_burning() {
         state.get_account_by_address(&address).program_owner,
         program_id
     );
-    let balance_to_burn = 1;
+    let balance_to_burn: u128 = 1;
     assert!(state.get_account_by_address(&address).balance > balance_to_burn);
 
-    let instruction_data = Program::serialize_instruction_data(balance_to_burn).unwrap();
     let message =
-        public_transaction::Message::new(program_id, vec![address], vec![], instruction_data);
+        public_transaction::Message::new(program_id, vec![address], vec![], balance_to_burn);
     let witness_set = public_transaction::WitnessSet::for_message(&message, &[]);
     let tx = PublicTransaction::new(message, witness_set);
     let result = state.transition_from_public_transaction(&tx);

nssa/test_program_methods/guest/src/bin/burner.rs

@@ -1,10 +1,10 @@
 use nssa_core::program::read_nssa_inputs;
 use risc0_zkvm::guest::env;
 
-type InstructionData = u128;
+type Instruction = u128;
 
 fn main() {
-    let (input_accounts, balance_to_burn) = read_nssa_inputs::<InstructionData>();
+    let (input_accounts, balance_to_burn) = read_nssa_inputs::<Instruction>();
 
     let [pre] = match input_accounts.try_into() {
         Ok(array) => array,

nssa/test_program_methods/guest/src/bin/data_changer.rs

@@ -1,10 +1,10 @@
 use nssa_core::program::read_nssa_inputs;
 use risc0_zkvm::guest::env;
 
-type InstructionData = ();
+type Instruction = ();
 
 fn main() {
-    let (input_accounts, _) = read_nssa_inputs::<InstructionData>();
+    let (input_accounts, _) = read_nssa_inputs::<Instruction>();
 
     let [pre] = match input_accounts.try_into() {
         Ok(array) => array,

nssa/test_program_methods/guest/src/bin/extra_output.rs

@@ -1,10 +1,10 @@
 use nssa_core::{account::Account, program::read_nssa_inputs};
 use risc0_zkvm::guest::env;
 
-type InstructionData = ();
+type Instruction = ();
 
 fn main() {
-    let (input_accounts, _) = read_nssa_inputs::<InstructionData>();
+    let (input_accounts, _) = read_nssa_inputs::<Instruction>();
 
     let [pre] = match input_accounts.try_into() {
         Ok(array) => array,

nssa/test_program_methods/guest/src/bin/minter.rs

@@ -1,10 +1,10 @@
 use nssa_core::{account::Account, program::read_nssa_inputs};
 use risc0_zkvm::guest::env;
 
-type InstructionData = ();
+type Instruction = ();
 
 fn main() {
-    let (input_accounts, _) = read_nssa_inputs::<InstructionData>();
+    let (input_accounts, _) = read_nssa_inputs::<Instruction>();
 
     let [pre] = match input_accounts.try_into() {
         Ok(array) => array,

nssa/test_program_methods/guest/src/bin/missing_output.rs

@@ -1,10 +1,10 @@
 use nssa_core::program::read_nssa_inputs;
 use risc0_zkvm::guest::env;
 
-type InstructionData = ();
+type Instruction = ();
 
 fn main() {
-    let (input_accounts, _) = read_nssa_inputs::<InstructionData>();
+    let (input_accounts, _) = read_nssa_inputs::<Instruction>();
 
     let [pre1, _] = match input_accounts.try_into() {
         Ok(array) => array,

nssa/test_program_methods/guest/src/bin/nonce_changer.rs

@@ -1,10 +1,10 @@
 use nssa_core::program::read_nssa_inputs;
 use risc0_zkvm::guest::env;
 
-type InstructionData = ();
+type Instruction = ();
 
 fn main() {
-    let (input_accounts, _) = read_nssa_inputs::<InstructionData>();
+    let (input_accounts, _) = read_nssa_inputs::<Instruction>();
 
     let [pre] = match input_accounts.try_into() {
         Ok(array) => array,

nssa/test_program_methods/guest/src/bin/program_owner_changer.rs

@@ -1,10 +1,10 @@
 use nssa_core::program::read_nssa_inputs;
 use risc0_zkvm::guest::env;
 
-type InstructionData = ();
+type Instruction = ();
 
 fn main() {
-    let (input_accounts, _) = read_nssa_inputs::<InstructionData>();
+    let (input_accounts, _) = read_nssa_inputs::<Instruction>();
 
     let [pre] = match input_accounts.try_into() {
         Ok(array) => array,

nssa/test_program_methods/guest/src/bin/simple_balance_transfer.rs

@@ -1,10 +1,10 @@
 use nssa_core::program::read_nssa_inputs;
 use risc0_zkvm::guest::env;
 
-type InstructionData = u128;
+type Instruction = u128;
 
 fn main() {
-    let (input_accounts, balance) = read_nssa_inputs::<InstructionData>();
+    let (input_accounts, balance) = read_nssa_inputs::<Instruction>();
 
     let [sender_pre, receiver_pre] = match input_accounts.try_into() {
         Ok(array) => array,

sequencer_rpc/src/process.rs

@@ -496,7 +496,7 @@ mod tests {
                             { "value": [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] },
                             { "value": [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2] }
                         ],
-                        "instruction_data": 10,
+                        "instruction_data": [10, 0, 0, 0],
                         "nonces": [0],
                         "program_id": nssa::program::Program::authenticated_transfer_program().id(),
                     },