import * as Address from "@voltaire/primitives/Address";

const addr = Address.fromHex("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3");
Address.toChecksummed(addr);  // "0x742d35Cc6634C0532925a3b844Bc9e7595f251e3"
Address.isZero(addr);         // false

import * as Hash from "@voltaire/primitives/Hash";

const hash = Hash.fromHex("0xabc...");
Hash.toHex(hash);
Hash.equals(hash1, hash2);

import * as Hex from "@voltaire/primitives/Hex";

Hex.fromBytes(bytes);      // "0x..."
Hex.toBytes("0xabcd");     // Uint8Array
Hex.concat(hex1, hex2);    // Combined hex
Hex.slice(hex, 0, 10);     // Substring

import * as Bytes32 from "@voltaire/primitives/Bytes32";

const key = Bytes32.fromHex("0x...");
Bytes32.toHex(key);

import * as Uint256 from "@voltaire/primitives/Uint256";

const value = Uint256.from(1000n);
Uint256.plus(a, b);
Uint256.times(a, b);
Uint256.shiftLeft(value, 8n);
Uint256.toHex(value);

import * as Rlp from "@voltaire/primitives/Rlp";

const encoded = Rlp.encode([address, nonce, value]);
const decoded = Rlp.decode(encoded);
Rlp.encodeLength(data);

import * as Abi from "@voltaire/primitives/Abi";

// Encode function call
const calldata = Abi.encodeFunctionData({
  abi: contractAbi,
  functionName: "transfer",
  args: [to, amount]
});

// Decode return value
const result = Abi.decodeFunctionResult({
  abi: contractAbi,
  functionName: "balanceOf",
  data: returnData
});

// Get function selector
Abi.getFunctionSelector("transfer(address,uint256)");  // "0xa9059cbb"

import * as Base64 from "@voltaire/primitives/Base64";

Base64.encode(bytes);
Base64.decode(base64String);

import * as Transaction from "@voltaire/primitives/Transaction";

// Create EIP-1559 transaction
const tx = Transaction.from({
  type: "eip1559",
  to: address,
  value: 1000000000000000000n,
  maxFeePerGas: 20000000000n,
  maxPriorityFeePerGas: 1000000000n,
  gasLimit: 21000n,
  nonce: 0n,
  chainId: 1n,
});

// Serialize
const serialized = Transaction.serialize(tx);

// Get hash
const hash = Transaction.hash(tx);

// Sign
const signed = Transaction.sign(tx, privateKey);

import * as AccessList from "@voltaire/primitives/AccessList";

const accessList = AccessList.from([
  { address: "0x...", storageKeys: ["0x..."] }
]);

import * as Authorization from "@voltaire/primitives/Authorization";

const auth = Authorization.from({
  chainId: 1n,
  address: "0x...",
  nonce: 0n,
});
const signed = Authorization.sign(auth, privateKey);

import * as Blob from "@voltaire/primitives/Blob";

const blob = Blob.from(data);
Blob.toCommitment(blob);  // KZG commitment

import * as Block from "@voltaire/primitives/Block";

Block.hash(block);
Block.number(block);
Block.transactions(block);

import * as BlockHeader from "@voltaire/primitives/BlockHeader";

BlockHeader.parentHash(header);
BlockHeader.stateRoot(header);
BlockHeader.transactionsRoot(header);

import * as BlockHash from "@voltaire/primitives/BlockHash";
import * as BlockNumber from "@voltaire/primitives/BlockNumber";

const hash = BlockHash.fromHex("0x...");
const num = BlockNumber.from(12345678n);

import * as Receipt from "@voltaire/primitives/Receipt";

Receipt.status(receipt);     // 1 = success, 0 = failure
Receipt.gasUsed(receipt);
Receipt.logs(receipt);

import * as EventLog from "@voltaire/primitives/EventLog";

EventLog.address(log);
EventLog.topics(log);
EventLog.data(log);
EventLog.decode(log, eventAbi);

import * as LogFilter from "@voltaire/primitives/LogFilter";

const filter = LogFilter.from({
  address: "0x...",
  topics: [eventSignature],
  fromBlock: 1000000n,
  toBlock: "latest",
});

import * as Bytecode from "@voltaire/primitives/Bytecode";

const code = Bytecode.fromHex("0x6080604052...");
Bytecode.jumpDestinations(code);
Bytecode.isValidJumpDest(code, pc);
Bytecode.getOpcode(code, pc);

import * as Opcode from "@voltaire/primitives/Opcode";

Opcode.name(0x60);           // "PUSH1"
Opcode.gas(0x60);            // 3
Opcode.stackInputs(0x60);    // 0
Opcode.stackOutputs(0x60);   // 1

