iop_hydra_proto/
transaction.rs

1use super::*;
2
3#[derive(Clone, Debug, Default, Deserialize, Serialize)]
4pub struct TxBatch {
5    pub transactions: Vec<TransactionData>,
6}
7
8#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
9#[serde(rename_all = "camelCase")]
10pub struct TransactionData {
11    #[serde(skip_serializing_if = "Option::is_none")]
12    pub version: Option<u8>,
13    #[serde(skip_serializing_if = "Option::is_none")]
14    pub network: Option<u8>,
15    #[serde(flatten)]
16    pub typed_asset: txtype::TypedAsset,
17    // pub timestamp: u32, // present in the v2 schema only for v1 compatibility
18    #[serde(skip_serializing_if = "Option::is_none")]
19    pub nonce: Option<String>,
20    pub sender_public_key: String,
21    pub fee: String,
22    pub amount: String,
23    #[serde(skip_serializing_if = "Option::is_none")]
24    pub expiration: Option<u32>,
25    #[serde(skip_serializing_if = "Option::is_none")]
26    pub recipient_id: Option<String>,
27    #[serde(skip_serializing_if = "Option::is_none")]
28    pub vendor_field: Option<String>,
29    #[serde(skip_serializing_if = "Option::is_none")]
30    pub id: Option<String>,
31    #[serde(skip_serializing_if = "Option::is_none")]
32    pub signature: Option<String>,
33    #[serde(skip_serializing_if = "Option::is_none")]
34    pub second_signature: Option<String>,
35    #[serde(skip_serializing_if = "Option::is_none")]
36    pub sign_signature: Option<String>,
37    #[serde(skip_serializing_if = "Vec::is_empty", default)]
38    pub signatures: Vec<String>,
39    #[serde(skip_serializing_if = "Option::is_none")]
40    pub block_id: Option<String>,
41    #[serde(skip_serializing_if = "Option::is_none")]
42    pub sequence: Option<u64>,
43}
44
45impl TransactionData {
46    pub fn get_id(&self) -> Result<String> {
47        let bytes = self.to_bytes(false, false, false)?;
48        let id = hex::encode(Sha256::digest(&bytes));
49        Ok(id)
50    }
51
52    pub fn to_bytes(
53        &self, skip_signature: bool, skip_second_signature: bool, skip_multisignatures: bool,
54    ) -> Result<Vec<u8>> {
55        serializer::to_bytes(self, skip_signature, skip_second_signature, skip_multisignatures)
56    }
57
58    // pub fn second_sign(&mut self, passphrase: &str) -> Result<&mut Self> {
59    //     let private_key = PrivateKey::from_passphrase(passphrase)?;
60    //     let bytes = self.to_bytes(false, true, false)?;
61    //     self.second_signature = Some(private_key.sign_ecdsa(&bytes)?);
62    //     Ok(self)
63    // }
64
65    // pub fn verify(&self) -> bool {
66    //     self.internal_verify(&self.sender_public_key, &self.signature, &self.to_bytes(true, true))
67    // }
68    //
69    // pub fn second_verify(&self, sender_public_key: &str) -> bool {
70    //     self.internal_verify(&sender_public_key, &self.sign_signature, &self.to_bytes(false, true))
71    // }
72    //
73    // fn internal_verify(&self, sender_public_key: &str, signature: &str, bytes: &[u8]) -> bool {
74    //     let hash = Sha256::digest(&bytes);
75    //     let pk = PublicKey::from_hex(&sender_public_key).unwrap();
76    //     let valid = pk.verify_signature_ecdsa(&hash, signature);
77    //     valid.unwrap_or(false)
78    // }
79}