lssa/common/src/transaction.rs

use k256::{
    ecdsa::{
        signature::{Signer, Verifier},
        Signature, SigningKey, VerifyingKey,
    },
    EncodedPoint, Scalar,
};
use log::info;
use secp256k1_zkp::{PedersenCommitment, Tweak};
use serde::de::{Error as DeError, Visitor};
use serde::{Deserialize, Deserializer, Serialize, Serializer};

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

use crate::merkle_tree_public::TreeHashType;

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

use crate::TransactionSignatureError;

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)]
pub enum TxKind {
    Public,
    Private,
    Shielded,
    Deshielded,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
///General transaction object
pub struct TransactionBody {
    pub tx_kind: TxKind,
    ///Tx input data (public part)
    pub execution_input: Vec<u8>,
    ///Tx output data (public_part)
    pub execution_output: Vec<u8>,
    ///Tx input utxo commitments
    pub utxo_commitments_spent_hashes: Vec<TreeHashType>,
    ///Tx output utxo commitments
    pub utxo_commitments_created_hashes: Vec<TreeHashType>,
    ///Tx output nullifiers
    pub nullifier_created_hashes: Vec<TreeHashType>,
    ///Execution proof (private part)
    pub execution_proof_private: String,
    ///Encoded blobs of data
    pub encoded_data: Vec<(CipherText, Vec<u8>, Tag)>,
    ///Transaction senders ephemeral pub key
    pub ephemeral_pub_key: Vec<u8>,
    ///Public (Pedersen) commitment
    pub commitment: Vec<PedersenCommitment>,
    ///tweak
    pub tweak: Tweak,
    ///secret_r
    pub secret_r: [u8; 32],
    ///Hex-encoded address of a smart contract account called
    pub sc_addr: String,
    ///Recorded changes in state of smart contract
    ///
    /// First value represents vector of changes, second is new length of a state
    pub state_changes: (serde_json::Value, usize),
}

#[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 {
        // TODO: Remove `unwrap` by implementing a `to_bytes` method
        // that deterministically encodes all transaction fields to bytes
        // and guarantees serialization will succeed.
        let raw_data = serde_json::to_vec(&self).unwrap();
        let mut hasher = sha2::Sha256::new();
        hasher.update(&raw_data);
        TreeHashType::from(hasher.finalize_fixed())
    }

    pub fn log(&self) {
        info!("Transaction hash is {:?}", hex::encode(self.hash()));
        info!("Transaction tx_kind is {:?}", self.tx_kind);
        info!("Transaction execution_input is {:?}", {
            if let Ok(action) = serde_json::from_slice::<ActionData>(&self.execution_input) {
                action.into_hexed_print()
            } else {
                "".to_string()
            }
        });
        info!("Transaction execution_output is {:?}", {
            if let Ok(action) = serde_json::from_slice::<ActionData>(&self.execution_output) {
                action.into_hexed_print()
            } else {
                "".to_string()
            }
        });
        info!(
            "Transaction utxo_commitments_spent_hashes is {:?}",
            self.utxo_commitments_spent_hashes
                .iter()
                .map(|val| hex::encode(val.clone()))
                .collect::<Vec<_>>()
        );
        info!(
            "Transaction utxo_commitments_created_hashes is {:?}",
            self.utxo_commitments_created_hashes
                .iter()
                .map(|val| hex::encode(val.clone()))
                .collect::<Vec<_>>()
        );
        info!(
            "Transaction nullifier_created_hashes is {:?}",
            self.nullifier_created_hashes
                .iter()
                .map(|val| hex::encode(val.clone()))
                .collect::<Vec<_>>()
        );
        info!(
            "Transaction encoded_data is {:?}",
            self.encoded_data
                .iter()
                .map(|val| (hex::encode(val.0.clone()), hex::encode(val.1.clone())))
                .collect::<Vec<_>>()
        );
        info!(
            "Transaction ephemeral_pub_key is {:?}",
            hex::encode(self.ephemeral_pub_key.clone())
        );
    }
}

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

type TransactionHash = TreeHashType;

/// A transaction with a signature.
/// Meant to be sent through the network to the sequencer
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct SignedTransaction {
    pub body: TransactionBody,
    signature: (TransactionSignature, SignaturePublicKey),
}

impl SignedTransaction {
    pub fn from_transaction_body(
        body: TransactionBody,
        private_key: SignaturePrivateKey,
    ) -> SignedTransaction {
        let hash = body.hash();
        let signature: Signature = private_key.sign(&hash);
        let public_key = VerifyingKey::from(&private_key);
        Self {
            body,
            signature: (signature, public_key),
        }
    }

    pub fn into_authenticated(self) -> Result<AuthenticatedTransaction, TransactionSignatureError> {
        let hash = self.body.hash();
        let (signature, public_key) = &self.signature;

        public_key
            .verify(&hash, signature)
            .map_err(|_| TransactionSignatureError::InvalidSignature)?;

        Ok(AuthenticatedTransaction {
            hash,
            signed_tx: self,
        })
    }
}

/// A transaction with a valid signature over the hash of its body.
/// Can only be constructed from an `SignedTransaction`
/// if the signature is valid
#[derive(Clone)]
pub struct AuthenticatedTransaction {
    hash: TransactionHash,
    signed_tx: SignedTransaction,
}

impl AuthenticatedTransaction {
    pub fn as_signed(&self) -> &SignedTransaction {
        &self.signed_tx
    }

    pub fn body(&self) -> &TransactionBody {
        &self.signed_tx.body
    }

    pub fn signature(&self) -> &TransactionSignature {
        &self.signed_tx.signature.0
    }

    pub fn hash(&self) -> &TransactionHash {
        &self.hash
    }
}

#[cfg(test)]
mod tests {
    use secp256k1_zkp::{constants::SECRET_KEY_SIZE, Tweak};
    use sha2::{digest::FixedOutput, Digest};

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

    #[test]
    fn test_transaction_hash_is_sha256_of_json_bytes() {
        let tx = TransactionBody {
            tx_kind: TxKind::Public,
            execution_input: vec![1, 2, 3, 4],
            execution_output: vec![5, 6, 7, 8],
            utxo_commitments_spent_hashes: vec![[9; 32], [10; 32], [11; 32], [12; 32]],
            utxo_commitments_created_hashes: vec![[13; 32]],
            nullifier_created_hashes: vec![[0; 32], [1; 32], [2; 32], [3; 32]],
            execution_proof_private: "loremipsum".to_string(),
            encoded_data: vec![(vec![255, 255, 255], vec![254, 254, 254], 1)],
            ephemeral_pub_key: vec![5; 32],
            commitment: vec![],
            tweak: Tweak::from_slice(&[7; SECRET_KEY_SIZE]).unwrap(),
            secret_r: [8; 32],
            sc_addr: "someAddress".to_string(),
            state_changes: (serde_json::Value::Null, 10),
        };
        let expected_hash = {
            let data = serde_json::to_vec(&tx).unwrap();
            let mut hasher = sha2::Sha256::new();
            hasher.update(&data);
            TreeHashType::from(hasher.finalize_fixed())
        };

        let hash = tx.hash();

        assert_eq!(expected_hash, hash);
    }
}