[dependencies]
gateway-sdk = { path = "path/to/gateway-sdk" }

use gateway_sdk::{FhevmSdkBuilder, Result};
use alloy::primitives::address;
use std::path::PathBuf;

fn main() -> Result<()> {
    // Initialize SDK
    let sdk = FhevmSdkBuilder::new()
        .with_keys_directory(PathBuf::from("./keys"))
        .with_gateway_chain_id(43113)
        .with_host_chain_id(11155111)
        .with_decryption_contract("0x1234567890123456789012345678901234567bbb")
        .with_input_verification_contract("0x1234567890123456789012345678901234567aaa")
        .with_acl_contract("0x0987654321098765432109876543210987654321")
        .build()?;

    // Create encrypted input
    let mut builder = sdk.create_input_builder()?;
    builder.add_u64(42)?;
    builder.add_bool(true)?;
    
    let encrypted = builder.encrypt_and_prove_for(
        address!("0x7777777777777777777777777777777777777777"),
        address!("0x8888888888888888888888888888888888888888")
    )?;
    
    // Generate EIP-712 signature for user decryption
    let signature_result = sdk
        .eip712_builder()
        .with_public_key("2000000000000000a554e431f47ef7b1dd1b72a43432b06213a959953ec93785f2c699af9bc6f331")
        .with_contract("0x7777777777777777777777777777777777777777")?
        .with_validity_period(1748252823, 30)
        .with_private_key("7136d8dc72f873124f4eded25f3525a20f6cee4296564c76b44f1d582c57640f")
        .with_verification(true)
        .generate_and_sign()?; // ← Recommended method
    
    println!("Encrypted {} values", encrypted.handles.len());
    println!("Signature verified: {}", signature_result.is_verified());
    Ok(())
}

cargo run --example minimal-eip712-signing
cargo run --example minimal-encrypted-input
cargo run --example minimal-sdk-setup
cargo run --example minimal-user-keys-generation  
cargo run --example minimal-user-decryption-request
cargo run --example minimal-user-decryption-response
cargo run --example minimal-public-decryption-request
cargo run --example minimal-public-decryption-response

let mut builder = sdk.create_input_builder()?;
builder
    .add_bool(true)?
    .add_u32(12345)?
    .add_u64(9876543210)?
    .add_address("0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef")?;

let encrypted = builder.encrypt_and_prove_for(contract_address, user_address)?;

// Create request
let calldata = sdk.create_public_decrypt_request_builder()
    .with_handles_from_bytes(&handles)?
    .build_and_generate_calldata()?;

// Process response
let results = sdk.create_public_decrypt_response_builder()
    .with_kms_signers(signers)
    .with_threshold(2)
    .with_gateway_chain_id(54321)
    .with_verifying_contract_address("0x...")
    .with_ct_handles(handles)
    .with_json_response(&response)
    .process()?;

// Generate EIP-712 signature with builder pattern
let eip712_result = sdk
    .eip712_builder()
    .with_public_key(&public_key)
    .with_contract("0x742d35Cc6634C0532925a3b8D8d8E4C9B4c5D2B1")?
    .with_validity_period(start_timestamp, duration_days)
    .with_private_key(&private_key)
    .with_verification(true)
    .generate_and_sign()?; // ← Primary recommended method

// Create decrypt request
let request = sdk.create_user_decrypt_request_builder()
    .with_handles_from_bytes(&handles, &contracts)?
    .with_user_address_from_str("0x...")?
    .with_signature_from_hex(&eip712_result.require_signature()?)?
    .with_public_key_from_hex(&public_key)?
    .with_validity(timestamp, duration)?
    .build_and_generate_calldata()?;

// Generate keypair
let keypair = sdk.generate_keypair()?;

// Method 1: Just generate hash (for manual signing)
let hash = sdk
    .eip712_builder()
    .with_public_key(&keypair.public_key)
    .with_contract("0x742d35Cc6634C0532925a3b8D8d8E4C9B4c5D2B1")?
    .with_validity_period(timestamp, 30)
    .generate_hash()?;

// Method 2: Sign without verification (fast)
let signed_result = sdk
    .eip712_builder()
    .with_public_key(&keypair.public_key)
    .with_contract("0x742d35Cc6634C0532925a3b8D8d8E4C9B4c5D2B1")?
    .with_validity_period(timestamp, 30)
    .with_private_key(&private_key)
    .generate_and_sign()?; // ← Recommended for most use cases

// Method 3: Sign with verification (production recommended)
let verified_result = sdk
    .eip712_builder()
    .with_public_key(&keypair.public_key)
    .with_contracts(&["0x742d...", "0x853d..."])? // Multiple contracts
    .with_validity_period(timestamp, 30)
    .with_private_key(&private_key)
    .with_verification(true)
    .generate_and_sign()?; // ← Same method, verification enabled

if verified_result.is_verified() {
    println!("✅ Signature verified successfully!");
}

let sdk = FhevmSdkBuilder::new()
    .with_keys_directory(path)
    .with_gateway_chain_id(chain_id)
    .with_host_chain_id(chain_id)
    .with_decryption_contract(address)
    .with_input_verification_contract(address)
    .with_acl_contract(address)
    .build()?;

// Export configuration
let yaml_config = sdk_builder.to_yaml()?;

// Load from YAML
let sdk = FhevmSdk::from_yaml_file("config.yaml")?;

// Generate new keys if needed
let sdk = FhevmSdkBuilder::new()
    .with_keys_directory_or_generate(PathBuf::from("./keys"))?
    .build()?;

// Manual key generation
use gateway_sdk::utils::generate_fhe_keyset;
generate_fhe_keyset(Path::new("./keys"))?;

match sdk.create_input_builder() {
    Ok(builder) => { /* use builder */ },
    Err(FhevmError::InvalidParams(msg)) => eprintln!("Invalid parameters: {}", msg),
    Err(e) => eprintln!("Error: {}", e),
}

# Run all tests
cargo test

# Run with logging
RUST_LOG=debug cargo test -- --nocapture

# Run specific module tests
cargo test signature::
cargo test encryption::
cargo test decryption::