.dependencies = .{
    .zigeth = .{
        .url = "https://github.com/ch4r10t33r/zigeth/archive/v0.2.1.tar.gz",
        .hash = "...", // Run `zig build` and Zig will provide the hash
    },
},

const zigeth = b.dependency("zigeth", .{
    .target = target,
    .optimize = optimize,
});

exe.root_module.addImport("zigeth", zigeth.module("zigeth"));
exe.linkLibC(); // Required for secp256k1

const std = @import("std");
const zigeth = @import("zigeth");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    // 1. Create a wallet
    var wallet = try zigeth.signer.Wallet.generate(allocator);
    defer wallet.deinit();
    
    const address = try wallet.getAddress();
    const address_hex = try address.toHex(allocator);
    defer allocator.free(address_hex);
    
    std.debug.print("🔑 New wallet created!\n", .{});
    std.debug.print("   Address: {s}\n\n", .{address_hex});
    
    // 2. Connect to Ethereum (Sepolia testnet)
    var provider = try zigeth.providers.Networks.sepolia(allocator);
    defer provider.deinit();
    
    std.debug.print("🌐 Connected to Sepolia testnet\n", .{});
    
    // 3. Query account balance
    const balance = try provider.getBalance(address);
    const eth = try zigeth.utils.units.weiToEther(balance);
    
    std.debug.print("   Balance: {d} ETH\n\n", .{eth});
    
    // 4. Get current block number
    const block_number = try provider.getBlockNumber();
    std.debug.print("📦 Current block: {}\n", .{block_number});
    
    // 5. Get gas price
    const gas_price = try provider.getGasPrice();
    const gwei = gas_price / 1_000_000_000;
    std.debug.print("⛽ Gas price: {} gwei\n", .{gwei});
}

const address = try zigeth.primitives.Address.fromHex(
    "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb7"
);

var provider = try zigeth.providers.Networks.mainnet(allocator);
defer provider.deinit();

const balance = try provider.getBalance(address);
const eth = try zigeth.utils.units.weiToEther(balance);
std.debug.print("Balance: {d} ETH\n", .{eth});

// Setup signer
var wallet = try zigeth.signer.Wallet.fromPrivateKeyHex(allocator, private_key);
defer wallet.deinit();

// Create transaction
var tx = zigeth.types.Transaction.newEip1559(allocator);
tx.to = try zigeth.primitives.Address.fromHex("0x...");
tx.value = zigeth.primitives.U256.fromInt(100_000_000_000_000_000); // 0.1 ETH
tx.nonce = try provider.getTransactionCount(wallet.address);
tx.gas_limit = 21000;
tx.max_fee_per_gas = 30_000_000_000; // 30 gwei
tx.max_priority_fee_per_gas = 2_000_000_000; // 2 gwei
tx.chain_id = 11155111; // Sepolia

// Sign and send
const signed_tx = try wallet.signTransaction(&tx);
const tx_hash = try provider.sendRawTransaction(signed_tx);

std.debug.print("Transaction sent: {}\n", .{tx_hash});

// USDC contract on Ethereum
const usdc_address = try zigeth.primitives.Address.fromHex(
    "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
);

// Use built-in ERC-20 interface
const erc20 = zigeth.sol.ERC20;
const balance_of = erc20.getFunctionByName("balanceOf").?;

// Encode function call
const params = [_]zigeth.abi.AbiValue{
    .{ .address = your_address },
};
const call_data = try zigeth.abi.encodeFunctionCall(allocator, balance_of, &params);
defer allocator.free(call_data);

// Call contract
const result = try provider.call(.{
    .to = usdc_address,
    .data = call_data,
});

// Decode result (uint256 balance)
const balance_value = std.mem.readInt(u256, result[0..32], .big);
const usdc_balance = @as(f64, @floatFromInt(balance_value)) / 1_000_000; // USDC has 6 decimals
std.debug.print("USDC Balance: {d}\n", .{usdc_balance});

const aa = zigeth.account_abstraction;

// Create EntryPoint v0.7 instance
const entry_point = try aa.EntryPoint.v07(allocator, &rpc);

// Create smart account
var smart_account = aa.SmartAccount.init(
    allocator,
    account_address,
    entry_point.address,
    .v0_7,
    owner_address,
    &rpc,
    &factory,
    0, // salt
);

// Encode transaction
const call_data = try smart_account.encodeExecute(recipient, value, &[_]u8{});
defer allocator.free(call_data);

// Create UserOperation
const gas_estimates = try gas_estimator.estimateGas(test_op);
const user_op_any = try smart_account.createUserOperation(call_data, gas_estimates);
var user_op = user_op_any.v0_7;

// Get paymaster sponsorship (FREE for user!)
var paymaster = aa.PaymasterClient.init(allocator, paymaster_url, api_key);
defer paymaster.deinit();
try paymaster.sponsorUserOperation(&user_op, entry_point.address, .sponsor);

// Sign and send
const signature = try smart_account.signUserOperation(user_op, private_key);
user_op.signature = signature;

var bundler = aa.BundlerClient.init(allocator, bundler_url, entry_point.address);
defer bundler.deinit();
const user_op_hash = try bundler.sendUserOperation(user_op);

