Struct QuantumBlockchain 

pub struct QuantumBlockchain {
    pub chain: Vec<Block>,
    pub pending_transactions: Vec<Transaction>,
    pub difficulty: usize,
    pub consensus: ConsensusType,
    pub nodes: Vec<String>,
}

Quantum blockchain with distributed ledger

Fields

chain: Vec<Block>

Chain of blocks

pending_transactions: Vec<Transaction>

Pending transactions

difficulty: usize

Mining difficulty

consensus: ConsensusType

Consensus algorithm

nodes: Vec<String>

Network nodes

Implementations

impl QuantumBlockchain

pub fn new(consensus: ConsensusType, difficulty: usize) -> Self

Creates a new quantum blockchain

Examples found in repository

examples/quantum_crypto.rs (line 226)

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 add_transaction(&mut self, transaction: Transaction) -> Result<()>

Adds a transaction to the pending transactions

Examples found in repository

examples/quantum_crypto.rs (line 247)

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 mine_block(&mut self) -> Result<Block>

Mines a new block

Examples found in repository

examples/quantum_crypto.rs (line 252)

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 verify(&self) -> Result<bool>

Verifies the blockchain

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

Alias for verify() - to match the example call

Examples found in repository

examples/quantum_crypto.rs (line 263)

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 tamper_with_block( &self, block_index: usize, sender: &str, amount: f64, ) -> Result<QuantumBlockchain>

Gets a blockchain with a tampered block for testing

Trait Implementations

impl Clone for QuantumBlockchain

fn clone(&self) -> QuantumBlockchain

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QuantumBlockchain

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

Formats the value using the given formatter.