From e1d2d683e3bb87a27278bd525cd43864007d4f68 Mon Sep 17 00:00:00 2001
From: qh11 <qh11@illinois.edu>
Date: Sun, 13 Feb 2022 15:37:11 -0600
Subject: [PATCH] Update transaction.rs
---
src/types/transaction.rs | 84 +++++++++++++++++++++++-----------------
1 file changed, 49 insertions(+), 35 deletions(-)
diff --git a/src/types/transaction.rs b/src/types/transaction.rs
index cb98654..6bb774f 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
--
GitLab