jlib 0.3.7

A lightweight blockchain lib.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

use crate::base::secp256k1::key::{SecretKey, PublicKey};
use crate::base::secp256k1::{Secp256k1, Message};

use crate::base::ring::{digest};
use cast_rs::hex;
use crate::base::wallet::keypair::*;

pub struct SignatureX <'a> {
    pub keypair: &'a Keypair,
}

impl <'a> SignatureX <'a> {
    pub fn new(keypair: &'a Keypair) -> Self {
        SignatureX {
            keypair: keypair,
        }
    }
}

impl <'a> SignatureX <'a> {
    /*
    @sign
    message: [u8]   /   message bytes needed to be sign.
    key    : [u8]   /   secret key bytes array.
    Output : signed hex string
    */
    pub fn sign(message: &[u8], key: &[u8]) -> String {
        let sign = Secp256k1::signing_only();
        let message = Message::from_slice(message).unwrap();
        let secret_key = SecretKey::from_slice(key).expect("32 bytes, within curve order");
        let signature = sign.sign(&message, &secret_key);

        signature.to_string().to_ascii_uppercase()
    }

    /*
    @verify
    message  : [u8]    /  raw message bytes.
    signature: [u8]    /  signed bytes array.
    Output   : bool    /  verify success or not.
    */
    pub fn verify(message: &[u8], signature: &[u8], key: &[u8]) -> bool {
        let vrfy = Secp256k1::verification_only();
        let sig: secp256k1::Signature = secp256k1::Signature::from_der(signature).expect("byte str decode");
        let secp = Secp256k1::new();
        let secret_key = SecretKey::from_slice(&key).expect("32 bytes, within curve order");
        let public_key = PublicKey::from_secret_key(&secp, &secret_key);
        let msg = Message::from_slice(&message).unwrap();
        if vrfy.verify(&msg, &sig, &public_key).is_ok() {
            return true;
        }

        false
    }

    //Output Hex String
    pub fn sign_txn_signature(&self, so: &Vec<u8>) -> String {
        let mut ctx = digest::Context::new(&digest::SHA512);
        ctx.update(&[83,84,88, 0]);
        ctx.update(&so);

        let hash = hex::encode(&ctx.finish().as_ref());
        let message = hash.get(0..64).unwrap().to_ascii_uppercase();
        let private_key = &self.keypair.private_key;
        let key = &hex::decode(private_key).unwrap()[1..];

        let msg = hex::decode(message).unwrap();
        let signed_hex_string = SignatureX::sign(&msg, &key);

        return signed_hex_string;
    }
}