Add ERC-20/721 modules, JSON ABI parser, examples, and fix Zig 0.15.2 compat (#1)

New modules:
- src/erc20.zig: typed ERC-20 wrapper with comptime selectors
- src/erc721.zig: typed ERC-721 wrapper with comptime selectors
- src/abi_json.zig: Solidity JSON ABI artifact parser

Examples directory (examples/):
- 7 example programs demonstrating key library features
- Standalone build.zig with path dependency on parent module

Zig 0.15.2 API migration across 12 source files:
- ArrayList.init(allocator) -> .empty + pass allocator to each method
- Pointer.Size enum: .One/.Slice -> .one/.slice
- pbkdf2 namespace flattened to direct function call
- Added @setEvalBranchQuota for comptime keccak hashing

Author: koko1123

examples/01_derive_address.zig

@@ -0,0 +1,27 @@
+// Example 01: Derive an Ethereum address from a private key
+//
+// Pure compute -- no RPC connection needed.
+
+const std = @import("std");
+const eth = @import("eth");
+
+pub fn main() !void {
+    var buf: [4096]u8 = undefined;
+    var stdout_impl = std.fs.File.stdout().writer(&buf);
+    const stdout = &stdout_impl.interface;
+
+    // Hardhat/Anvil account #0 private key (DO NOT use in production)
+    const private_key = try eth.hex.hexToBytesFixed(32, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80");
+
+    // Create a signer from the private key
+    const signer = eth.signer.Signer.init(private_key);
+
+    // Derive the Ethereum address
+    const addr = try signer.address();
+    const checksum = eth.primitives.addressToChecksum(&addr);
+
+    try stdout.print("Private key: 0xac0974...f2ff80\n", .{});
+    try stdout.print("Address:     {s}\n", .{checksum});
+    // Expected: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
+    try stdout.flush();
+}

examples/02_check_balance.zig

@@ -0,0 +1,38 @@
+// Example 02: Check an account balance via JSON-RPC
+//
+// Requires a running Ethereum node (e.g., Anvil at localhost:8545).
+// Start Anvil with: anvil
+
+const std = @import("std");
+const eth = @import("eth");
+
+pub fn main() !void {
+    var buf: [4096]u8 = undefined;
+    var stdout_impl = std.fs.File.stdout().writer(&buf);
+    const stdout = &stdout_impl.interface;
+
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    // Connect to local node
+    var transport = eth.http_transport.HttpTransport.init(allocator, "http://127.0.0.1:8545");
+    defer transport.deinit();
+    var provider = eth.provider.Provider.init(allocator, &transport);
+
+    // Anvil account #0
+    const addr = try eth.primitives.addressFromHex("0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266");
+
+    const balance = provider.getBalance(addr) catch |err| {
+        try stdout.print("Failed to connect to RPC: {}\n", .{err});
+        try stdout.print("\nTo run this example, start Anvil:\n  anvil\n", .{});
+        try stdout.flush();
+        return;
+    };
+
+    const ether = eth.units.formatEther(balance);
+    const checksum = eth.primitives.addressToChecksum(&addr);
+    try stdout.print("Address: {s}\n", .{checksum});
+    try stdout.print("Balance: {d:.4} ETH\n", .{ether});
+    try stdout.flush();
+}

examples/03_sign_message.zig

@@ -0,0 +1,33 @@
+// Example 03: Sign a message with EIP-191 personal message prefix
+//
+// Pure compute -- no RPC connection needed.
+
+const std = @import("std");
+const eth = @import("eth");
+
+pub fn main() !void {
+    var buf: [4096]u8 = undefined;
+    var stdout_impl = std.fs.File.stdout().writer(&buf);
+    const stdout = &stdout_impl.interface;
+
+    // Hardhat/Anvil account #0 private key
+    const private_key = try eth.hex.hexToBytesFixed(32, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80");
+
+    const signer = eth.signer.Signer.init(private_key);
+    const addr = try signer.address();
+    const checksum = eth.primitives.addressToChecksum(&addr);
+
+    // Sign a personal message (EIP-191)
+    const message = "Hello, Ethereum!";
+    const sig = try signer.signMessage(message);
+
+    try stdout.print("Signer:  {s}\n", .{checksum});
+    try stdout.print("Message: \"{s}\"\n", .{message});
+    try stdout.print("v: {d}\n", .{sig.v});
+    try stdout.print("r: ", .{});
+    for (sig.r) |b| try stdout.print("{x:0>2}", .{b});
+    try stdout.print("\ns: ", .{});
+    for (sig.s) |b| try stdout.print("{x:0>2}", .{b});
+    try stdout.print("\n", .{});
+    try stdout.flush();
+}

examples/04_send_transaction.zig

@@ -0,0 +1,56 @@
+// Example 04: Send a transaction using the Wallet
+//
+// Requires Anvil running at localhost:8545.
+// Start Anvil with: anvil
+
+const std = @import("std");
+const eth = @import("eth");
+
+pub fn main() !void {
+    var buf: [4096]u8 = undefined;
+    var stdout_impl = std.fs.File.stdout().writer(&buf);
+    const stdout = &stdout_impl.interface;
+
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    // Connect to local Anvil node
+    var transport = eth.http_transport.HttpTransport.init(allocator, "http://127.0.0.1:8545");
+    defer transport.deinit();
+    var provider = eth.provider.Provider.init(allocator, &transport);
+
+    // Test connection first
+    _ = provider.getChainId() catch |err| {
+        try stdout.print("Failed to connect to RPC: {}\n", .{err});
+        try stdout.print("\nTo run this example, start Anvil:\n  anvil\n", .{});
+        try stdout.flush();
+        return;
+    };
+
+    // Anvil account #0
+    const private_key = try eth.hex.hexToBytesFixed(32, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80");
+
+    var wallet = eth.wallet.Wallet.init(allocator, private_key, &provider);
+    const sender = try wallet.address();
+    const sender_checksum = eth.primitives.addressToChecksum(&sender);
+
+    // Send 0.1 ETH to account #1
+    const recipient = try eth.primitives.addressFromHex("0x70997970C51812dc3A010C7d01b50e0d17dc79C8");
+    const recipient_checksum = eth.primitives.addressToChecksum(&recipient);
+    const value = eth.units.parseEther(0.1);
+
+    try stdout.print("Sending 0.1 ETH\n", .{});
+    try stdout.print("  From: {s}\n", .{sender_checksum});
+    try stdout.print("  To:   {s}\n", .{recipient_checksum});
+
+    const tx_hash = try wallet.sendTransaction(.{
+        .to = recipient,
+        .value = value,
+    });
+
+    try stdout.print("Tx hash: 0x", .{});
+    for (tx_hash) |b| try stdout.print("{x:0>2}", .{b});
+    try stdout.print("\n", .{});
+    try stdout.flush();
+}

examples/05_read_erc20.zig

@@ -0,0 +1,51 @@
+// Example 05: Read ERC-20 token data using the ERC20 convenience module
+//
+// Requires Anvil running at localhost:8545 with a deployed ERC-20 token.
+// This example demonstrates the API -- it will fail without a deployed contract.
+
+const std = @import("std");
+const eth = @import("eth");
+
+pub fn main() !void {
+    var buf: [4096]u8 = undefined;
+    var stdout_impl = std.fs.File.stdout().writer(&buf);
+    const stdout = &stdout_impl.interface;
+
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    // Connect to local node
+    var transport = eth.http_transport.HttpTransport.init(allocator, "http://127.0.0.1:8545");
+    defer transport.deinit();
+    var provider = eth.provider.Provider.init(allocator, &transport);
+
+    // Test connection
+    _ = provider.getChainId() catch |err| {
+        try stdout.print("Failed to connect to RPC: {}\n", .{err});
+        try stdout.print("\nTo run this example, start Anvil:\n  anvil\n", .{});
+        try stdout.flush();
+        return;
+    };
+
+    // Show the ERC-20 module API
+    try stdout.print("ERC-20 Module API:\n\n", .{});
+    try stdout.print("Comptime selectors (zero runtime cost):\n", .{});
+    try stdout.print("  transfer:     0x", .{});
+    for (eth.erc20.selectors.transfer) |b| try stdout.print("{x:0>2}", .{b});
+    try stdout.print("\n  balanceOf:    0x", .{});
+    for (eth.erc20.selectors.balanceOf) |b| try stdout.print("{x:0>2}", .{b});
+    try stdout.print("\n  approve:      0x", .{});
+    for (eth.erc20.selectors.approve) |b| try stdout.print("{x:0>2}", .{b});
+    try stdout.print("\n  totalSupply:  0x", .{});
+    for (eth.erc20.selectors.totalSupply) |b| try stdout.print("{x:0>2}", .{b});
+    try stdout.print("\n\n", .{});
+
+    // Show how you would use it with a real token contract:
+    try stdout.print("Usage:\n", .{});
+    try stdout.print("  var token = eth.erc20.ERC20.init(allocator, token_addr, &provider);\n", .{});
+    try stdout.print("  const balance = try token.balanceOf(holder_addr);\n", .{});
+    try stdout.print("  const name = try token.name();\n", .{});
+    try stdout.print("  defer allocator.free(name);\n", .{});
+    try stdout.flush();
+}

examples/06_hd_wallet.zig

@@ -0,0 +1,35 @@
+// Example 06: HD wallet derivation from mnemonic
+//
+// Pure compute -- no RPC connection needed.
+// Derives multiple Ethereum addresses from a BIP-39 mnemonic.
+
+const std = @import("std");
+const eth = @import("eth");
+
+pub fn main() !void {
+    var buf: [4096]u8 = undefined;
+    var stdout_impl = std.fs.File.stdout().writer(&buf);
+    const stdout = &stdout_impl.interface;
+
+    // Standard test mnemonic (DO NOT use in production)
+    const words = [_][]const u8{
+        "abandon", "abandon", "abandon", "abandon",
+        "abandon", "abandon", "abandon", "abandon",
+        "abandon", "abandon", "abandon", "about",
+    };
+
+    // Convert mnemonic to seed
+    const seed = try eth.mnemonic.toSeed(&words, "");
+
+    try stdout.print("Mnemonic: abandon abandon ... about\n\n", .{});
+    try stdout.print("Derived accounts (BIP-44: m/44'/60'/0'/0/i):\n", .{});
+
+    // Derive first 5 accounts
+    for (0..5) |i| {
+        const key = try eth.hd_wallet.deriveEthAccount(seed, @intCast(i));
+        const addr = key.toAddress();
+        const checksum = eth.primitives.addressToChecksum(&addr);
+        try stdout.print("  [{d}] {s}\n", .{ i, checksum });
+    }
+    try stdout.flush();
+}

examples/07_comptime_selectors.zig

@@ -0,0 +1,42 @@
+// Example 07: Comptime function selectors and event topics
+//
+// Pure compute -- no RPC connection needed.
+// Showcases eth.zig's comptime-first approach: all selectors and topics
+// are computed at compile time with zero runtime cost.
+
+const std = @import("std");
+const eth = @import("eth");
+
+pub fn main() !void {
+    var buf: [4096]u8 = undefined;
+    var stdout_impl = std.fs.File.stdout().writer(&buf);
+    const stdout = &stdout_impl.interface;
+
+    // Use runtime selectors in examples (comptime selectors are used inside the library
+    // where the eval branch quota is pre-configured).
+    const transfer_sel = eth.keccak.selector("transfer(address,uint256)");
+    const approve_sel = eth.keccak.selector("approve(address,uint256)");
+    const balance_sel = eth.keccak.selector("balanceOf(address)");
+
+    const transfer_topic = eth.keccak.hash("Transfer(address,address,uint256)");
+    const approval_topic = eth.keccak.hash("Approval(address,address,uint256)");
+
+    try stdout.print("Function Selectors:\n", .{});
+    try stdout.print("  transfer(address,uint256):     0x", .{});
+    for (transfer_sel) |b| try stdout.print("{x:0>2}", .{b});
+    try stdout.print("\n  approve(address,uint256):      0x", .{});
+    for (approve_sel) |b| try stdout.print("{x:0>2}", .{b});
+    try stdout.print("\n  balanceOf(address):            0x", .{});
+    for (balance_sel) |b| try stdout.print("{x:0>2}", .{b});
+
+    try stdout.print("\n\nEvent Topics:\n", .{});
+    try stdout.print("  Transfer(address,address,uint256):\n    0x", .{});
+    for (transfer_topic) |b| try stdout.print("{x:0>2}", .{b});
+    try stdout.print("\n  Approval(address,address,uint256):\n    0x", .{});
+    for (approval_topic) |b| try stdout.print("{x:0>2}", .{b});
+
+    try stdout.print("\n\nInside the library, these are computed at compile time:\n", .{});
+    try stdout.print("  const sel = eth.abi_comptime.comptimeSelector(\"transfer(address,uint256)\");\n", .{});
+    try stdout.print("  // sel == [4]u8{{ 0xa9, 0x05, 0x9c, 0xbb }} -- zero runtime cost\n", .{});
+    try stdout.flush();
+}

examples/build.zig

@@ -0,0 +1,37 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const eth_dep = b.dependency("eth", .{
+        .target = target,
+        .optimize = optimize,
+    });
+    const eth_module = eth_dep.module("eth");
+
+    const examples = .{
+        .{ "01_derive_address", "01_derive_address.zig" },
+        .{ "02_check_balance", "02_check_balance.zig" },
+        .{ "03_sign_message", "03_sign_message.zig" },
+        .{ "04_send_transaction", "04_send_transaction.zig" },
+        .{ "05_read_erc20", "05_read_erc20.zig" },
+        .{ "06_hd_wallet", "06_hd_wallet.zig" },
+        .{ "07_comptime_selectors", "07_comptime_selectors.zig" },
+    };
+
+    inline for (examples) |example| {
+        const exe = b.addExecutable(.{
+            .name = example[0],
+            .root_module = b.createModule(.{
+                .root_source_file = b.path(example[1]),
+                .target = target,
+                .optimize = optimize,
+                .imports = &.{
+                    .{ .name = "eth", .module = eth_module },
+                },
+            }),
+        });
+        b.installArtifact(exe);
+    }
+}

examples/build.zig.zon

@@ -0,0 +1,15 @@
+.{
+    .name = .eth_zig_examples,
+    .version = "0.1.0",
+    .fingerprint = 0xd73bf5facd267e8e,
+    .minimum_zig_version = "0.15.2",
+    .dependencies = .{
+        .eth = .{
+            .path = "..",
+        },
+    },
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+    },
+}