Struct BlockParser 

pub struct BlockParser {}

Block parser that extracts generator information from FullBlock structures

Implementations

impl BlockParser

pub fn new() -> Self

Examples found in repository

examples/basic_usage.rs (line 5)

fn main() {
    // Initialize the parser
    let parser = BlockParser::new();

    // Example 1: Parse generator from hex string
    let example_generator_hex = "ff02ffff01ff02ffff01ff02ffff03ff0bffff01ff02ffff03ffff09ff05ffff1dff0bffff1effff0bff0bffff02ff06ffff04ff02ffff04ff17ff8080808080808080ffff01ff02ff17ff2f80ffff01ff088080ff0180ffff01ff04ffff04ff04ffff04ff05ffff04ff0bff80808080ff018080ffff02ffff03ff0bffff01ff02ffff03ffff09ff05ffff1dff0bffff1effff0bff0bffff02ff06ffff04ff02ffff04ff17ff8080808080808080ffff01ff02ff17ff2f80ffff01ff088080ff0180ffff01ff04ffff04ff04ffff04ff05ffff04ff0bff80808080ff018080";

    match parser.parse_generator_from_hex(example_generator_hex) {
        Ok(parsed_generator) => {
            println!("Successfully parsed generator:");
            println!(
                "  Generator size: {} bytes",
                parsed_generator.analysis.size_bytes
            );
            println!(
                "  Contains CLVM patterns: {}",
                parsed_generator.analysis.contains_clvm_patterns
            );
            println!(
                "  Contains coin patterns: {}",
                parsed_generator.analysis.contains_coin_patterns
            );
            println!("  Entropy: {:.2}", parsed_generator.analysis.entropy);
            println!("  Block info: {:?}", parsed_generator.block_info);
        }
        Err(e) => {
            eprintln!("Error parsing generator: {}", e);
        }
    }

    // Example 2: Parse generator from bytes
    let generator_bytes = hex::decode("ff80").unwrap(); // Simple empty list
    match parser.parse_generator_from_bytes(&generator_bytes) {
        Ok(parsed_generator) => {
            println!("\nParsed simple generator:");
            println!(
                "  Generator size: {} bytes",
                parsed_generator.analysis.size_bytes
            );
            println!("  Is empty: {}", parsed_generator.analysis.is_empty);
        }
        Err(e) => {
            eprintln!("Error parsing simple generator: {}", e);
        }
    }

    // Example 3: Analyze generator bytecode
    let test_bytes = b"Hello, CLVM World!";
    match parser.analyze_generator(test_bytes) {
        Ok(analysis) => {
            println!("\nAnalyzing test bytes:");
            println!("  Size: {} bytes", analysis.size_bytes);
            println!("  Entropy: {:.2}", analysis.entropy);
            println!(
                "  Contains CLVM patterns: {}",
                analysis.contains_clvm_patterns
            );
        }
        Err(e) => {
            eprintln!("Error analyzing test bytes: {}", e);
        }
    }

    println!("\n✅ Production-quality generator parser completed!");
    println!("Features implemented:");
    println!("  🔄 Complete Python full_block_utils.py compatibility");
    println!("  🚀 Production CLVM serialization length calculation");
    println!("  📊 Advanced generator analysis and pattern detection");
    println!("  🛡️  Comprehensive error handling and validation");
    println!("  🏗️  All reference functions: block_info_from_block, generator_from_block, get_height_and_tx_status_from_block");
}

pub fn parse_full_block(&self, block: &FullBlock) -> Result<ParsedBlock>

Parse a FullBlock directly instead of bytes

pub fn parse_full_block_from_bytes( &self, block_bytes: &[u8], ) -> Result<ParsedBlock>

Parse a full block from bytes (for backwards compatibility)

pub fn parse_block_info(&self, block: &FullBlock) -> Result<GeneratorBlockInfo>

Extract generator block info from a FullBlock

pub fn extract_generator_from_block( &self, block: &FullBlock, ) -> Result<Option<Vec<u8>>>

Extract just the generator from a FullBlock

pub fn get_height_and_tx_status_from_block( &self, block: &FullBlock, ) -> Result<BlockHeightInfo>

Get block height and transaction status from a FullBlock

pub fn parse_generator_from_hex( &self, generator_hex: &str, ) -> Result<ParsedGenerator>

Parse generator from hex string

Examples found in repository

examples/basic_usage.rs (line 10)

