logos-execution-zone/common/src/transaction.rs

use k256::ecdsa::{
    Signature, SigningKey, VerifyingKey,
    signature::{Signer, Verifier},
};
use log::info;
use serde::{Deserialize, Serialize};

use sha2::{Digest, digest::FixedOutput};

use elliptic_curve::{
    consts::{B0, B1},
    generic_array::GenericArray,
};
use sha2::digest::typenum::{UInt, UTerm};

use crate::TreeHashType;

pub type CipherText = Vec<u8>;
pub type Nonce = GenericArray<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>>;
pub type Tag = u8;

#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq, Eq)]
pub enum TxKind {
    Public,
    PrivacyPreserving,
}

#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
///General transaction object
pub struct TransactionBody {
    pub tx_kind: TxKind,
    ///Encoded blobs of data
    pub encoded_transaction_data: Vec<u8>,
}

impl From<nssa::NSSATransaction> for TransactionBody {
    fn from(value: nssa::NSSATransaction) -> Self {
        match value {
            nssa::NSSATransaction::Public(tx) => Self {
                tx_kind: TxKind::Public,
                encoded_transaction_data: tx.to_bytes(),
            },
            nssa::NSSATransaction::PrivacyPreserving(tx) => Self {
                tx_kind: TxKind::PrivacyPreserving,
                encoded_transaction_data: tx.to_bytes(),
            },
        }
    }
}

impl TryFrom<&TransactionBody> for nssa::NSSATransaction {
    type Error = nssa::error::NssaError;

    fn try_from(value: &TransactionBody) -> Result<Self, Self::Error> {
        match value.tx_kind {
            TxKind::Public => nssa::PublicTransaction::from_bytes(&value.encoded_transaction_data)
                .map(|tx| tx.into()),
            TxKind::PrivacyPreserving => {
                nssa::PrivacyPreservingTransaction::from_bytes(&value.encoded_transaction_data)
                    .map(|tx| tx.into())
            }
        }
    }
}

