<<<<<<< HEAD

Smart Contract Storage and Execution

The ZHTP Unified Storage System includes built-in support for storing and executing smart contracts through the DHT layer. This example demonstrates how to deploy, query, and interact with smart contracts stored in the distributed network.

Overview

Smart contracts in ZHTP storage are:

WASM-based: Contracts are compiled to WebAssembly for secure execution
DHT-distributed: Contract bytecode and metadata are replicated across the network
Discoverable: Contracts can be found by tags, names, and metadata
Versioned: Multiple versions of contracts can coexist
Metadata-rich: Comprehensive metadata for contract discovery and usage

Deploying Smart Contracts

Basic Contract Deployment

use lib_storage::*;
use lib_identity::ZhtpIdentity;
use std::fs;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize storage system
    let config = UnifiedStorageConfig::default();
    let mut storage = UnifiedStorageSystem::new(config).await?;
    
    // Create developer identity
    let developer = create_developer_identity()?;
    
    // Deploy a simple contract
    deploy_hello_world_contract(&mut storage, developer.clone()).await?;
    
    // Deploy a payment processor contract
    deploy_payment_contract(&mut storage, developer.clone()).await?;
    
    // Deploy a data registry contract
    deploy_registry_contract(&mut storage, developer).await?;
    
    Ok(())
}

async fn deploy_hello_world_contract(
    storage: &mut UnifiedStorageSystem,
    developer: ZhtpIdentity
) -> Result<String, Box<dyn std::error::Error>> {
    
    // Load compiled WASM contract
    let wasm_bytecode = compile_hello_world_contract()?;
    
    // Create contract metadata
    let metadata = ContractMetadata {
        name: "Hello World".to_string(),
        version: "1.0.0".to_string(),
        description: "Simple greeting contract for demonstration".to_string(),
        author: "ZHTP Developer".to_string(),
        tags: vec![
            "demo".to_string(),
            "hello".to_string(),
            "simple".to_string()
        ],
        abi: Some(serde_json::json!({
            "functions": [
                {
                    "name": "greet",
                    "inputs": [{"name": "name", "type": "string"}],
                    "outputs": [{"name": "greeting", "type": "string"}]
                }
            ]
        })),
        dependencies: vec![],
        license: Some("MIT".to_string()),
        repository: Some("https://github.com/zhtp/contracts".to_string()),
    };
    
    // Deploy contract to DHT
    let contract_id = "hello_world_v1".to_string();
    
    // Create contract deployment message
    let contract_data = ContractDhtData {
        contract_id: contract_id.clone(),
        bytecode: Some(wasm_bytecode),
        metadata: Some(metadata),
        function_name: None,
        function_args: vec![],
    };
    
    // Store contract in DHT (this would normally be done through DHT messaging)
    let contract_key = format!("contract:{}", contract_id);
    let contract_info = serde_json::json!({
        "contract_id": contract_id,
        "bytecode": hex::encode(&contract_data.bytecode.as_ref().unwrap()),
        "metadata": contract_data.metadata,
        "deployed_at": std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap().as_secs(),
        "deployer": hex::encode(developer.id.as_bytes())
    });
    
    let serialized_contract = serde_json::to_vec(&contract_info)?;
    
    // Upload contract as regular content (this integrates with DHT storage)
    let upload_request = UploadRequest {
        content: serialized_contract,
        filename: format!("{}.contract", contract_id),
        mime_type: "application/wasm".to_string(),
        description: "Smart contract deployment".to_string(),
        tags: vec!["contract".to_string(), "wasm".to_string()],
        encrypt: false, // Contracts are typically public
        compress: true,
        access_control: AccessControlSettings {
            public_read: true,
            read_permissions: vec![],
            write_permissions: vec![],
            expires_at: None,
        },
        storage_requirements: ContentStorageRequirements {
            duration_days: 3650, // 10 years for long-term contract storage
            quality_requirements: QualityRequirements {
                min_uptime: 0.99,
                max_response_time: 1000,
                min_replication: 5,
                data_integrity_level: 0.999,
            },
            budget_constraints: BudgetConstraints {
                max_total_cost: 100000, // 100K ZHTP tokens
                max_cost_per_gb_day: 200,
                preferred_payment_schedule: PaymentSchedule::Annual,
            },
        },
    };
    
    let content_hash = storage.upload_content(upload_request, developer).await?;
    
    println!(" Hello World contract deployed:");
    println!("  Contract ID: {}", contract_id);
    println!("  Content Hash: {}", hex::encode(content_hash.as_bytes()));
    println!("  Bytecode size: {} bytes", contract_data.bytecode.unwrap().len());
    
    Ok(contract_id)
}

Payment Processor Contract