std.debug.print("UserOp sent: {}\n", .{user_op_hash});

// Connect to networks
var mainnet = try zigeth.providers.Networks.mainnet(allocator);
var sepolia = try zigeth.providers.Networks.sepolia(allocator);
var polygon = try zigeth.providers.Networks.polygon(allocator);
var arbitrum = try zigeth.providers.Networks.arbitrum(allocator);
var optimism = try zigeth.providers.Networks.optimism(allocator);
var base = try zigeth.providers.Networks.base(allocator);
var localhost = try zigeth.providers.Networks.localhost(allocator);

// HTTP Provider
var provider = try zigeth.providers.HttpProvider.init(
    allocator,
    "https://your-rpc-endpoint.com"
);
defer provider.deinit();

// WebSocket Provider (for subscriptions)
var ws_provider = try zigeth.providers.WsProvider.init(
    allocator,
    "wss://your-ws-endpoint.com"
);
defer ws_provider.deinit();

// IPC Provider (Unix socket)
var ipc_provider = try zigeth.providers.IpcProvider.init(
    allocator,
    "/path/to/geth.ipc"
);
defer ipc_provider.deinit();

// Generate new wallet
var wallet = try zigeth.signer.Wallet.generate(allocator);

// Import from private key
const key_hex = "0x1234...";
var wallet = try zigeth.signer.Wallet.fromPrivateKeyHex(allocator, key_hex);

// HD Wallet (BIP-32/BIP-44)
const phrase = "word1 word2 ... word12";
var mnemonic = try zigeth.signer.Mnemonic.fromPhrase(allocator, phrase);
const seed = try mnemonic.toSeed("passphrase");
const hd_wallet = try zigeth.signer.HDWallet.fromSeed(allocator, seed);
var account = try hd_wallet.getWallet(0); // First account

// Encrypted Keystore (JSON V3)
const password = "secure-password";
const keystore = try zigeth.signer.Keystore.encrypt(
    allocator,
    private_key,
    address,
    password,
    .pbkdf2
);

// Gas middleware - automatic gas price optimization
const gas_config = zigeth.middleware.GasConfig.fast(); // or .slow, .standard, .custom
var gas = zigeth.middleware.GasMiddleware.init(allocator, provider, gas_config);
const gas_price = try gas.getGasPrice();
try gas.applyGasSettings(&transaction);

// Nonce middleware - automatic nonce management
var nonce = try zigeth.middleware.NonceMiddleware.init(allocator, provider, .hybrid);
defer nonce.deinit();
const next_nonce = try nonce.reserveNonce(address);

// Signer middleware - automatic transaction signing
const signer_config = zigeth.middleware.SignerConfig.mainnet();
var signer = try zigeth.middleware.SignerMiddleware.init(
    allocator,
    private_key,
    signer_config
);
const signature = try signer.signTransaction(&transaction);

const block_num = try provider.eth.blockNumber();
const balance = try provider.eth.getBalance(address, .{ .tag = .latest });
const tx = try provider.eth.getTransactionByHash(tx_hash);
const receipt = try provider.eth.getTransactionReceipt(tx_hash);
const gas_price = try provider.eth.gasPrice();
const chain_id = try provider.eth.chainId();
// ... and 17 more methods

const version = try provider.net.version();
const listening = try provider.net.listening();
const peer_count = try provider.net.peerCount();

const client_version = try provider.web3.clientVersion();
const sha3_hash = try provider.web3.sha3(data);

const trace = try provider.debug.traceTransaction(allocator, tx_hash, options);
const block_trace = try provider.debug.traceBlockByNumber(allocator, block_num, options);
// ... and 5 more debug methods

// ERC-20 Token interaction using standard interfaces
const usdc = try zigeth.primitives.Address.fromHex(
    "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
);

// Use pre-defined ERC-20 interface
const erc20 = zigeth.sol.ERC20;
const balance_of = erc20.getFunctionByName("balanceOf").?;

// Encode function call
const params = [_]zigeth.abi.AbiValue{
    .{ .address = your_address },
};
const call_data = try zigeth.abi.encodeFunctionCall(
    allocator,
    balance_of,
    &params
);

// Make contract call
const result = try provider.eth.call(.{
    .to = usdc,
    .data = call_data,
}, .{ .tag = .latest });

// Legacy Transaction
var tx = zigeth.types.Transaction.newLegacy(
    allocator,
    to_address,
    value,
    data,
    nonce,
    gas_limit,
    gas_price,
);

// EIP-1559 Transaction (recommended)
var tx = zigeth.types.Transaction.newEip1559(
    allocator,
    to_address,
    value,
    data,
    nonce,
    gas_limit,
    max_fee_per_gas,
    max_priority_fee_per_gas,
    chain_id,
    access_list,
);

// EIP-7702 Transaction (delegation)
var tx = zigeth.types.Transaction.newEip7702(
    allocator,
    to_address,
    value,
    data,
    nonce,
    gas_limit,
    max_fee_per_gas,
    max_priority_fee_per_gas,
    chain_id,
    authorization_list,
);