diff --git a/src/types/transaction.rs b/src/types/transaction.rs
index cb9865448fd55ec589f62d3881da63ef50751e86..6bb774f0a658164d79446249e7f163e53d91b054 100755
--- a/src/types/transaction.rs
+++ b/src/types/transaction.rs
@@ -1,60 +1,74 @@
-use ring::signature::{Ed25519KeyPair, Signature, KeyPair, VerificationAlgorithm, EdDSAParameters};
-use rand::Rng;
-use crate::types::address::Address;
-use bincode::serialize;
 use serde::{Serialize,Deserialize};
-
+use ring::signature::{ED25519, UnparsedPublicKey, Ed25519KeyPair, Signature, KeyPair, VerificationAlgorithm, EdDSAParameters};
+use rand::Rng;
+use crate::types::hash::{H256, Hashable};
+use bincode::{serialize, deserialize};
+use super::address::Address;
 
 #[derive(Serialize, Deserialize, Debug, Default, Clone)]
 pub struct Transaction {
     sender: Address,
     receiver: Address,
-    value: u32
+    value: f32,
 }
 
-
 #[derive(Serialize, Deserialize, Debug, Default, Clone)]
 pub struct SignedTransaction {
-    transaction: Transaction,
-    signature_vec: Vec<u8>,
-    public_key_vec: Vec<u8>
+    transaction : Transaction,
+    sig : Vec<u8>,
+}
+
+impl SignedTransaction{
+    fn fromTransact(t:Transaction, key: &Ed25519KeyPair) -> Self{
+        let signature = sign(&t, &key);
+        let signature_vector: Vec<u8> = signature.as_ref().to_vec();
+        return SignedTransaction{
+            transaction : t,
+            sig : signature_vector,
+        }
+    }
+}
+
+impl Hashable for SignedTransaction{
+    fn hash(&self) -> H256{
+        let bytes = bincode::serialize(&self).unwrap();
+        return ring::digest::digest(&ring::digest::SHA256, &bytes).into();
+    }
 }
 
 /// Create digital signature of a transaction
 pub fn sign(t: &Transaction, key: &Ed25519KeyPair) -> Signature {
-    let serializeT = bincode::serialize(&t).unwrap(); 
-    let signature = key.sign(&serializeT);
-    signature
-    //unimplemented!()
+    // unimplemented!()
+    let ser_t = serialize(&t).unwrap();
+    key.sign(&ser_t)
 }
 
 /// Verify digital signature of a transaction, using public key instead of secret key
 pub fn verify(t: &Transaction, public_key: &[u8], signature: &[u8]) -> bool {
-    let serializeT = serialize(&t).unwrap();
-    let unparsed = ring::signature::UnparsedPublicKey::new(&ring::signature::ED25519, public_key);
-    let result = unparsed.verify(&serializeT, signature);
-    let mut ans:bool = false;
-    if result == Ok(()) {
-        ans = true;
-    } else {
-        ans = false;
-    }
-    return ans;
-    //unimplemented!()
+    // unimplemented!()
+    let ser_t = serialize(&t).unwrap();
+    // let public_key_bytes = public_key.as_ref();
+    let peer_public_key =
+    UnparsedPublicKey::new(&ED25519, public_key);
+    let result = peer_public_key.verify(&ser_t, signature);
+    result.is_ok()
 }
 
 #[cfg(any(test, test_utilities))]
 pub fn generate_random_transaction() -> Transaction {
-    let sender: [u8; 20] = rand::random();
-    let receiver: [u8; 20] = rand::random();
-    let value: u32 = rand::random();
-    let newTransaction = Transaction {
-        sender: sender.into(),
-        receiver: receiver.into(),
-        value: value
-    };
-    newTransaction
-    //unimplemented!()
+    let mut rng = rand::thread_rng();
+    let price :f32 = rng.gen_range(1..1000) as f32;
+    let ad1_u : u8 = rng.gen_range(1..250);
+    let ad2_u : u8 = rng.gen_range(1..250);
+    let ad1 = [ad1_u;20];
+    let ad2 = [ad2_u;20];
+    let Ad1 = Address::from(&ad1);
+    let Ad2 = Address::from(&ad2);
+    Transaction{
+        sender:Ad1,
+        receiver:Ad2,
+        value:price,
+    }
 }
 
 // DO NOT CHANGE THIS COMMENT, IT IS FOR AUTOGRADER. BEFORE TEST