Remove abi_comptime module: unify selector/hash API (#25)

* Remove abi_comptime module: unify selector/hash API for comptime+runtime

Library functions no longer restrict callers with comptime parameters.
keccak.selector() and keccak.hash() work at both comptime and runtime --
the caller decides by using the `comptime` keyword or not.

Closes #23

* Remove comptime_address: rename to addressFromHex for comptime+runtime use

Same pattern as the selector/hash fix -- the caller decides whether to
evaluate at comptime, not the library.

Author: koko1123

CONTRIBUTING.md

@@ -35,7 +35,7 @@ Layer 1:  Primitives     (zero deps, no allocator needed)
           primitives.zig, uint256.zig, hex.zig
 
 Layer 2:  Encoding       (-> primitives)
-          rlp.zig, abi_encode.zig, abi_decode.zig, abi_types.zig, abi_comptime.zig
+          rlp.zig, abi_encode.zig, abi_decode.zig, abi_types.zig
 
 Layer 3:  Crypto         (-> primitives)
           keccak.zig, secp256k1.zig, signature.zig

README.md

@@ -92,16 +92,19 @@ const name = try token.name();
 defer allocator.free(name);
 ```
 
-### Comptime function selectors and event topics
+### Function selectors and event topics
 
 ```zig
 const eth = @import("eth");
 
 // Computed at compile time -- zero runtime cost
-const transfer_sel = eth.abi_comptime.comptimeSelector("transfer(address,uint256)");
+const transfer_sel = comptime eth.keccak.selector("transfer(address,uint256)");
 // transfer_sel == [4]u8{ 0xa9, 0x05, 0x9c, 0xbb }
 
-const transfer_topic = eth.abi_comptime.comptimeTopic("Transfer(address,address,uint256)");
+// Same function works at runtime too
+const runtime_sel = eth.keccak.selector(runtime_signature);
+
+const transfer_topic = comptime eth.keccak.hash("Transfer(address,address,uint256)");
 // transfer_topic == keccak256("Transfer(address,address,uint256)")
 ```
 
@@ -174,7 +177,7 @@ cd examples && zig build && ./zig-out/bin/01_derive_address
 | Layer | Modules | Description |
 |-------|---------|-------------|
 | **Primitives** | `primitives`, `uint256`, `hex` | Address, Hash, Bytes32, u256, hex encoding |
-| **Encoding** | `rlp`, `abi_encode`, `abi_decode`, `abi_types`, `abi_comptime` | RLP and ABI encoding/decoding, comptime selectors |
+| **Encoding** | `rlp`, `abi_encode`, `abi_decode`, `abi_types` | RLP and ABI encoding/decoding |
 | **Crypto** | `secp256k1`, `signer`, `signature`, `keccak`, `eip155` | ECDSA signing (RFC 6979), Keccak-256, EIP-155 |
 | **Types** | `transaction`, `receipt`, `block`, `blob`, `access_list` | Legacy, EIP-2930, EIP-1559, EIP-4844 transactions |
 | **Accounts** | `mnemonic`, `hd_wallet` | BIP-32/39/44 HD wallets and mnemonic generation |

docs/content/docs/comptime.mdx

@@ -1,26 +1,31 @@
 ---
 title: Comptime Selectors
-description: Compile-time function selectors and event topics -- a key differentiator of eth.zig.
+description: Function selectors and event topics that work at both compile time and runtime.
 ---
 
-One of eth.zig's most powerful features is **comptime-first design**. Function selectors and event topics are computed at compile time, eliminating runtime hashing entirely.
+eth.zig provides unified `keccak.selector()` and `keccak.hash()` functions that work at both compile time and runtime. The **caller** decides when to evaluate -- the library never restricts you.
 
 ## Function Selectors
 
-A Solidity function selector is the first 4 bytes of the Keccak-256 hash of the function signature. In eth.zig, this is done at compile time:
+A Solidity function selector is the first 4 bytes of the Keccak-256 hash of the function signature. Use `comptime` for zero runtime cost:
 
 ```zig
 const eth = @import("eth");
 
-// Computed at compile time -- zero runtime cost
-const transfer_sel = eth.abi_comptime.comptimeSelector("transfer(address,uint256)");
+// Evaluated at compile time -- zero runtime cost
+const transfer_sel = comptime eth.keccak.selector("transfer(address,uint256)");
 // transfer_sel == [4]u8{ 0xa9, 0x05, 0x9c, 0xbb }
 
-const approve_sel = eth.abi_comptime.comptimeSelector("approve(address,uint256)");
+const approve_sel = comptime eth.keccak.selector("approve(address,uint256)");
 // approve_sel == [4]u8{ 0x09, 0x5e, 0xa7, 0xb3 }
 ```
 
-The Zig compiler evaluates `comptimeSelector` during compilation. The resulting binary contains only the precomputed 4-byte selectors -- no hashing at runtime.
+The same function also works at runtime with dynamic strings:
+
+```zig
+// Runtime -- useful when the signature is only known at runtime
+const runtime_sel = eth.keccak.selector(some_signature);
+```
 
 ## Event Topics
 
@@ -29,21 +34,18 @@ Event topics (used for log filtering) work the same way:
 ```zig
 const eth = @import("eth");
 
-const transfer_topic = eth.abi_comptime.comptimeTopic("Transfer(address,address,uint256)");
+const transfer_topic = comptime eth.keccak.hash("Transfer(address,address,uint256)");
 // transfer_topic == keccak256("Transfer(address,address,uint256)")
 
-const approval_topic = eth.abi_comptime.comptimeTopic("Approval(address,address,uint256)");
+const approval_topic = comptime eth.keccak.hash("Approval(address,address,uint256)");
 ```
 
 ## Why This Matters
 
-In other Ethereum libraries, function selectors are typically computed at runtime:
-
 | Approach | When It Runs | Cost |
 |----------|-------------|------|
-| eth.zig `comptimeSelector` | Compile time | 0 ns at runtime |
-| Runtime `keccak256(signature)` | Every call | ~128 ns per hash |
-| Cached/lazy hash | First call | ~128 ns once, then lookup |
+| `comptime eth.keccak.selector(...)` | Compile time | 0 ns at runtime |
+| `eth.keccak.selector(runtime_str)` | Runtime | ~128 ns per hash |
 
 For hot paths (MEV bots, indexers, high-frequency DeFi), eliminating per-call hashing overhead adds up.
 
@@ -73,17 +75,17 @@ Define selectors for any contract function:
 const eth = @import("eth");
 
 // UniswapV2 Router
-const swap_sel = eth.abi_comptime.comptimeSelector(
+const swap_sel = comptime eth.keccak.selector(
     "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)"
 );
 
 // Aave V3 Pool
-const supply_sel = eth.abi_comptime.comptimeSelector(
+const supply_sel = comptime eth.keccak.selector(
     "supply(address,uint256,address,uint16)"
 );
 
 // Any custom function
-const my_sel = eth.abi_comptime.comptimeSelector(
+const my_sel = comptime eth.keccak.selector(
     "myFunction(uint256,bytes32,bool)"
 );
 ```

docs/content/docs/contracts.mdx

@@ -13,7 +13,7 @@ Use `contractRead` to call a contract function and decode the result:
 const eth = @import("eth");
 
 // Define the function selector (comptime -- zero runtime cost)
-const balanceOf_sel = eth.abi_comptime.comptimeSelector("balanceOf(address)");
+const balanceOf_sel = comptime eth.keccak.selector("balanceOf(address)");
 
 // Read balanceOf for a given address
 const results = try eth.contract.contractRead(
@@ -36,7 +36,7 @@ Use `contractWrite` to send a state-changing transaction:
 ```zig
 const eth = @import("eth");
 
-const transfer_sel = eth.abi_comptime.comptimeSelector("transfer(address,uint256)");
+const transfer_sel = comptime eth.keccak.selector("transfer(address,uint256)");
 
 const tx_hash = try eth.contract.contractWrite(
     allocator,

docs/content/docs/contributing.mdx

@@ -38,7 +38,7 @@ Layer 1:  Primitives     (zero deps, no allocator needed)
           primitives.zig, uint256.zig, hex.zig
 
 Layer 2:  Encoding       (-> primitives)
-          rlp.zig, abi_encode.zig, abi_decode.zig, abi_types.zig, abi_comptime.zig
+          rlp.zig, abi_encode.zig, abi_decode.zig, abi_types.zig
 
 Layer 3:  Crypto         (-> primitives)
           keccak.zig, secp256k1.zig, signature.zig

docs/content/docs/examples.mdx

@@ -70,16 +70,19 @@ const name = try token.name();
 defer allocator.free(name);
 ```
 
-## Comptime Function Selectors
+## Function Selectors
 
 ```zig
 const eth = @import("eth");
 
 // Computed at compile time -- zero runtime cost
-const transfer_sel = eth.abi_comptime.comptimeSelector("transfer(address,uint256)");
+const transfer_sel = comptime eth.keccak.selector("transfer(address,uint256)");
 // transfer_sel == [4]u8{ 0xa9, 0x05, 0x9c, 0xbb }
 
-const transfer_topic = eth.abi_comptime.comptimeTopic("Transfer(address,address,uint256)");
+// Same function works at runtime too
+const runtime_sel = eth.keccak.selector(some_signature);
+
+const transfer_topic = comptime eth.keccak.hash("Transfer(address,address,uint256)");
 // transfer_topic == keccak256("Transfer(address,address,uint256)")
 ```
 

docs/content/docs/modules.mdx

@@ -26,19 +26,21 @@ RLP and ABI encoding/decoding with comptime support.
 | `abi_encode` | `encode`, `encodePacked` | ABI encoding for function calls and data |
 | `abi_decode` | `decode`, `decodeOutput` | ABI decoding of return values and calldata |
 | `abi_types` | `AbiType`, `Function`, `Event` | ABI type definitions |
-| `abi_comptime` | `comptimeSelector`, `comptimeTopic` | Compile-time function selectors and event topics |
 | `abi_json` | `parseAbi` | Parse Solidity JSON ABI files |
 
-### Comptime Selectors
+### Function Selectors
 
 ```zig
 const eth = @import("eth");
 
 // Computed at compile time -- zero runtime cost
-const transfer_sel = eth.abi_comptime.comptimeSelector("transfer(address,uint256)");
+const transfer_sel = comptime eth.keccak.selector("transfer(address,uint256)");
 // transfer_sel == [4]u8{ 0xa9, 0x05, 0x9c, 0xbb }
 
-const transfer_topic = eth.abi_comptime.comptimeTopic("Transfer(address,address,uint256)");
+// Same function works at runtime with dynamic strings
+const runtime_sel = eth.keccak.selector(some_signature);
+
+const transfer_topic = comptime eth.keccak.hash("Transfer(address,address,uint256)");
 // transfer_topic == keccak256("Transfer(address,address,uint256)")
 ```
 

docs/content/docs/tokens.mdx

@@ -50,7 +50,7 @@ For state-changing operations, use the contract module with a Wallet:
 ```zig
 const eth = @import("eth");
 
-const transfer_sel = eth.abi_comptime.comptimeSelector("transfer(address,uint256)");
+const transfer_sel = comptime eth.keccak.selector("transfer(address,uint256)");
 
 const tx_hash = try eth.contract.contractWrite(
     allocator,

examples/07_comptime_selectors.zig examples/07_selectors.zigexamples/07_comptime_selectors.zig renamed to examples/07_selectors.zig

@@ -1,8 +1,8 @@
-// Example 07: Unified comptime/runtime selectors and event topics
+// Example 07: Function selectors and event topics
 //
 // Pure compute -- no RPC connection needed.
-// Showcases eth.zig's unified API: keccak.selector() and keccak.hash()
-// work at both comptime and runtime. The caller decides.
+// keccak.selector() and keccak.hash() work at both comptime and runtime.
+// The caller decides by using the `comptime` keyword or not.
 
 const std = @import("std");
 const eth = @import("eth");