async fn deploy_payment_contract(
    storage: &mut UnifiedStorageSystem,
    developer: ZhtpIdentity
) -> Result<String, Box<dyn std::error::Error>> {
    
    let wasm_bytecode = compile_payment_contract()?;
    
    let metadata = ContractMetadata {
        name: "Payment Processor".to_string(),
        version: "2.1.0".to_string(),
        description: "Automated payment processing with escrow support".to_string(),
        author: "ZHTP Financial Team".to_string(),
        tags: vec![
            "payment".to_string(),
            "escrow".to_string(),
            "finance".to_string(),
            "automation".to_string()
        ],
        abi: Some(serde_json::json!({
            "functions": [
                {
                    "name": "create_payment",
                    "inputs": [
                        {"name": "recipient", "type": "address"},
                        {"name": "amount", "type": "uint64"},
                        {"name": "conditions", "type": "string"}
                    ],
                    "outputs": [{"name": "payment_id", "type": "string"}]
                },
                {
                    "name": "release_payment",
                    "inputs": [{"name": "payment_id", "type": "string"}],
                    "outputs": [{"name": "success", "type": "bool"}]
                },
                {
                    "name": "get_payment_status",
                    "inputs": [{"name": "payment_id", "type": "string"}],
                    "outputs": [{"name": "status", "type": "string"}]
                }
            ]
        })),
        dependencies: vec!["escrow_manager".to_string()],
        license: Some("Apache-2.0".to_string()),
        repository: Some("https://github.com/zhtp/payment-contracts".to_string()),
    };
    
    let contract_id = "payment_processor_v2".to_string();
    
    // Deploy with higher quality requirements for financial contracts
    let upload_request = UploadRequest {
        content: create_contract_package(&contract_id, &wasm_bytecode, &metadata)?,
        filename: format!("{}.contract", contract_id),
        mime_type: "application/wasm".to_string(),
        description: "Payment processor smart contract".to_string(),
        tags: vec!["contract".to_string(), "payment".to_string(), "critical".to_string()],
        encrypt: false,
        compress: true,
        access_control: AccessControlSettings {
            public_read: true,
            read_permissions: vec![],
            write_permissions: vec![],
            expires_at: None,
        },
        storage_requirements: ContentStorageRequirements {
            duration_days: 3650, // 10 years
            quality_requirements: QualityRequirements {
                min_uptime: 0.999,    // 99.9% uptime for critical contracts
                max_response_time: 500, // 500ms for financial operations
                min_replication: 8,     // Higher replication for security
                data_integrity_level: 0.9999, // 99.99% integrity
            },
            budget_constraints: BudgetConstraints {
                max_total_cost: 500000, // 500K ZHTP tokens
                max_cost_per_gb_day: 1000, // Premium pricing for critical contracts
                preferred_payment_schedule: PaymentSchedule::Annual,
            },
        },
    };
    
    let content_hash = storage.upload_content(upload_request, developer).await?;
    
    println!(" Payment Processor contract deployed:");
    println!("  Contract ID: {}", contract_id);
    println!("  Version: {}", metadata.version);
    println!("  Content Hash: {}", hex::encode(content_hash.as_bytes()));
    
    Ok(contract_id)
}

Contract Discovery and Querying

Finding Contracts by Tags

async fn discover_contracts(
    storage: &UnifiedStorageSystem,
    user: ZhtpIdentity
) -> Result<(), Box<dyn std::error::Error>> {
    
    // Search for payment-related contracts
    let payment_query = SearchQuery {
        keywords: vec!["payment".to_string()],
        content_type: Some("application/wasm".to_string()),
        tags: vec!["contract".to_string(), "payment".to_string()],
        owner: None,
        date_range: None,
        size_range: None,
        limit: 10,
    };
    
    let payment_contracts = storage.search_content(payment_query, user.clone()).await?;
    
    println!("💳 Found {} payment contracts:", payment_contracts.len());
    for contract in &payment_contracts {
        println!("   {} - {}", contract.filename, contract.description);
        println!("      Tags: {:?}", contract.tags);
        println!("      Size: {} bytes", contract.size);
        
        // Parse contract metadata if available
        if let Ok(contract_info) = parse_contract_metadata(contract) {
            println!("      Version: {}", contract_info.version);
            println!("      Author: {}", contract_info.author);
        }
    }
    
    // Search for demo contracts
    let demo_query = SearchQuery {
        keywords: vec!["demo".to_string(), "example".to_string()],
        content_type: Some("application/wasm".to_string()),
        tags: vec!["contract".to_string()],
        owner: None,
        date_range: None,
        size_range: None,
        limit: 5,
    };
    
    let demo_contracts = storage.search_content(demo_query, user.clone()).await?;
    
    println!("\\n Found {} demo contracts:", demo_contracts.len());
    for contract in &demo_contracts {
        println!("   {} - {}", contract.filename, contract.description);
    }
    
    // Search by specific author
    let author_query = SearchQuery {
        keywords: vec!["ZHTP".to_string()],
        content_type: Some("application/wasm".to_string()),
        tags: vec!["contract".to_string()],
        owner: None,
        date_range: None,
        size_range: None,
        limit: 20,
    };
    
    let author_contracts = storage.search_content(author_query, user).await?;
    
    println!("\\n Found {} ZHTP contracts:", author_contracts.len());
    for contract in &author_contracts {
        println!("   {}", contract.filename);
    }
    
    Ok(())
}

Contract Metadata Analysis