#[derive(Debug, Serialize, Deserialize)]
pub struct MintMoneyPublicTx {
    pub acc: [u8; 32],
    pub amount: u128,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct SendMoneyShieldedTx {
    pub acc_sender: [u8; 32],
    pub amount: u128,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct SendMoneyDeshieldedTx {
    pub receiver_data: Vec<(u128, [u8; 32])>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct OwnedUTXO {
    pub hash: [u8; 32],
    pub owner: [u8; 32],
    pub amount: u128,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct OwnedUTXOForPublication {
    pub hash: String,
    pub owner: String,
    pub amount: u128,
}

impl From<OwnedUTXO> for OwnedUTXOForPublication {
    fn from(value: OwnedUTXO) -> Self {
        Self {
            hash: hex::encode(value.hash),
            owner: hex::encode(value.owner),
            amount: value.amount,
        }
    }
}

#[derive(Debug, Serialize, Deserialize)]
pub struct UTXOPublication {
    pub utxos: Vec<OwnedUTXO>,
}

#[derive(Debug, Serialize, Deserialize)]
pub enum ActionData {
    MintMoneyPublicTx(MintMoneyPublicTx),
    SendMoneyShieldedTx(SendMoneyShieldedTx),
    SendMoneyDeshieldedTx(SendMoneyDeshieldedTx),
    UTXOPublication(UTXOPublication),
}

impl ActionData {
    pub fn into_hexed_print(self) -> String {
        match self {
            ActionData::MintMoneyPublicTx(action) => {
                format!(
                    "Account {:?} minted {:?} balance",
                    hex::encode(action.acc),
                    action.amount
                )
            }
            ActionData::SendMoneyDeshieldedTx(action) => {
                format!(
                    "Receivers receipt {:?}",
                    action
                        .receiver_data
                        .into_iter()
                        .map(|(amount, rec)| (amount, hex::encode(rec)))
                        .collect::<Vec<_>>()
                )
            }
            ActionData::SendMoneyShieldedTx(action) => {
                format!(
                    "Shielded send from {:?} for {:?} balance",
                    hex::encode(action.acc_sender),
                    action.amount
                )
            }
            ActionData::UTXOPublication(action) => {
                let pub_own_utxo: Vec<OwnedUTXOForPublication> = action
                    .utxos
                    .into_iter()
                    .map(|owned_utxo| owned_utxo.into())
                    .collect();
                format!("Published utxos {pub_own_utxo:?}")
            }
        }
    }
}

impl TransactionBody {
    /// Computes and returns the SHA-256 hash of the JSON-serialized representation of `self`.
    pub fn hash(&self) -> TreeHashType {
        let bytes_to_hash = self.to_bytes();
        let mut hasher = sha2::Sha256::new();
        hasher.update(&bytes_to_hash);
        TreeHashType::from(hasher.finalize_fixed())
    }

    pub fn to_bytes(&self) -> Vec<u8> {
        // TODO: Remove `unwrap` by implementing a `to_bytes` method
        // that deterministically encodes all transaction fields to bytes
        // and guarantees serialization will succeed.
        serde_json::to_vec(&self).unwrap()
    }

    pub fn from_bytes(bytes: Vec<u8>) -> Self {
        serde_json::from_slice(&bytes).unwrap()
    }

    pub fn log(&self) {
        info!("Transaction hash is {:?}", hex::encode(self.hash()));
        info!("Transaction tx_kind is {:?}", self.tx_kind);
    }
}

pub type TransactionSignature = Signature;
pub type SignaturePublicKey = VerifyingKey;
pub type SignaturePrivateKey = SigningKey;

#[cfg(test)]
mod tests {
    use super::*;
    use k256::{FieldBytes, ecdsa::signature::Signer};
    use secp256k1_zkp::{Tweak, constants::SECRET_KEY_SIZE};
    use sha2::{Digest, digest::FixedOutput};

    use crate::{
        transaction::{TransactionBody, TxKind},
        TreeHashType,
    };

    fn test_transaction_body() -> TransactionBody {
        TransactionBody {
            tx_kind: TxKind::Public,
            encoded_transaction_data: vec![1, 2, 3, 4],
        }
    }

    #[test]
    fn test_transaction_hash_is_sha256_of_json_bytes() {
        let body = test_transaction_body();
        let expected_hash = {
            let data = body.to_bytes();
            let mut hasher = sha2::Sha256::new();
            hasher.update(&data);
            TreeHashType::from(hasher.finalize_fixed())
        };

        let hash = body.hash();

        assert_eq!(expected_hash, hash);
    }

    #[test]
    fn test_to_bytes_from_bytes() {
        let body = test_transaction_body();

        let body_bytes = body.to_bytes();
        let body_new = TransactionBody::from_bytes(body_bytes);

        assert_eq!(body, body_new);
    #[test]
    fn test_into_authenticated_succeeds_for_valid_signature() {
        let transaction = test_transaction();
        let authenticated_tx = transaction.clone().into_authenticated().unwrap();

        let signature = authenticated_tx.transaction().signature;
        let hash = authenticated_tx.hash();

        assert_eq!(authenticated_tx.transaction(), &transaction);
        assert_eq!(hash, &transaction.body.hash());
        assert!(
            authenticated_tx
                .transaction()
                .public_key
                .verify(&transaction.body.to_bytes(), &signature)
                .is_ok()
        );
    }

    #[test]
    fn test_into_authenticated_fails_for_invalid_signature() {
        let body = test_transaction_body();
        let key_bytes = FieldBytes::from_slice(&[37; 32]);
        let private_key: SigningKey = SigningKey::from_bytes(key_bytes).unwrap();
        let transaction = {
            let mut this = Transaction::new(body, private_key.clone());
            // Modify the signature to make it invalid
            // We do this by changing it to the signature of something else
            this.signature = private_key.sign(b"deadbeef");
            this
        };

        matches!(
            transaction.into_authenticated(),
            Err(TransactionSignatureError::InvalidSignature)
        );
    }

    #[test]
    fn test_authenticated_transaction_getter() {
        let transaction = test_transaction();
        let authenticated_tx = transaction.clone().into_authenticated().unwrap();
        assert_eq!(authenticated_tx.transaction(), &transaction);
    }

    #[test]
    fn test_authenticated_transaction_hash_getter() {
        let transaction = test_transaction();
        let authenticated_tx = transaction.clone().into_authenticated().unwrap();
        assert_eq!(authenticated_tx.hash(), &transaction.body.hash());
    }

    #[test]
    fn test_authenticated_transaction_into_transaction() {
        let transaction = test_transaction();
        let authenticated_tx = transaction.clone().into_authenticated().unwrap();
        assert_eq!(authenticated_tx.into_transaction(), transaction);
    }
}