zera-sdk 0.1.0

Rust SDK for ZERA transactions, validator APIs, and bridge workflows
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use prost::Message;
use zera_proto::zera_txn::{CoinTxn, TransferAuthentication};

use crate::error::{Result, ZeraError};
use crate::sign::signer::{create_transaction_hash, sign_transaction_data, ZeraSigner};
use crate::tx::BaseTxnAccess;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CoinTxnKeyPair {
    pub public_key: String,
    pub private_key: String,
}

pub async fn sign_and_finalize<T>(txn: &mut T, signer: &dyn ZeraSigner) -> Result<()>
where
    T: Message + BaseTxnAccess,
{
    let bytes = txn.encode_to_vec();
    let signature = signer.sign(&bytes).await?;
    {
        let base = txn
            .base_mut()
            .ok_or_else(|| ZeraError::Validation("Transaction is missing base data".to_string()))?;
        base.signature = Some(signature);
    }

    let signed_bytes = txn.encode_to_vec();
    let hash = create_transaction_hash(&signed_bytes);
    let base = txn
        .base_mut()
        .ok_or_else(|| ZeraError::Validation("Transaction is missing base data".to_string()))?;
    base.hash = Some(hash);
    Ok(())
}

pub fn sign_with_key<T>(txn: &mut T, private_key: &str, public_key_id: &str) -> Result<()>
where
    T: Message + BaseTxnAccess,
{
    let bytes = txn.encode_to_vec();
    let signature = sign_transaction_data(&bytes, private_key, public_key_id)?;
    {
        let base = txn
            .base_mut()
            .ok_or_else(|| ZeraError::Validation("Transaction is missing base data".to_string()))?;
        base.signature = Some(signature);
    }

    let signed_bytes = txn.encode_to_vec();
    let hash = create_transaction_hash(&signed_bytes);
    let base = txn
        .base_mut()
        .ok_or_else(|| ZeraError::Validation("Transaction is missing base data".to_string()))?;
    base.hash = Some(hash);
    Ok(())
}

pub async fn sign_coin_txn(txn: &mut CoinTxn, signers: &[&dyn ZeraSigner]) -> Result<()> {
    if signers.is_empty() {
        return Err(ZeraError::Validation(
            "At least one signer is required".to_string(),
        ));
    }

    let txn_bytes = txn.encode_to_vec();
    let auth = txn.auth.get_or_insert_with(TransferAuthentication::default);
    for signer in signers {
        auth.signature.push(signer.sign(&txn_bytes).await?);
    }

    let signed_bytes = txn.encode_to_vec();
    let hash = create_transaction_hash(&signed_bytes);
    let base = txn
        .base
        .as_mut()
        .ok_or_else(|| ZeraError::Validation("CoinTXN is missing base data".to_string()))?;
    base.hash = Some(hash);
    Ok(())
}

pub fn sign_coin_txn_with_keys(txn: &mut CoinTxn, keys: &[CoinTxnKeyPair]) -> Result<()> {
    if keys.is_empty() {
        return Err(ZeraError::Validation(
            "At least one key pair is required".to_string(),
        ));
    }

    let txn_bytes = txn.encode_to_vec();
    let auth = txn.auth.get_or_insert_with(TransferAuthentication::default);
    for key in keys {
        if key.public_key.is_empty() || key.private_key.is_empty() {
            return Err(ZeraError::Validation(
                "Key pair is missing privateKey or publicKey".to_string(),
            ));
        }
        auth.signature.push(sign_transaction_data(
            &txn_bytes,
            &key.private_key,
            &key.public_key,
        )?);
    }

    let signed_bytes = txn.encode_to_vec();
    let hash = create_transaction_hash(&signed_bytes);
    let base = txn
        .base
        .as_mut()
        .ok_or_else(|| ZeraError::Validation("CoinTXN is missing base data".to_string()))?;
    base.hash = Some(hash);
    Ok(())
}