minor refactor

common/src/test_utils.rs

@@ -36,7 +36,7 @@ pub fn produce_dummy_empty_transaction() -> nssa::PublicTransaction {
     let nonces = vec![];
     let instruction_data = 0;
     let message =
-        nssa::public_transaction::Message::new(program_id, addresses, nonces, instruction_data);
+        nssa::public_transaction::Message::try_new(program_id, addresses, nonces, instruction_data).unwrap();
     let private_key = nssa::PrivateKey::new(1);
     let witness_set = nssa::public_transaction::WitnessSet::for_message(&message, &[&private_key]);
     nssa::PublicTransaction::new(message, witness_set)
@@ -53,7 +53,7 @@ pub fn create_transaction_native_token_transfer(
     let nonces = vec![nonce];
     let program_id = nssa::program::Program::authenticated_transfer_program().id();
     let message =
-        nssa::public_transaction::Message::new(program_id, addresses, nonces, balance_to_move);
+        nssa::public_transaction::Message::try_new(program_id, addresses, nonces, balance_to_move).unwrap();
     let witness_set = nssa::public_transaction::WitnessSet::for_message(&message, &[&signing_key]);
     nssa::PublicTransaction::new(message, witness_set)
 }

nssa/src/error.rs

@@ -12,5 +12,5 @@ pub enum NssaError {
     InvalidProgramBehavior,
 
     #[error("Serialization error: {0}")]
-    InstructionDataSerializationError(String),
+    InstructionSerializationError(String),
 }

nssa/src/program.rs

@@ -19,10 +19,10 @@ impl Program {
     }
 
     pub fn serialize_instruction<T: Serialize>(
-        instruction_data: T,
+        instruction: T,
     ) -> Result<InstructionData, NssaError> {
-        to_vec(&instruction_data)
-            .map_err(|e| NssaError::InstructionDataSerializationError(e.to_string()))
+        to_vec(&instruction)
+            .map_err(|e| NssaError::InstructionSerializationError(e.to_string()))
     }
 
     pub(crate) fn execute(

nssa/src/public_transaction/message.rs

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

nssa/src/tests/state_tests.rs

@@ -14,7 +14,7 @@ fn transfer_transaction(
     let addresses = vec![from, to];
     let nonces = vec![nonce];
     let program_id = Program::authenticated_transfer_program().id();
-    let message = public_transaction::Message::new(program_id, addresses, nonces, balance);
+    let message = public_transaction::Message::try_new(program_id, addresses, nonces, balance).unwrap();
     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![], ());
+    let message = public_transaction::Message::try_new(program_id, addresses, vec![], ()).unwrap();
     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![], ());
+    let message = public_transaction::Message::try_new(program_id, addresses, vec![], ()).unwrap();
     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![], ());
+    let message = public_transaction::Message::try_new(program_id, addresses, vec![], ()).unwrap();
     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![], ());
+    let message = public_transaction::Message::try_new(program_id, vec![address], vec![], ()).unwrap();
     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![], ());
+    let message = public_transaction::Message::try_new(program_id, vec![address], vec![], ()).unwrap();
     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![], ());
+    let message = public_transaction::Message::try_new(program_id, vec![address], vec![], ()).unwrap();
     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![], ());
+    let message = public_transaction::Message::try_new(program_id, vec![address], vec![], ()).unwrap();
     let witness_set = public_transaction::WitnessSet::for_message(&message, &[]);
     let tx = PublicTransaction::new(message, witness_set);
 
@@ -151,12 +151,12 @@ fn test_program_should_fail_if_transfers_balance_from_non_owned_account() {
         state.get_account_by_address(&sender_address).program_owner,
         program_id
     );
-    let message = public_transaction::Message::new(
+    let message = public_transaction::Message::try_new(
         program_id,
         vec![sender_address, receiver_address],
         vec![],
         balance_to_move,
-    );
+    ).unwrap();
     let witness_set = public_transaction::WitnessSet::for_message(&message, &[]);
     let tx = PublicTransaction::new(message, witness_set);
 
@@ -178,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![], ());
+    let message = public_transaction::Message::try_new(program_id, vec![address], vec![], ()).unwrap();
     let witness_set = public_transaction::WitnessSet::for_message(&message, &[]);
     let tx = PublicTransaction::new(message, witness_set);
 
@@ -194,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![], ());
+    let message = public_transaction::Message::try_new(program_id, vec![address], vec![], ()).unwrap();
     let witness_set = public_transaction::WitnessSet::for_message(&message, &[]);
     let tx = PublicTransaction::new(message, witness_set);
 
@@ -219,7 +219,7 @@ fn test_program_should_fail_if_does_not_preserve_total_balance_by_burning() {
     assert!(state.get_account_by_address(&address).balance > balance_to_burn);
 
     let message =
-        public_transaction::Message::new(program_id, vec![address], vec![], balance_to_burn);
+        public_transaction::Message::try_new(program_id, vec![address], vec![], balance_to_burn).unwrap();
     let witness_set = public_transaction::WitnessSet::for_message(&message, &[]);
     let tx = PublicTransaction::new(message, witness_set);
     let result = state.transition_from_public_transaction(&tx);

wallet/src/lib.rs

@@ -79,12 +79,12 @@ impl WalletCore {
                 let addresses = vec![nssa::Address::new(from), nssa::Address::new(to)];
                 let nonces = vec![nonce];
                 let program_id = nssa::program::Program::authenticated_transfer_program().id();
-                let message = nssa::public_transaction::Message::new(
+                let message = nssa::public_transaction::Message::try_new(
                     program_id,
                     addresses,
                     nonces,
                     balance_to_move,
-                );
+                ).unwrap();
 
                 let signing_key = account.key_holder.get_pub_account_signing_key();
                 let witness_set =