import * as GasConstants from "@voltaire/primitives/GasConstants";

GasConstants.G_ZERO;          // 0
GasConstants.G_BASE;          // 2
GasConstants.G_VERYLOW;       // 3
GasConstants.G_SLOAD;         // 2100 (post-Berlin)
GasConstants.G_SSTORE_SET;    // 20000

import * as StorageKey from "@voltaire/primitives/StorageKey";
import * as StorageValue from "@voltaire/primitives/StorageValue";

const key = StorageKey.from(0n);
const value = StorageValue.from(bytes32);

import * as Chain from "@voltaire/primitives/Chain";

Chain.mainnet;
Chain.sepolia;
Chain.byId(1n);
Chain.nativeCurrency(chain);
Chain.rpcUrls(chain);

import * as ChainId from "@voltaire/primitives/ChainId";

const chainId = ChainId.from(1n);  // Mainnet
ChainId.isMainnet(chainId);        // true

import * as Hardfork from "@voltaire/primitives/Hardfork";

Hardfork.LONDON;
Hardfork.SHANGHAI;
Hardfork.CANCUN;
Hardfork.hasEIP1559(Hardfork.LONDON);  // true
Hardfork.hasEIP4844(Hardfork.CANCUN);  // true

import * as FeeMarket from "@voltaire/primitives/FeeMarket";

FeeMarket.calculateBaseFee(parentGasUsed, parentGasLimit, parentBaseFee);
FeeMarket.estimateMaxFee(baseFee, priorityFee);

import * as Denomination from "@voltaire/primitives/Denomination";

Denomination.toWei("1.5", "ether");   // 1500000000000000000n
Denomination.fromWei(wei, "gwei");    // "1500000000"
Denomination.parseEther("1.5");       // 1500000000000000000n
Denomination.formatEther(wei);        // "1.5"

import * as Signature from "@voltaire/primitives/Signature";

const sig = Signature.from({ r, s, v });
Signature.toHex(sig);
Signature.toCompact(sig);     // 64-byte compact format
Signature.recover(sig, hash); // Recover public key

import * as PrivateKey from "@voltaire/primitives/PrivateKey";
import * as PublicKey from "@voltaire/primitives/PublicKey";

const pk = PrivateKey.generate();
const pubkey = PublicKey.fromPrivateKey(pk);
PublicKey.toAddress(pubkey);

import * as Siwe from "@voltaire/primitives/Siwe";

const message = Siwe.createMessage({
  domain: "example.com",
  address: "0x...",
  statement: "Sign in",
  uri: "https://example.com",
  version: "1",
  chainId: 1n,
  nonce: "abc123",
});

Siwe.verify(message, signature);

import * as Ens from "@voltaire/primitives/Ens";

Ens.normalize("Vitalik.eth");  // "vitalik.eth"
Ens.namehash("vitalik.eth");   // 0x...
Ens.isValidName(name);

import * as Domain from "@voltaire/primitives/Domain";

const domain = Domain.from({
  name: "MyContract",
  version: "1",
  chainId: 1n,
  verifyingContract: "0x...",
});
Domain.separator(domain);

import * as UserOperation from "@voltaire/primitives/UserOperation";

const userOp = UserOperation.from({
  sender: "0x...",
  nonce: 0n,
  initCode: "0x",
  callData: "0x...",
  callGasLimit: 100000n,
  verificationGasLimit: 100000n,
  preVerificationGas: 21000n,
  maxFeePerGas: 20000000000n,
  maxPriorityFeePerGas: 1000000000n,
  paymasterAndData: "0x",
  signature: "0x",
});

UserOperation.hash(userOp, entryPoint, chainId);

import * as Slot from "@voltaire/primitives/Slot";
import * as Epoch from "@voltaire/primitives/Epoch";

const slot = Slot.from(1000000n);
Slot.toEpoch(slot);  // Epoch containing this slot

import * as Selector from "@voltaire/primitives/Selector";

Selector.fromSignature("transfer(address,uint256)");  // "0xa9059cbb"

import * as Proxy from "@voltaire/primitives/Proxy";

Proxy.isMinimalProxy(bytecode);
Proxy.getImplementation(bytecode);  // Extract implementation address
Proxy.create(implementationAddress); // Generate proxy bytecode

import * as BloomFilter from "@voltaire/primitives/BloomFilter";

BloomFilter.add(bloom, topic);
BloomFilter.contains(bloom, topic);
BloomFilter.merge(bloom1, bloom2);

import * as BinaryTree from "@voltaire/primitives/BinaryTree";

BinaryTree.root(leaves);
BinaryTree.proof(leaves, index);
BinaryTree.verify(root, leaf, proof, index);