fn main() {
    // Initialize the parser
    let parser = BlockParser::new();

    // Example 1: Parse generator from hex string
    let example_generator_hex = "ff02ffff01ff02ffff01ff02ffff03ff0bffff01ff02ffff03ffff09ff05ffff1dff0bffff1effff0bff0bffff02ff06ffff04ff02ffff04ff17ff8080808080808080ffff01ff02ff17ff2f80ffff01ff088080ff0180ffff01ff04ffff04ff04ffff04ff05ffff04ff0bff80808080ff018080ffff02ffff03ff0bffff01ff02ffff03ffff09ff05ffff1dff0bffff1effff0bff0bffff02ff06ffff04ff02ffff04ff17ff8080808080808080ffff01ff02ff17ff2f80ffff01ff088080ff0180ffff01ff04ffff04ff04ffff04ff05ffff04ff0bff80808080ff018080";

    match parser.parse_generator_from_hex(example_generator_hex) {
        Ok(parsed_generator) => {
            println!("Successfully parsed generator:");
            println!(
                "  Generator size: {} bytes",
                parsed_generator.analysis.size_bytes
            );
            println!(
                "  Contains CLVM patterns: {}",
                parsed_generator.analysis.contains_clvm_patterns
            );
            println!(
                "  Contains coin patterns: {}",
                parsed_generator.analysis.contains_coin_patterns
            );
            println!("  Entropy: {:.2}", parsed_generator.analysis.entropy);
            println!("  Block info: {:?}", parsed_generator.block_info);
        }
        Err(e) => {
            eprintln!("Error parsing generator: {}", e);
        }
    }

    // Example 2: Parse generator from bytes
    let generator_bytes = hex::decode("ff80").unwrap(); // Simple empty list
    match parser.parse_generator_from_bytes(&generator_bytes) {
        Ok(parsed_generator) => {
            println!("\nParsed simple generator:");
            println!(
                "  Generator size: {} bytes",
                parsed_generator.analysis.size_bytes
            );
            println!("  Is empty: {}", parsed_generator.analysis.is_empty);
        }
        Err(e) => {
            eprintln!("Error parsing simple generator: {}", e);
        }
    }

    // Example 3: Analyze generator bytecode
    let test_bytes = b"Hello, CLVM World!";
    match parser.analyze_generator(test_bytes) {
        Ok(analysis) => {
            println!("\nAnalyzing test bytes:");
            println!("  Size: {} bytes", analysis.size_bytes);
            println!("  Entropy: {:.2}", analysis.entropy);
            println!(
                "  Contains CLVM patterns: {}",
                analysis.contains_clvm_patterns
            );
        }
        Err(e) => {
            eprintln!("Error analyzing test bytes: {}", e);
        }
    }

    println!("\n✅ Production-quality generator parser completed!");
    println!("Features implemented:");
    println!("  🔄 Complete Python full_block_utils.py compatibility");
    println!("  🚀 Production CLVM serialization length calculation");
    println!("  📊 Advanced generator analysis and pattern detection");
    println!("  🛡️  Comprehensive error handling and validation");
    println!("  🏗️  All reference functions: block_info_from_block, generator_from_block, get_height_and_tx_status_from_block");
}

pub fn parse_generator_from_bytes( &self, generator_bytes: &[u8], ) -> Result<ParsedGenerator>

Parse generator from bytes

Examples found in repository

examples/basic_usage.rs (line 35)

fn main() {
    // Initialize the parser
    let parser = BlockParser::new();

    // Example 1: Parse generator from hex string
    let example_generator_hex = "ff02ffff01ff02ffff01ff02ffff03ff0bffff01ff02ffff03ffff09ff05ffff1dff0bffff1effff0bff0bffff02ff06ffff04ff02ffff04ff17ff8080808080808080ffff01ff02ff17ff2f80ffff01ff088080ff0180ffff01ff04ffff04ff04ffff04ff05ffff04ff0bff80808080ff018080ffff02ffff03ff0bffff01ff02ffff03ffff09ff05ffff1dff0bffff1effff0bff0bffff02ff06ffff04ff02ffff04ff17ff8080808080808080ffff01ff02ff17ff2f80ffff01ff088080ff0180ffff01ff04ffff04ff04ffff04ff05ffff04ff0bff80808080ff018080";

    match parser.parse_generator_from_hex(example_generator_hex) {
        Ok(parsed_generator) => {
            println!("Successfully parsed generator:");
            println!(
                "  Generator size: {} bytes",
                parsed_generator.analysis.size_bytes
            );
            println!(
                "  Contains CLVM patterns: {}",
                parsed_generator.analysis.contains_clvm_patterns
            );
            println!(
                "  Contains coin patterns: {}",
                parsed_generator.analysis.contains_coin_patterns
            );
            println!("  Entropy: {:.2}", parsed_generator.analysis.entropy);
            println!("  Block info: {:?}", parsed_generator.block_info);
        }
        Err(e) => {
            eprintln!("Error parsing generator: {}", e);
        }
    }

    // Example 2: Parse generator from bytes
    let generator_bytes = hex::decode("ff80").unwrap(); // Simple empty list
    match parser.parse_generator_from_bytes(&generator_bytes) {
        Ok(parsed_generator) => {
            println!("\nParsed simple generator:");
            println!(
                "  Generator size: {} bytes",
                parsed_generator.analysis.size_bytes
            );
            println!("  Is empty: {}", parsed_generator.analysis.is_empty);
        }
        Err(e) => {
            eprintln!("Error parsing simple generator: {}", e);
        }
    }

    // Example 3: Analyze generator bytecode
    let test_bytes = b"Hello, CLVM World!";
    match parser.analyze_generator(test_bytes) {
        Ok(analysis) => {
            println!("\nAnalyzing test bytes:");
            println!("  Size: {} bytes", analysis.size_bytes);
            println!("  Entropy: {:.2}", analysis.entropy);
            println!(
                "  Contains CLVM patterns: {}",
                analysis.contains_clvm_patterns
            );
        }
        Err(e) => {
            eprintln!("Error analyzing test bytes: {}", e);
        }
    }

    println!("\n✅ Production-quality generator parser completed!");
    println!("Features implemented:");
    println!("  🔄 Complete Python full_block_utils.py compatibility");
    println!("  🚀 Production CLVM serialization length calculation");
    println!("  📊 Advanced generator analysis and pattern detection");
    println!("  🛡️  Comprehensive error handling and validation");
    println!("  🏗️  All reference functions: block_info_from_block, generator_from_block, get_height_and_tx_status_from_block");
}