async fn analyze_contract(
    storage: &mut UnifiedStorageSystem,
    contract_hash: ContentHash,
    user: ZhtpIdentity
) -> Result<(), Box<dyn std::error::Error>> {
    
    // Download contract data
    let download_request = DownloadRequest {
        content_hash: contract_hash,
        requester: user,
        access_proof: None,
    };
    
    let contract_data = storage.download_content(download_request).await?;
    
    // Parse contract information
    let contract_info: serde_json::Value = serde_json::from_slice(&contract_data)?;
    
    println!(" Contract Analysis:");
    println!("  Contract ID: {}", contract_info["contract_id"].as_str().unwrap_or("unknown"));
    
    if let Some(metadata) = contract_info["metadata"].as_object() {
        println!("  Name: {}", metadata["name"].as_str().unwrap_or("unnamed"));
        println!("  Version: {}", metadata["version"].as_str().unwrap_or("unknown"));
        println!("  Description: {}", metadata["description"].as_str().unwrap_or("no description"));
        println!("  Author: {}", metadata["author"].as_str().unwrap_or("anonymous"));
        
        if let Some(tags) = metadata["tags"].as_array() {
            let tag_strings: Vec<String> = tags.iter()
                .filter_map(|t| t.as_str())
                .map(|s| s.to_string())
                .collect();
            println!("  Tags: {:?}", tag_strings);
        }
        
        if let Some(abi) = metadata["abi"].as_object() {
            if let Some(functions) = abi["functions"].as_array() {
                println!("  Functions:");
                for func in functions {
                    if let Some(name) = func["name"].as_str() {
                        println!("    - {}", name);
                        
                        if let Some(inputs) = func["inputs"].as_array() {
                            for input in inputs {
                                if let (Some(input_name), Some(input_type)) = 
                                    (input["name"].as_str(), input["type"].as_str()) {
                                    println!("      Input: {} ({})", input_name, input_type);
                                }
                            }
                        }
                        
                        if let Some(outputs) = func["outputs"].as_array() {
                            for output in outputs {
                                if let (Some(output_name), Some(output_type)) = 
                                    (output["name"].as_str(), output["type"].as_str()) {
                                    println!("      Output: {} ({})", output_name, output_type);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    // Analyze bytecode
    if let Some(bytecode_hex) = contract_info["bytecode"].as_str() {
        if let Ok(bytecode) = hex::decode(bytecode_hex) {
            println!("  Bytecode size: {} bytes", bytecode.len());
            println!("  Bytecode hash: {}", hex::encode(blake3::hash(&bytecode).as_bytes()));
            
            // Basic WASM validation
            if bytecode.starts_with(&[0x00, 0x61, 0x73, 0x6d]) {
                println!("   Valid WASM magic number");
            } else {
                println!("   Invalid WASM magic number");
            }
        }
    }
    
    println!("  Deployed at: {}", contract_info["deployed_at"].as_u64().unwrap_or(0));
    println!("  Deployer: {}", contract_info["deployer"].as_str().unwrap_or("unknown"));
    
    Ok(())
}

Contract Execution Simulation

// Note: This is a simulation - actual contract execution would require a WASM runtime
async fn simulate_contract_execution(
    storage: &mut UnifiedStorageSystem,
    contract_id: &str,
    function_name: &str,
    args: Vec<String>,
    caller: ZhtpIdentity
) -> Result<String, Box<dyn std::error::Error>> {
    
    println!(" Simulating contract execution:");
    println!("  Contract: {}", contract_id);
    println!("  Function: {}", function_name);
    println!("  Arguments: {:?}", args);
    
    // In a implementation, this would:
    // 1. Download contract bytecode
    // 2. Initialize WASM runtime
    // 3. Load contract into runtime
    // 4. Execute function with arguments
    // 5. Return result
    
    match contract_id {
        "hello_world_v1" => {
            if function_name == "greet" && !args.is_empty() {
                let name = &args[0];
                let result = format!("Hello, {}! Welcome to ZHTP Storage.", name);
                println!("   Execution result: {}", result);
                Ok(result)
            } else {
                Err("Invalid function or arguments for hello_world_v1".into())
            }
        }
        
        "payment_processor_v2" => {
            match function_name {
                "create_payment" if args.len() >= 3 => {
                    let recipient = &args[0];
                    let amount = args[1].parse::<u64>().unwrap_or(0);
                    let conditions = &args[2];
                    
                    let payment_id = format!("pay_{}", hex::encode(&rand::random::<[u8; 8]>()));
                    
                    println!("  💳 Created payment:");
                    println!("    Payment ID: {}", payment_id);
                    println!("    Recipient: {}", recipient);
                    println!("    Amount: {} ZHTP", amount);
                    println!("    Conditions: {}", conditions);
                    
                    Ok(payment_id)
                }
                
                "release_payment" if !args.is_empty() => {
                    let payment_id = &args[0];
                    println!("   Payment {} released successfully", payment_id);
                    Ok("true".to_string())
                }
                
                "get_payment_status" if !args.is_empty() => {
                    let payment_id = &args[0];
                    let status = "pending"; // Simulated status
                    println!("   Payment {} status: {}", payment_id, status);
                    Ok(status.to_string())
                }
                
                _ => Err("Invalid function or arguments for payment_processor_v2".into())
            }
        }
        
        _ => {
            Err(format!("Unknown contract: {}", contract_id).into())
        }
    }
}

Contract Interaction Examples

Using Hello World Contract

async fn interact_with_hello_world(
    storage: &mut UnifiedStorageSystem,
    user: ZhtpIdentity
) -> Result<(), Box<dyn std::error::Error>> {
    
    println!("👋 Interacting with Hello World contract");
    
    // Call greet function with different names
    let names = vec!["Alice", "Bob", "ZHTP User"];
    
    for name in names {
        let result = simulate_contract_execution(
            storage,
            "hello_world_v1",
            "greet",
            vec![name.to_string()],
            user.clone()
        ).await?;
        
        println!("  Greeting for {}: {}", name, result);
    }
    
    Ok(())
}

Using Payment Processor Contract

async fn interact_with_payment_processor(
    storage: &mut UnifiedStorageSystem,
    user: ZhtpIdentity
) -> Result<(), Box<dyn std::error::Error>> {
    
    println!("💳 Interacting with Payment Processor contract");
    
    // Create a payment
    let payment_id = simulate_contract_execution(
        storage,
        "payment_processor_v2",
        "create_payment",
        vec![
            "recipient_address_123".to_string(),
            "1000".to_string(), // 1000 ZHTP tokens
            "Deliver goods within 7 days".to_string()
        ],
        user.clone()
    ).await?;
    
    // Check payment status
    let status = simulate_contract_execution(
        storage,
        "payment_processor_v2",  
        "get_payment_status",
        vec![payment_id.clone()],
        user.clone()
    ).await?;
    
    println!("Current payment status: {}", status);
    
    // Simulate condition fulfillment and release payment
    tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
    
    let release_result = simulate_contract_execution(
        storage,
        "payment_processor_v2",
        "release_payment", 
        vec![payment_id],
        user
    ).await?;
    
    println!("Payment release result: {}", release_result);
    
    Ok(())
}

Contract Registry Management

Contract Version Management

async fn manage_contract_versions(
    storage: &mut UnifiedStorageSystem,
    developer: ZhtpIdentity
) -> Result<(), Box<dyn std::error::Error>> {
    
    println!(" Managing contract versions");
    
    // Deploy version 1.0
    let v1_metadata = ContractMetadata {
        name: "Data Registry".to_string(),
        version: "1.0.0".to_string(),
        description: "Simple data registry contract".to_string(),
        author: "ZHTP Developer".to_string(),
        tags: vec!["registry".to_string(), "data".to_string()],
        abi: Some(serde_json::json!({
            "functions": [
                {
                    "name": "store_data",
                    "inputs": [{"name": "key", "type": "string"}, {"name": "value", "type": "string"}],
                    "outputs": [{"name": "success", "type": "bool"}]
                }
            ]
        })),
        dependencies: vec![],
        license: Some("MIT".to_string()),
        repository: None,
    };
    
    deploy_contract_version("data_registry_v1", &v1_metadata, storage, developer.clone()).await?;
    
    // Deploy version 2.0 with additional features
    let v2_metadata = ContractMetadata {
        name: "Data Registry".to_string(),
        version: "2.0.0".to_string(),
        description: "Enhanced data registry with search and permissions".to_string(),
        author: "ZHTP Developer".to_string(),
        tags: vec!["registry".to_string(), "data".to_string(), "enhanced".to_string()],
        abi: Some(serde_json::json!({
            "functions": [
                {
                    "name": "store_data",
                    "inputs": [{"name": "key", "type": "string"}, {"name": "value", "type": "string"}],
                    "outputs": [{"name": "success", "type": "bool"}]
                },
                {
                    "name": "search_data",
                    "inputs": [{"name": "query", "type": "string"}],
                    "outputs": [{"name": "results", "type": "array"}]
                },
                {
                    "name": "set_permissions",
                    "inputs": [{"name": "key", "type": "string"}, {"name": "permissions", "type": "string"}],
                    "outputs": [{"name": "success", "type": "bool"}]
                }
            ]
        })),
        dependencies: vec!["permissions_manager".to_string()],
        license: Some("MIT".to_string()),
        repository: Some("https://github.com/zhtp/data-registry".to_string()),
    };
    
    deploy_contract_version("data_registry_v2", &v2_metadata, storage, developer.clone()).await?;
    
    // List all versions
    list_contract_versions(storage, "data_registry", developer).await?;
    
    Ok(())
}

async fn deploy_contract_version(
    contract_id: &str,
    metadata: &ContractMetadata,
    storage: &mut UnifiedStorageSystem,
    developer: ZhtpIdentity
) -> Result<(), Box<dyn std::error::Error>> {
    
    let bytecode = compile_contract_by_name(&metadata.name, &metadata.version)?;
    
    let upload_request = UploadRequest {
        content: create_contract_package(contract_id, &bytecode, metadata)?,
        filename: format!("{}.contract", contract_id),
        mime_type: "application/wasm".to_string(),
        description: format!("{} v{}", metadata.name, metadata.version),
        tags: vec!["contract".to_string(), "version".to_string()],
        encrypt: false,
        compress: true,
        access_control: AccessControlSettings {
            public_read: true,
            read_permissions: vec![],
            write_permissions: vec![],
            expires_at: None,
        },
        storage_requirements: ContentStorageRequirements {
            duration_days: 1825, // 5 years
            quality_requirements: QualityRequirements::default(),
            budget_constraints: BudgetConstraints::default(),
        },
    };
    
    let content_hash = storage.upload_content(upload_request, developer).await?;
    
    println!(" Deployed {} v{}: {}", 
             metadata.name, 
             metadata.version, 
             hex::encode(content_hash.as_bytes()));
    
    Ok(())
}

Complete Contract Example

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!(" ZHTP Smart Contract Example");
    
    // Initialize storage system
    let config = UnifiedStorageConfig::default();
    let mut storage = UnifiedStorageSystem::new(config).await?;
    
    // Create identities
    let developer = create_developer_identity()?;
    let user = create_user_identity()?;
    
    println!("\\n Deploying contracts...");
    
    // Deploy contracts
    let hello_contract = deploy_hello_world_contract(&mut storage, developer.clone()).await?;
    let payment_contract = deploy_payment_contract(&mut storage, developer.clone()).await?;
    
    println!("\\n Discovering contracts...");
    
    // Discover contracts
    discover_contracts(&storage, user.clone()).await?;
    
    println!("\\n Executing contracts...");
    
    // Interact with contracts
    interact_with_hello_world(&mut storage, user.clone()).await?;
    interact_with_payment_processor(&mut storage, user.clone()).await?;
    
    println!("\\n System statistics:");
    let stats = storage.get_statistics().await?;
    println!("  Total content: {}", stats.storage_stats.total_content_count);
    println!("  Storage used: {} bytes", stats.storage_stats.total_storage_used);
    
    println!("\\n Smart contract example completed successfully!");
    
    Ok(())
}

// Helper functions for compilation and packaging
fn compile_hello_world_contract() -> Result<Vec<u8>, Box<dyn std::error::Error>> {
    // In a implementation, this would compile Rust/AssemblyScript to WASM
    // For this example, we'll return a minimal WASM module
    Ok(create_minimal_wasm_module("hello_world"))
}

fn compile_payment_contract() -> Result<Vec<u8>, Box<dyn std::error::Error>> {
    Ok(create_minimal_wasm_module("payment_processor"))
}

fn compile_contract_by_name(name: &str, version: &str) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
    Ok(create_minimal_wasm_module(&format!("{}_{}", name, version)))
}

fn create_minimal_wasm_module(name: &str) -> Vec<u8> {
    // WASM magic number + minimal module
    let mut module = vec![0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00];
    module.extend_from_slice(name.as_bytes());
    module
}

fn create_contract_package(
    contract_id: &str,
    bytecode: &[u8],
    metadata: &ContractMetadata
) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
    let package = serde_json::json!({
        "contract_id": contract_id,
        "bytecode": hex::encode(bytecode),
        "metadata": metadata,
        "deployed_at": std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap().as_secs()
    });
    
    Ok(serde_json::to_vec(&package)?)
}

// Additional helper functions...
fn create_developer_identity() -> Result<ZhtpIdentity, Box<dyn std::error::Error>> {
    // Implementation would create a proper developer identity
    unimplemented!("Create using lib-identity")  
}

fn create_user_identity() -> Result<ZhtpIdentity, Box<dyn std::error::Error>> {
    // Implementation would create a proper user identity
    unimplemented!("Create using lib-identity")
}

=======

Smart Contract Storage and Execution

Overview

Smart contracts in ZHTP storage are:

WASM-based: Contracts are compiled to WebAssembly for secure execution
DHT-distributed: Contract bytecode and metadata are replicated across the network
Discoverable: Contracts can be found by tags, names, and metadata
Versioned: Multiple versions of contracts can coexist
Metadata-rich: Comprehensive metadata for contract discovery and usage

Deploying Smart Contracts

Basic Contract Deployment

use lib_storage::*;
use lib_identity::ZhtpIdentity;
use std::fs;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize storage system
    let config = UnifiedStorageConfig::default();
    let mut storage = UnifiedStorageSystem::new(config).await?;
    
    // Create developer identity
    let developer = create_developer_identity()?;
    
    // Deploy a simple contract
    deploy_hello_world_contract(&mut storage, developer.clone()).await?;
    
    // Deploy a payment processor contract
    deploy_payment_contract(&mut storage, developer.clone()).await?;
    
    // Deploy a data registry contract
    deploy_registry_contract(&mut storage, developer).await?;
    
    Ok(())
}

async fn deploy_hello_world_contract(
    storage: &mut UnifiedStorageSystem,
    developer: ZhtpIdentity
) -> Result<String, Box<dyn std::error::Error>> {
    
    // Load compiled WASM contract
    let wasm_bytecode = compile_hello_world_contract()?;
    
    // Create contract metadata
    let metadata = ContractMetadata {
        name: "Hello World".to_string(),
        version: "1.0.0".to_string(),
        description: "Simple greeting contract for demonstration".to_string(),
        author: "ZHTP Developer".to_string(),
        tags: vec![
            "demo".to_string(),
            "hello".to_string(),
            "simple".to_string()
        ],
        abi: Some(serde_json::json!({
            "functions": [
                {
                    "name": "greet",
                    "inputs": [{"name": "name", "type": "string"}],
                    "outputs": [{"name": "greeting", "type": "string"}]
                }
            ]
        })),
        dependencies: vec![],
        license: Some("MIT".to_string()),
        repository: Some("https://github.com/zhtp/contracts".to_string()),
    };
    
    // Deploy contract to DHT
    let contract_id = "hello_world_v1".to_string();
    
    // Create contract deployment message
    let contract_data = ContractDhtData {
        contract_id: contract_id.clone(),
        bytecode: Some(wasm_bytecode),
        metadata: Some(metadata),
        function_name: None,
        function_args: vec![],
    };
    
    // Store contract in DHT (this would normally be done through DHT messaging)
    let contract_key = format!("contract:{}", contract_id);
    let contract_info = serde_json::json!({
        "contract_id": contract_id,
        "bytecode": hex::encode(&contract_data.bytecode.as_ref().unwrap()),
        "metadata": contract_data.metadata,
        "deployed_at": std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap().as_secs(),
        "deployer": hex::encode(developer.id.as_bytes())
    });
    
    let serialized_contract = serde_json::to_vec(&contract_info)?;
    
    // Upload contract as regular content (this integrates with DHT storage)
    let upload_request = UploadRequest {
        content: serialized_contract,
        filename: format!("{}.contract", contract_id),
        mime_type: "application/wasm".to_string(),
        description: "Smart contract deployment".to_string(),
        tags: vec!["contract".to_string(), "wasm".to_string()],
        encrypt: false, // Contracts are typically public
        compress: true,
        access_control: AccessControlSettings {
            public_read: true,
            read_permissions: vec![],
            write_permissions: vec![],
            expires_at: None,
        },
        storage_requirements: ContentStorageRequirements {
            duration_days: 3650, // 10 years for long-term contract storage
            quality_requirements: QualityRequirements {
                min_uptime: 0.99,
                max_response_time: 1000,
                min_replication: 5,
                data_integrity_level: 0.999,
            },
            budget_constraints: BudgetConstraints {
                max_total_cost: 100000, // 100K ZHTP tokens
                max_cost_per_gb_day: 200,
                preferred_payment_schedule: PaymentSchedule::Annual,
            },
        },
    };
    
    let content_hash = storage.upload_content(upload_request, developer).await?;
    
    println!(" Hello World contract deployed:");
    println!("  Contract ID: {}", contract_id);
    println!("  Content Hash: {}", hex::encode(content_hash.as_bytes()));
    println!("  Bytecode size: {} bytes", contract_data.bytecode.unwrap().len());
    
    Ok(contract_id)
}

Payment Processor Contract

async fn deploy_payment_contract(
    storage: &mut UnifiedStorageSystem,
    developer: ZhtpIdentity
) -> Result<String, Box<dyn std::error::Error>> {
    
    let wasm_bytecode = compile_payment_contract()?;
    
    let metadata = ContractMetadata {
        name: "Payment Processor".to_string(),
        version: "2.1.0".to_string(),
        description: "Automated payment processing with escrow support".to_string(),
        author: "ZHTP Financial Team".to_string(),
        tags: vec![
            "payment".to_string(),
            "escrow".to_string(),
            "finance".to_string(),
            "automation".to_string()
        ],
        abi: Some(serde_json::json!({
            "functions": [
                {
                    "name": "create_payment",
                    "inputs": [
                        {"name": "recipient", "type": "address"},
                        {"name": "amount", "type": "uint64"},
                        {"name": "conditions", "type": "string"}
                    ],
                    "outputs": [{"name": "payment_id", "type": "string"}]
                },
                {
                    "name": "release_payment",
                    "inputs": [{"name": "payment_id", "type": "string"}],
                    "outputs": [{"name": "success", "type": "bool"}]
                },
                {
                    "name": "get_payment_status",
                    "inputs": [{"name": "payment_id", "type": "string"}],
                    "outputs": [{"name": "status", "type": "string"}]
                }
            ]
        })),
        dependencies: vec!["escrow_manager".to_string()],
        license: Some("Apache-2.0".to_string()),
        repository: Some("https://github.com/zhtp/payment-contracts".to_string()),
    };
    
    let contract_id = "payment_processor_v2".to_string();
    
    // Deploy with higher quality requirements for financial contracts
    let upload_request = UploadRequest {
        content: create_contract_package(&contract_id, &wasm_bytecode, &metadata)?,
        filename: format!("{}.contract", contract_id),
        mime_type: "application/wasm".to_string(),
        description: "Payment processor smart contract".to_string(),
        tags: vec!["contract".to_string(), "payment".to_string(), "critical".to_string()],
        encrypt: false,
        compress: true,
        access_control: AccessControlSettings {
            public_read: true,
            read_permissions: vec![],
            write_permissions: vec![],
            expires_at: None,
        },
        storage_requirements: ContentStorageRequirements {
            duration_days: 3650, // 10 years
            quality_requirements: QualityRequirements {
                min_uptime: 0.999,    // 99.9% uptime for critical contracts
                max_response_time: 500, // 500ms for financial operations
                min_replication: 8,     // Higher replication for security
                data_integrity_level: 0.9999, // 99.99% integrity
            },
            budget_constraints: BudgetConstraints {
                max_total_cost: 500000, // 500K ZHTP tokens
                max_cost_per_gb_day: 1000, // Premium pricing for critical contracts
                preferred_payment_schedule: PaymentSchedule::Annual,
            },
        },
    };
    
    let content_hash = storage.upload_content(upload_request, developer).await?;
    
    println!(" Payment Processor contract deployed:");
    println!("  Contract ID: {}", contract_id);
    println!("  Version: {}", metadata.version);
    println!("  Content Hash: {}", hex::encode(content_hash.as_bytes()));
    
    Ok(contract_id)
}

Contract Discovery and Querying

Finding Contracts by Tags

async fn discover_contracts(
    storage: &UnifiedStorageSystem,
    user: ZhtpIdentity
) -> Result<(), Box<dyn std::error::Error>> {
    
    // Search for payment-related contracts
    let payment_query = SearchQuery {
        keywords: vec!["payment".to_string()],
        content_type: Some("application/wasm".to_string()),
        tags: vec!["contract".to_string(), "payment".to_string()],
        owner: None,
        date_range: None,
        size_range: None,
        limit: 10,
    };
    
    let payment_contracts = storage.search_content(payment_query, user.clone()).await?;
    
    println!("💳 Found {} payment contracts:", payment_contracts.len());
    for contract in &payment_contracts {
        println!("   {} - {}", contract.filename, contract.description);
        println!("      Tags: {:?}", contract.tags);
        println!("      Size: {} bytes", contract.size);
        
        // Parse contract metadata if available
        if let Ok(contract_info) = parse_contract_metadata(contract) {
            println!("      Version: {}", contract_info.version);
            println!("      Author: {}", contract_info.author);
        }
    }
    
    // Search for demo contracts
    let demo_query = SearchQuery {
        keywords: vec!["demo".to_string(), "example".to_string()],
        content_type: Some("application/wasm".to_string()),
        tags: vec!["contract".to_string()],
        owner: None,
        date_range: None,
        size_range: None,
        limit: 5,
    };
    
    let demo_contracts = storage.search_content(demo_query, user.clone()).await?;
    
    println!("\\n Found {} demo contracts:", demo_contracts.len());
    for contract in &demo_contracts {
        println!("   {} - {}", contract.filename, contract.description);
    }
    
    // Search by specific author
    let author_query = SearchQuery {
        keywords: vec!["ZHTP".to_string()],
        content_type: Some("application/wasm".to_string()),
        tags: vec!["contract".to_string()],
        owner: None,
        date_range: None,
        size_range: None,
        limit: 20,
    };
    
    let author_contracts = storage.search_content(author_query, user).await?;
    
    println!("\\n Found {} ZHTP contracts:", author_contracts.len());
    for contract in &author_contracts {
        println!("   {}", contract.filename);
    }
    
    Ok(())
}

Contract Metadata Analysis

async fn analyze_contract(
    storage: &mut UnifiedStorageSystem,
    contract_hash: ContentHash,
    user: ZhtpIdentity
) -> Result<(), Box<dyn std::error::Error>> {
    
    // Download contract data
    let download_request = DownloadRequest {
        content_hash: contract_hash,
        requester: user,
        access_proof: None,
    };
    
    let contract_data = storage.download_content(download_request).await?;
    
    // Parse contract information
    let contract_info: serde_json::Value = serde_json::from_slice(&contract_data)?;
    
    println!(" Contract Analysis:");
    println!("  Contract ID: {}", contract_info["contract_id"].as_str().unwrap_or("unknown"));
    
    if let Some(metadata) = contract_info["metadata"].as_object() {
        println!("  Name: {}", metadata["name"].as_str().unwrap_or("unnamed"));
        println!("  Version: {}", metadata["version"].as_str().unwrap_or("unknown"));
        println!("  Description: {}", metadata["description"].as_str().unwrap_or("no description"));
        println!("  Author: {}", metadata["author"].as_str().unwrap_or("anonymous"));
        
        if let Some(tags) = metadata["tags"].as_array() {
            let tag_strings: Vec<String> = tags.iter()
                .filter_map(|t| t.as_str())
                .map(|s| s.to_string())
                .collect();
            println!("  Tags: {:?}", tag_strings);
        }
        
        if let Some(abi) = metadata["abi"].as_object() {
            if let Some(functions) = abi["functions"].as_array() {
                println!("  Functions:");
                for func in functions {
                    if let Some(name) = func["name"].as_str() {
                        println!("    - {}", name);
                        
                        if let Some(inputs) = func["inputs"].as_array() {
                            for input in inputs {
                                if let (Some(input_name), Some(input_type)) = 
                                    (input["name"].as_str(), input["type"].as_str()) {
                                    println!("      Input: {} ({})", input_name, input_type);
                                }
                            }
                        }
                        
                        if let Some(outputs) = func["outputs"].as_array() {
                            for output in outputs {
                                if let (Some(output_name), Some(output_type)) = 
                                    (output["name"].as_str(), output["type"].as_str()) {
                                    println!("      Output: {} ({})", output_name, output_type);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    // Analyze bytecode
    if let Some(bytecode_hex) = contract_info["bytecode"].as_str() {
        if let Ok(bytecode) = hex::decode(bytecode_hex) {
            println!("  Bytecode size: {} bytes", bytecode.len());
            println!("  Bytecode hash: {}", hex::encode(blake3::hash(&bytecode).as_bytes()));
            
            // Basic WASM validation
            if bytecode.starts_with(&[0x00, 0x61, 0x73, 0x6d]) {
                println!("   Valid WASM magic number");
            } else {
                println!("   Invalid WASM magic number");
            }
        }
    }
    
    println!("  Deployed at: {}", contract_info["deployed_at"].as_u64().unwrap_or(0));
    println!("  Deployer: {}", contract_info["deployer"].as_str().unwrap_or("unknown"));
    
    Ok(())
}

Contract Execution Simulation

// Note: This is a simulation - actual contract execution would require a WASM runtime
async fn simulate_contract_execution(
    storage: &mut UnifiedStorageSystem,
    contract_id: &str,
    function_name: &str,
    args: Vec<String>,
    caller: ZhtpIdentity
) -> Result<String, Box<dyn std::error::Error>> {
    
    println!(" Simulating contract execution:");
    println!("  Contract: {}", contract_id);
    println!("  Function: {}", function_name);
    println!("  Arguments: {:?}", args);
    
    // In a implementation, this would:
    // 1. Download contract bytecode
    // 2. Initialize WASM runtime
    // 3. Load contract into runtime
    // 4. Execute function with arguments
    // 5. Return result
    
    match contract_id {
        "hello_world_v1" => {
            if function_name == "greet" && !args.is_empty() {
                let name = &args[0];
                let result = format!("Hello, {}! Welcome to ZHTP Storage.", name);
                println!("   Execution result: {}", result);
                Ok(result)
            } else {
                Err("Invalid function or arguments for hello_world_v1".into())
            }
        }
        
        "payment_processor_v2" => {
            match function_name {
                "create_payment" if args.len() >= 3 => {
                    let recipient = &args[0];
                    let amount = args[1].parse::<u64>().unwrap_or(0);
                    let conditions = &args[2];
                    
                    let payment_id = format!("pay_{}", hex::encode(&rand::random::<[u8; 8]>()));
                    
                    println!("  💳 Created payment:");
                    println!("    Payment ID: {}", payment_id);
                    println!("    Recipient: {}", recipient);
                    println!("    Amount: {} ZHTP", amount);
                    println!("    Conditions: {}", conditions);
                    
                    Ok(payment_id)
                }
                
                "release_payment" if !args.is_empty() => {
                    let payment_id = &args[0];
                    println!("   Payment {} released successfully", payment_id);
                    Ok("true".to_string())
                }
                
                "get_payment_status" if !args.is_empty() => {
                    let payment_id = &args[0];
                    let status = "pending"; // Simulated status
                    println!("   Payment {} status: {}", payment_id, status);
                    Ok(status.to_string())
                }
                
                _ => Err("Invalid function or arguments for payment_processor_v2".into())
            }
        }
        
        _ => {
            Err(format!("Unknown contract: {}", contract_id).into())
        }
    }
}

Contract Interaction Examples

Using Hello World Contract

async fn interact_with_hello_world(
    storage: &mut UnifiedStorageSystem,
    user: ZhtpIdentity
) -> Result<(), Box<dyn std::error::Error>> {
    
    println!("👋 Interacting with Hello World contract");
    
    // Call greet function with different names
    let names = vec!["Alice", "Bob", "ZHTP User"];
    
    for name in names {
        let result = simulate_contract_execution(
            storage,
            "hello_world_v1",
            "greet",
            vec![name.to_string()],
            user.clone()
        ).await?;
        
        println!("  Greeting for {}: {}", name, result);
    }
    
    Ok(())
}

Using Payment Processor Contract

async fn interact_with_payment_processor(
    storage: &mut UnifiedStorageSystem,
    user: ZhtpIdentity
) -> Result<(), Box<dyn std::error::Error>> {
    
    println!("💳 Interacting with Payment Processor contract");
    
    // Create a payment
    let payment_id = simulate_contract_execution(
        storage,
        "payment_processor_v2",
        "create_payment",
        vec![
            "recipient_address_123".to_string(),
            "1000".to_string(), // 1000 ZHTP tokens
            "Deliver goods within 7 days".to_string()
        ],
        user.clone()
    ).await?;
    
    // Check payment status
    let status = simulate_contract_execution(
        storage,
        "payment_processor_v2",  
        "get_payment_status",
        vec![payment_id.clone()],
        user.clone()
    ).await?;
    
    println!("Current payment status: {}", status);
    
    // Simulate condition fulfillment and release payment
    tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
    
    let release_result = simulate_contract_execution(
        storage,
        "payment_processor_v2",
        "release_payment", 
        vec![payment_id],
        user
    ).await?;
    
    println!("Payment release result: {}", release_result);
    
    Ok(())
}

Contract Registry Management

Contract Version Management

async fn manage_contract_versions(
    storage: &mut UnifiedStorageSystem,
    developer: ZhtpIdentity
) -> Result<(), Box<dyn std::error::Error>> {
    
    println!(" Managing contract versions");
    
    // Deploy version 1.0
    let v1_metadata = ContractMetadata {
        name: "Data Registry".to_string(),
        version: "1.0.0".to_string(),
        description: "Simple data registry contract".to_string(),
        author: "ZHTP Developer".to_string(),
        tags: vec!["registry".to_string(), "data".to_string()],
        abi: Some(serde_json::json!({
            "functions": [
                {
                    "name": "store_data",
                    "inputs": [{"name": "key", "type": "string"}, {"name": "value", "type": "string"}],
                    "outputs": [{"name": "success", "type": "bool"}]
                }
            ]
        })),
        dependencies: vec![],
        license: Some("MIT".to_string()),
        repository: None,
    };
    
    deploy_contract_version("data_registry_v1", &v1_metadata, storage, developer.clone()).await?;
    
    // Deploy version 2.0 with additional features
    let v2_metadata = ContractMetadata {
        name: "Data Registry".to_string(),
        version: "2.0.0".to_string(),
        description: "Enhanced data registry with search and permissions".to_string(),
        author: "ZHTP Developer".to_string(),
        tags: vec!["registry".to_string(), "data".to_string(), "enhanced".to_string()],
        abi: Some(serde_json::json!({
            "functions": [
                {
                    "name": "store_data",
                    "inputs": [{"name": "key", "type": "string"}, {"name": "value", "type": "string"}],
                    "outputs": [{"name": "success", "type": "bool"}]
                },
                {
                    "name": "search_data",
                    "inputs": [{"name": "query", "type": "string"}],
                    "outputs": [{"name": "results", "type": "array"}]
                },
                {
                    "name": "set_permissions",
                    "inputs": [{"name": "key", "type": "string"}, {"name": "permissions", "type": "string"}],
                    "outputs": [{"name": "success", "type": "bool"}]
                }
            ]
        })),
        dependencies: vec!["permissions_manager".to_string()],
        license: Some("MIT".to_string()),
        repository: Some("https://github.com/zhtp/data-registry".to_string()),
    };
    
    deploy_contract_version("data_registry_v2", &v2_metadata, storage, developer.clone()).await?;
    
    // List all versions
    list_contract_versions(storage, "data_registry", developer).await?;
    
    Ok(())
}

async fn deploy_contract_version(
    contract_id: &str,
    metadata: &ContractMetadata,
    storage: &mut UnifiedStorageSystem,
    developer: ZhtpIdentity
) -> Result<(), Box<dyn std::error::Error>> {
    
    let bytecode = compile_contract_by_name(&metadata.name, &metadata.version)?;
    
    let upload_request = UploadRequest {
        content: create_contract_package(contract_id, &bytecode, metadata)?,
        filename: format!("{}.contract", contract_id),
        mime_type: "application/wasm".to_string(),
        description: format!("{} v{}", metadata.name, metadata.version),
        tags: vec!["contract".to_string(), "version".to_string()],
        encrypt: false,
        compress: true,
        access_control: AccessControlSettings {
            public_read: true,
            read_permissions: vec![],
            write_permissions: vec![],
            expires_at: None,
        },
        storage_requirements: ContentStorageRequirements {
            duration_days: 1825, // 5 years
            quality_requirements: QualityRequirements::default(),
            budget_constraints: BudgetConstraints::default(),
        },
    };
    
    let content_hash = storage.upload_content(upload_request, developer).await?;
    
    println!(" Deployed {} v{}: {}", 
             metadata.name, 
             metadata.version, 
             hex::encode(content_hash.as_bytes()));
    
    Ok(())
}

Complete Contract Example

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!(" ZHTP Smart Contract Example");
    
    // Initialize storage system
    let config = UnifiedStorageConfig::default();
    let mut storage = UnifiedStorageSystem::new(config).await?;
    
    // Create identities
    let developer = create_developer_identity()?;
    let user = create_user_identity()?;
    
    println!("\\n Deploying contracts...");
    
    // Deploy contracts
    let hello_contract = deploy_hello_world_contract(&mut storage, developer.clone()).await?;
    let payment_contract = deploy_payment_contract(&mut storage, developer.clone()).await?;
    
    println!("\\n Discovering contracts...");
    
    // Discover contracts
    discover_contracts(&storage, user.clone()).await?;
    
    println!("\\n Executing contracts...");
    
    // Interact with contracts
    interact_with_hello_world(&mut storage, user.clone()).await?;
    interact_with_payment_processor(&mut storage, user.clone()).await?;
    
    println!("\\n System statistics:");
    let stats = storage.get_statistics().await?;
    println!("  Total content: {}", stats.storage_stats.total_content_count);
    println!("  Storage used: {} bytes", stats.storage_stats.total_storage_used);
    
    println!("\\n Smart contract example completed successfully!");
    
    Ok(())
}

// Helper functions for compilation and packaging
fn compile_hello_world_contract() -> Result<Vec<u8>, Box<dyn std::error::Error>> {
    // In a implementation, this would compile Rust/AssemblyScript to WASM
    // For this example, we'll return a minimal WASM module
    Ok(create_minimal_wasm_module("hello_world"))
}

fn compile_payment_contract() -> Result<Vec<u8>, Box<dyn std::error::Error>> {
    Ok(create_minimal_wasm_module("payment_processor"))
}

fn compile_contract_by_name(name: &str, version: &str) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
    Ok(create_minimal_wasm_module(&format!("{}_{}", name, version)))
}

fn create_minimal_wasm_module(name: &str) -> Vec<u8> {
    // WASM magic number + minimal module
    let mut module = vec![0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00];
    module.extend_from_slice(name.as_bytes());
    module
}

fn create_contract_package(
    contract_id: &str,
    bytecode: &[u8],
    metadata: &ContractMetadata
) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
    let package = serde_json::json!({
        "contract_id": contract_id,
        "bytecode": hex::encode(bytecode),
        "metadata": metadata,
        "deployed_at": std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap().as_secs()
    });
    
    Ok(serde_json::to_vec(&package)?)
}

// Additional helper functions...
fn create_developer_identity() -> Result<ZhtpIdentity, Box<dyn std::error::Error>> {
    // Implementation would create a proper developer identity
    unimplemented!("Create using lib-identity")  
}

fn create_user_identity() -> Result<ZhtpIdentity, Box<dyn std::error::Error>> {
    // Implementation would create a proper user identity
    unimplemented!("Create using lib-identity")
}

160e135c54d30cf715cbb2bc4e005cffdc6e9f77 This example demonstrates the complete smart contract lifecycle in ZHTP storage, from deployment through discovery to execution. The system provides a robust foundation for building decentralized applications with persistent, discoverable smart contracts.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Smart Contract Storage and Execution

Overview

Deploying Smart Contracts

Basic Contract Deployment

Payment Processor Contract

Contract Discovery and Querying

Finding Contracts by Tags

Contract Metadata Analysis

Contract Execution Simulation

Contract Interaction Examples

Using Hello World Contract

Using Payment Processor Contract

Contract Registry Management

Contract Version Management

Complete Contract Example

Smart Contract Storage and Execution

Overview

Deploying Smart Contracts

Basic Contract Deployment

Payment Processor Contract

Contract Discovery and Querying

Finding Contracts by Tags

Contract Metadata Analysis

Contract Execution Simulation

Contract Interaction Examples

Using Hello World Contract

Using Payment Processor Contract

Contract Registry Management

Contract Version Management

Complete Contract Example

FilesExpand file tree

smart_contracts.md

Latest commit

History

smart_contracts.md

File metadata and controls

Smart Contract Storage and Execution

Overview

Deploying Smart Contracts

Basic Contract Deployment

Payment Processor Contract

Contract Discovery and Querying

Finding Contracts by Tags

Contract Metadata Analysis

Contract Execution Simulation

Contract Interaction Examples

Using Hello World Contract

Using Payment Processor Contract

Contract Registry Management

Contract Version Management

Complete Contract Example

Smart Contract Storage and Execution

Overview

Deploying Smart Contracts

Basic Contract Deployment

Payment Processor Contract

Contract Discovery and Querying

Finding Contracts by Tags

Contract Metadata Analysis

Contract Execution Simulation

Contract Interaction Examples

Using Hello World Contract

Using Payment Processor Contract

Contract Registry Management

Contract Version Management

Complete Contract Example