Struct Transaction 

pub struct Transaction {
    pub sender: Vec<u8>,
    pub recipient: Vec<u8>,
    pub amount: f64,
    pub data: Vec<u8>,
    /* private fields */
}

Represents a transaction in a quantum blockchain

Fields

sender: Vec<u8>

Sender’s public key hash

recipient: Vec<u8>

Recipient’s public key hash

amount: f64

Amount to transfer

data: Vec<u8>

Additional data (can be used for smart contracts)

Implementations

impl Transaction

pub fn new( sender: Vec<u8>, recipient: Vec<u8>, amount: f64, data: Vec<u8>, ) -> Self

Creates a new transaction

Examples found in repository

examples/quantum_crypto.rs (line 243)

fn run_blockchain_example() -> Result<()> {
    println!("\nQuantum Blockchain Example");
    println!("-------------------------");

    use quantrs2_ml::blockchain::{ConsensusType, QuantumBlockchain, Transaction};

    // Create a quantum blockchain
    let difficulty = 2; // 2 leading zeros required for mining
    println!("Creating quantum blockchain with difficulty {}", difficulty);
    let mut blockchain = QuantumBlockchain::new(ConsensusType::QuantumProofOfWork, difficulty);

    // Create a transaction
    let sender = vec![1, 2, 3, 4];
    let recipient = vec![5, 6, 7, 8];
    let amount = 100.0;

    println!(
        "Creating transaction: {} sends {} units to recipient",
        sender
            .iter()
            .map(|&b| b.to_string())
            .collect::<Vec<_>>()
            .join(""),
        amount
    );

    let transaction = Transaction::new(sender.clone(), recipient.clone(), amount, Vec::new());

    // Add transaction
    println!("Adding transaction to blockchain...");
    blockchain.add_transaction(transaction)?;

    // Mine a block
    println!("Mining new block...");
    let start = Instant::now();
    let block = blockchain.mine_block()?;
    println!("Block mined in {:.2?}", start.elapsed());

    println!(
        "Block hash: {:02x?}",
        &block.hash[0..8.min(block.hash.len())]
    );
    println!("Blockchain length: {}", blockchain.chain.len());

    // Verify blockchain
    println!("Verifying blockchain integrity...");
    let is_valid = blockchain.verify_chain()?;

    if is_valid {
        println!("✓ Blockchain verification successful!");
    } else {
        println!("✗ Blockchain verification failed!");
    }

    Ok(())
}

pub fn sign(&mut self, signature: Vec<u8>) -> Result<()>

Signs the transaction

pub fn verify(&self) -> Result<bool>

Verifies the transaction signature

pub fn hash(&self) -> Vec<u8>

Gets the transaction hash

Trait Implementations

impl Clone for Transaction

fn clone(&self) -> Transaction

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Transaction

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.