pub fn analyze_generator( &self, generator_bytes: &[u8], ) -> Result<GeneratorAnalysis>

Analyze generator bytecode

Examples found in repository

examples/basic_usage.rs (line 51)

fn main() {
    // Initialize the parser
    let parser = BlockParser::new();

    // Example 1: Parse generator from hex string
    let example_generator_hex = "ff02ffff01ff02ffff01ff02ffff03ff0bffff01ff02ffff03ffff09ff05ffff1dff0bffff1effff0bff0bffff02ff06ffff04ff02ffff04ff17ff8080808080808080ffff01ff02ff17ff2f80ffff01ff088080ff0180ffff01ff04ffff04ff04ffff04ff05ffff04ff0bff80808080ff018080ffff02ffff03ff0bffff01ff02ffff03ffff09ff05ffff1dff0bffff1effff0bff0bffff02ff06ffff04ff02ffff04ff17ff8080808080808080ffff01ff02ff17ff2f80ffff01ff088080ff0180ffff01ff04ffff04ff04ffff04ff05ffff04ff0bff80808080ff018080";

    match parser.parse_generator_from_hex(example_generator_hex) {
        Ok(parsed_generator) => {
            println!("Successfully parsed generator:");
            println!(
                "  Generator size: {} bytes",
                parsed_generator.analysis.size_bytes
            );
            println!(
                "  Contains CLVM patterns: {}",
                parsed_generator.analysis.contains_clvm_patterns
            );
            println!(
                "  Contains coin patterns: {}",
                parsed_generator.analysis.contains_coin_patterns
            );
            println!("  Entropy: {:.2}", parsed_generator.analysis.entropy);
            println!("  Block info: {:?}", parsed_generator.block_info);
        }
        Err(e) => {
            eprintln!("Error parsing generator: {}", e);
        }
    }

    // Example 2: Parse generator from bytes
    let generator_bytes = hex::decode("ff80").unwrap(); // Simple empty list
    match parser.parse_generator_from_bytes(&generator_bytes) {
        Ok(parsed_generator) => {
            println!("\nParsed simple generator:");
            println!(
                "  Generator size: {} bytes",
                parsed_generator.analysis.size_bytes
            );
            println!("  Is empty: {}", parsed_generator.analysis.is_empty);
        }
        Err(e) => {
            eprintln!("Error parsing simple generator: {}", e);
        }
    }

    // Example 3: Analyze generator bytecode
    let test_bytes = b"Hello, CLVM World!";
    match parser.analyze_generator(test_bytes) {
        Ok(analysis) => {
            println!("\nAnalyzing test bytes:");
            println!("  Size: {} bytes", analysis.size_bytes);
            println!("  Entropy: {:.2}", analysis.entropy);
            println!(
                "  Contains CLVM patterns: {}",
                analysis.contains_clvm_patterns
            );
        }
        Err(e) => {
            eprintln!("Error analyzing test bytes: {}", e);
        }
    }

    println!("\n✅ Production-quality generator parser completed!");
    println!("Features implemented:");
    println!("  🔄 Complete Python full_block_utils.py compatibility");
    println!("  🚀 Production CLVM serialization length calculation");
    println!("  📊 Advanced generator analysis and pattern detection");
    println!("  🛡️  Comprehensive error handling and validation");
    println!("  🏗️  All reference functions: block_info_from_block, generator_from_block, get_height_and_tx_status_from_block");
}

Trait Implementations

impl Default for BlockParser

fn default() -> Self

Returns the “default value” for a type.