refactor public_transaction module into folder

nssa/src/public_transaction.rs

@@ -1,98 +0,0 @@
-use nssa_core::{account::Nonce, program::ProgramId};
-use serde::{Deserialize, Serialize};
-use sha2::{Digest, digest::FixedOutput};
-
-use crate::{
-    address::Address,
-    signature::{PrivateKey, PublicKey, Signature},
-};
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct Message {
-    pub(crate) program_id: ProgramId,
-    pub(crate) addresses: Vec<Address>,
-    pub(crate) nonces: Vec<Nonce>,
-    // TODO: change to Vec<u8> for general programs
-    pub(crate) instruction_data: u128,
-}
-
-impl Message {
-    pub fn new(
-        program_id: ProgramId,
-        addresses: Vec<Address>,
-        nonces: Vec<Nonce>,
-        instruction_data: u128,
-    ) -> Self {
-        Self {
-            program_id,
-            addresses,
-            nonces,
-            instruction_data,
-        }
-    }
-
-    fn to_bytes(&self) -> Vec<u8> {
-        //TODO: implement
-        vec![0, 0]
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct WitnessSet {
-    pub(crate) signatures_and_public_keys: Vec<(Signature, PublicKey)>,
-}
-
-impl WitnessSet {
-    pub fn for_message(message: &Message, private_keys: &[&PrivateKey]) -> Self {
-        let message_bytes = message.to_bytes();
-        let signatures_and_public_keys = private_keys
-            .iter()
-            .map(|&key| (Signature::new(key, &message_bytes), PublicKey::new(key)))
-            .collect();
-        Self {
-            signatures_and_public_keys,
-        }
-    }
-
-    pub fn iter_signatures(&self) -> impl Iterator<Item = &(Signature, PublicKey)> {
-        self.signatures_and_public_keys.iter()
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct PublicTransaction {
-    message: Message,
-    witness_set: WitnessSet,
-}
-
-impl PublicTransaction {
-    pub fn message(&self) -> &Message {
-        &self.message
-    }
-
-    pub fn witness_set(&self) -> &WitnessSet {
-        &self.witness_set
-    }
-
-    pub(crate) fn signer_addresses(&self) -> Vec<Address> {
-        self.witness_set
-            .signatures_and_public_keys
-            .iter()
-            .map(|(_, public_key)| Address::from_public_key(public_key))
-            .collect()
-    }
-
-    pub fn new(message: Message, witness_set: WitnessSet) -> Self {
-        Self {
-            message,
-            witness_set,
-        }
-    }
-
-    pub fn hash(&self) -> [u8; 32] {
-        let bytes = serde_cbor::to_vec(&self).unwrap();
-        let mut hasher = sha2::Sha256::new();
-        hasher.update(&bytes);
-        hasher.finalize_fixed().into()
-    }
-}

nssa/src/public_transaction/message.rs

@@ -0,0 +1,29 @@
+use nssa_core::{account::Nonce, program::ProgramId};
+use serde::{Deserialize, Serialize};
+
+use crate::Address;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct Message {
+    pub(crate) program_id: ProgramId,
+    pub(crate) addresses: Vec<Address>,
+    pub(crate) nonces: Vec<Nonce>,
+    // TODO: change to Vec<u8> for general programs
+    pub(crate) instruction_data: u128,
+}
+
+impl Message {
+    pub fn new(
+        program_id: ProgramId,
+        addresses: Vec<Address>,
+        nonces: Vec<Nonce>,
+        instruction_data: u128,
+    ) -> Self {
+        Self {
+            program_id,
+            addresses,
+            nonces,
+            instruction_data,
+        }
+    }
+}

nssa/src/public_transaction/mod.rs

@@ -0,0 +1,52 @@
+use nssa_core::{account::Nonce, program::ProgramId};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, digest::FixedOutput};
+
+use crate::{
+    address::Address,
+    signature::{PrivateKey, PublicKey, Signature},
+};
+
+mod message;
+mod witness_set;
+
+pub use message::Message;
+pub use witness_set::WitnessSet;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct PublicTransaction {
+    message: Message,
+    witness_set: WitnessSet,
+}
+
+impl PublicTransaction {
+    pub fn message(&self) -> &Message {
+        &self.message
+    }
+
+    pub fn witness_set(&self) -> &WitnessSet {
+        &self.witness_set
+    }
+
+    pub(crate) fn signer_addresses(&self) -> Vec<Address> {
+        self.witness_set
+            .signatures_and_public_keys
+            .iter()
+            .map(|(_, public_key)| Address::from_public_key(public_key))
+            .collect()
+    }
+
+    pub fn new(message: Message, witness_set: WitnessSet) -> Self {
+        Self {
+            message,
+            witness_set,
+        }
+    }
+
+    pub fn hash(&self) -> [u8; 32] {
+        let bytes = serde_cbor::to_vec(&self).unwrap();
+        let mut hasher = sha2::Sha256::new();
+        hasher.update(&bytes);
+        hasher.finalize_fixed().into()
+    }
+}

nssa/src/public_transaction/witness_set.rs

@@ -0,0 +1,30 @@
+use serde::{Deserialize, Serialize};
+
+use crate::{PrivateKey, PublicKey, Signature, public_transaction::Message};
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct WitnessSet {
+    pub(crate) signatures_and_public_keys: Vec<(Signature, PublicKey)>,
+}
+
+fn serialize_message_to_bytes(message: &Message) -> Vec<u8> {
+    //TODO: implement
+    vec![0, 0]
+}
+
+impl WitnessSet {
+    pub fn for_message(message: &Message, private_keys: &[&PrivateKey]) -> Self {
+        let message_bytes = serialize_message_to_bytes(&message);
+        let signatures_and_public_keys = private_keys
+            .iter()
+            .map(|&key| (Signature::new(key, &message_bytes), PublicKey::new(key)))
+            .collect();
+        Self {
+            signatures_and_public_keys,
+        }
+    }
+
+    pub fn iter_signatures(&self) -> impl Iterator<Item = &(Signature, PublicKey)> {
+        self.signatures_and_public_keys.iter()
+    }
+}