x402-fl 0.0.0

package/.claude/settings.local.json

@@ -0,0 +1,10 @@
+{
+  "permissions": {
+    "allow": [
+      "WebSearch",
+      "WebFetch(domain:raw.githubusercontent.com)",
+      "Bash(gh api:*)",
+      "Bash(npm view:*)"
+    ]
+  }
+}

package/.env.example

@@ -0,0 +1,4 @@
+# Base mainnet RPC URL for Anvil forking
+# Free: https://mainnet.base.org
+# Better: Alchemy or Infura Base mainnet RPC
+BASE_RPC_URL=https://mainnet.base.org

package/.github/workflows/publish.yml

@@ -0,0 +1,66 @@
+name: Publish
+
+on:
+  release:
+    types: [published]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    name: Publish [npm]
+    runs-on: ubuntu-latest
+    environment: NPM
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: pnpm/action-setup@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "18"
+          registry-url: https://registry.npmjs.org
+          cache: pnpm
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Extract and validate version from tag
+        id: info
+        run: |
+          TAG="${{ github.event.release.tag_name }}"
+
+          if [[ "$TAG" =~ ^v([0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9.]+)?)$ ]]; then
+            VERSION="${BASH_REMATCH[1]}"
+          else
+            echo "Error: Tag must be in format v0.0.0 (e.g., v1.0.0, v1.0.0-beta.1)"
+            echo "Received: $TAG"
+            exit 1
+          fi
+
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+
+          if [[ "$VERSION" == *-* ]]; then
+            echo "dist_tag=next" >> $GITHUB_OUTPUT
+          else
+            echo "dist_tag=latest" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Build
+        run: pnpm build
+
+      - name: Set version
+        run: |
+          VERSION="${{ steps.info.outputs.version }}"
+          sed -i 's/"version": "0.0.0"/"version": "'"$VERSION"'"/g' package.json
+
+      - name: Publish
+        run: npm publish --access public --tag ${{ steps.info.outputs.dist_tag }} --provenance
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 kevzzsk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,121 @@
+# x402-fl
+
+Local x402 facilitator for development and testing. Forks Base mainnet with Foundry Anvil and runs a local facilitator server. Fund any address with USDC via direct storage manipulation.
+
+> **Warning**: This is for local development only. Do NOT use in production. It uses Anvil's well-known deterministic private keys, which are publicly known and have zero security.
+
+## What it does
+
+`x402-fl` spins up a complete local x402 payment environment in one command:
+
+1. Forks Base mainnet using Anvil (so you get real USDC contract state)
+2. Starts a local facilitator server that can verify and settle x402 payments
+3. Provides a `fund` command to mint USDC to any address via Anvil storage manipulation
+
+## Prerequisites
+
+- Node.js 18+
+- [pnpm](https://pnpm.io/)
+- [Foundry](https://www.getfoundry.sh/introduction/installation) (provides `anvil`)
+- A Base mainnet RPC URL (e.g. `https://mainnet.base.org`, Alchemy, or Infura)
+
+## Quick Start
+
+```bash
+git clone https://github.com/anthropics/x402-fl.git
+cd x402-fl
+pnpm install
+```
+
+Create a `.env` file:
+
+```bash
+cp .env.example .env
+# Edit .env and set BASE_RPC_URL
+```
+
+Start the local environment:
+
+```bash
+pnpm dev
+```
+
+This starts Anvil on port 8545 and launches the facilitator on port 4022.
+
+Fund an account with USDC:
+
+```bash
+npx tsx src/cli.ts fund 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 100
+```
+
+## CLI Commands
+
+### `dev`
+
+Start Anvil fork + facilitator server for local x402 development.
+
+```bash
+pnpm dev [options]
+```
+
+| Flag                    | Default                | Description           |
+| ----------------------- | ---------------------- | --------------------- |
+| `--port <number>`       | `4022`                 | Facilitator HTTP port |
+| `--anvil-port <number>` | `8545`                 | Anvil RPC port        |
+| `--rpc-url <url>`       | `BASE_RPC_URL` env var | Base RPC URL to fork  |
+
+### `fund`
+
+Fund any address with USDC on the local Anvil fork.
+
+```bash
+npx tsx src/cli.ts fund <address> <amount> [options]
+```
+
+| Argument / Flag         | Default  | Description                                       |
+| ----------------------- | -------- | ------------------------------------------------- |
+| `<address>`             | required | 0x-prefixed Ethereum address to fund              |
+| `<amount>`              | required | USDC amount (human-readable, e.g. `100` or `1.5`) |
+| `--anvil-port <number>` | `8545`   | Anvil RPC port                                    |
+
+### `balance`
+
+Check USDC balance for an address on the local Anvil fork.
+
+```bash
+npx tsx src/cli.ts balance <address> [options]
+```
+
+| Argument / Flag         | Default  | Description                  |
+| ----------------------- | -------- | ---------------------------- |
+| `<address>`             | required | 0x-prefixed Ethereum address |
+| `--anvil-port <number>` | `8545`   | Anvil RPC port               |
+
+## Test Accounts
+
+The facilitator uses Anvil's default deterministic account (index 0). **Do not use these keys for anything real.**
+
+| Role        | Address                                      |
+| ----------- | -------------------------------------------- |
+| Facilitator | `0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266` |
+
+Any address can be funded using `x402-fl fund`.
+
+## How it works
+
+Anvil forks Base mainnet at the latest block, giving you a local copy of all on-chain state including the USDC contract. The `fund` command uses `anvil_setStorageAt` to directly write ERC-20 balance values into contract storage — it auto-detects the correct storage slot by probing common mapping layouts (slots 0–20). The facilitator server exposes `/verify`, `/settle`, `/supported`, and `/health` endpoints using the `@x402/core` and `@x402/evm` packages, operating against the local Anvil fork instead of real Base mainnet.
+
+## Roadmap
+
+- [ ] Custom ERC-20 token support
+- [ ] Custom Fork url
+- [ ] Dockerised anvil node
+- [ ] Testcontainers for facilitator + anvil for deterministic testing env
+
+## Issues
+
+Found a bug or have a feature request? [Open an issue](https://github.com/anthropics/x402-fl/issues).
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import { readFileSync } from "fs";
+import { Command, InvalidArgumentError } from "commander";
+import dotenv from "dotenv";
+import { defaults } from "./lib/config.js";
+const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
+dotenv.config();
+function parsePort(value) {
+    const port = parseInt(value, 10);
+    if (isNaN(port) || port < 1 || port > 65535) {
+        throw new InvalidArgumentError("must be a number between 1 and 65535");
+    }
+    return port;
+}
+function parseAddress(value) {
+    if (!/^0x[0-9a-fA-F]{40}$/.test(value)) {
+        throw new InvalidArgumentError("must be a valid 0x-prefixed Ethereum address (42 characters)");
+    }
+    return value;
+}
+function parseAmount(value) {
+    if (!/^\d+(\.\d+)?$/.test(value) || Number(value) <= 0) {
+        throw new InvalidArgumentError("must be a positive number (e.g. '100' or '1.5')");
+    }
+    return value;
+}
+const program = new Command();
+program
+    .name("x402-fl")
+    .description("Local x402 facilitator dev tool\n\n" +
+    "  Spin up a local Anvil fork and x402 facilitator server for development.\n" +
+    "  Requires `anvil` (from Foundry) to be installed and available in PATH.\n\n" +
+    "  Quick start:\n" +
+    "    $ x402-fl dev --rpc-url https://mainnet.base.org\n" +
+    "    $ x402-fl fund 0xYourAddress 100")
+    .version(pkg.version)
+    .showHelpAfterError(true)
+    .configureHelp({ showGlobalOptions: true });
+program
+    .command("dev")
+    .description("Start Anvil fork + facilitator server for local x402 development")
+    .option("--port <number>", `facilitator server port (default: ${defaults.facilitatorPort})`, parsePort, defaults.facilitatorPort)
+    .option("--anvil-port <number>", `Anvil JSON-RPC port (default: ${defaults.anvilPort})`, parsePort, defaults.anvilPort)
+    .option("--rpc-url <url>", "Base mainnet RPC URL to fork (or set BASE_RPC_URL in .env)")
+    .addHelpText("after", `
+Examples:
+  $ x402-fl dev --rpc-url https://mainnet.base.org
+  $ x402-fl dev --rpc-url $BASE_RPC_URL --port 5000 --anvil-port 9545
+
+Environment variables:
+  BASE_RPC_URL    Fallback RPC URL when --rpc-url is not provided`)
+    .action(async (opts) => {
+    const rpcUrl = opts.rpcUrl || process.env.BASE_RPC_URL;
+    if (!rpcUrl) {
+        program.error("missing required RPC URL\n\n" +
+            "  Provide one of:\n" +
+            "    --rpc-url <url>          pass directly as a flag\n" +
+            "    BASE_RPC_URL=<url>       set in .env or environment\n\n" +
+            "  Example:\n" +
+            "    $ x402-fl dev --rpc-url https://mainnet.base.org");
+    }
+    const { devCommand } = await import("./commands/dev.js");
+    await devCommand({
+        port: opts.port,
+        anvilPort: opts.anvilPort,
+        rpcUrl,
+    });
+});
+program
+    .command("fund")
+    .description("Fund an address with USDC on local Anvil")
+    .argument("<address>", "0x-prefixed Ethereum address to fund", parseAddress)
+    .argument("<amount>", "USDC amount (e.g. '100' or '1.5')", parseAmount)
+    .option("--anvil-port <number>", `Anvil JSON-RPC port`, parsePort, defaults.anvilPort)
+    .addHelpText("after", `
+Examples:
+  $ x402-fl fund 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 100
+  $ x402-fl fund 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 1.5 --anvil-port 9545`)
+    .action(async (address, amount, opts) => {
+    const { fundCommand } = await import("./commands/fund.js");
+    await fundCommand({
+        address,
+        amount,
+        anvilPort: opts.anvilPort,
+    });
+});
+program
+    .command("balance")
+    .description("Get USDC balance for an address on local Anvil")
+    .argument("<address>", "0x-prefixed Ethereum address to check", parseAddress)
+    .option("--anvil-port <number>", `Anvil JSON-RPC port`, parsePort, defaults.anvilPort)
+    .addHelpText("after", `
+Examples:
+  $ x402-fl balance 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
+  $ x402-fl balance 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 --anvil-port 9545`)
+    .action(async (address, opts) => {
+    const { balanceCommand } = await import("./commands/balance.js");
+    await balanceCommand({
+        address,
+        anvilPort: opts.anvilPort,
+    });
+});
+program.parse();

package/dist/commands/balance.d.ts

@@ -0,0 +1,5 @@
+export interface BalanceOptions {
+    address: `0x${string}`;
+    anvilPort: number;
+}
+export declare function balanceCommand(options: BalanceOptions): Promise<void>;

package/dist/commands/balance.js

@@ -0,0 +1,46 @@
+import chalk from "chalk";
+import boxen from "boxen";
+import { createPublicClient, fetchChainId } from "../lib/chain.js";
+import { DEFAULT_DECIMALS, formatTokenAmount, USDC_ADDRESS, } from "../lib/config.js";
+import { ERC20_ABI } from "../lib/abi.js";
+export async function balanceCommand(options) {
+    const { address, anvilPort } = options;
+    const rpcUrl = `http://localhost:${anvilPort}`;
+    let chainId;
+    try {
+        chainId = await fetchChainId(rpcUrl);
+    }
+    catch {
+        console.error(`Error: Could not connect to Anvil at ${rpcUrl}.\n` +
+            `Make sure Anvil is running (e.g. "x402-fl dev" or "anvil --fork-url ...").`);
+        process.exit(1);
+    }
+    const client = createPublicClient(rpcUrl, chainId);
+    let decimals = DEFAULT_DECIMALS;
+    try {
+        decimals = await client.readContract({
+            address: USDC_ADDRESS,
+            abi: ERC20_ABI,
+            functionName: "decimals",
+        });
+    }
+    catch {
+        // Non-standard token without decimals(); fall back to default
+    }
+    const balance = await client.readContract({
+        address: USDC_ADDRESS,
+        abi: ERC20_ABI,
+        functionName: "balanceOf",
+        args: [address],
+    });
+    console.log(boxen([
+        `${chalk.dim("Token")}    ${USDC_ADDRESS}`,
+        `${chalk.dim("Address")}  ${address}`,
+        `${chalk.dim("Balance")}  ${chalk.green.bold(formatTokenAmount(balance, decimals))} USDC`,
+    ].join("\n"), {
+        title: "USDC Balance",
+        padding: 1,
+        borderStyle: "round",
+        borderColor: "cyan",
+    }));
+}

package/dist/commands/dev.d.ts

@@ -0,0 +1,6 @@
+export interface DevOptions {
+    port: number;
+    anvilPort: number;
+    rpcUrl: string;
+}
+export declare function devCommand(options: DevOptions): Promise<void>;

package/dist/commands/dev.js

@@ -0,0 +1,85 @@
+import chalk from "chalk";
+import boxen from "boxen";
+import { startAnvil, waitForAnvil } from "../lib/anvil.js";
+import { startFacilitator } from "../lib/facilitator.js";
+import { fetchChainId } from "../lib/chain.js";
+import { accounts, networkId, USDC_ADDRESS } from "../lib/config.js";
+export async function devCommand(options) {
+    const localRpcUrl = `http://localhost:${options.anvilPort}`;
+    let anvilProc = null;
+    let server = null;
+    function cleanup() {
+        console.log("\nShutting down...");
+        let pending = 0;
+        const done = () => { if (--pending <= 0)
+            process.exit(0); };
+        if (server) {
+            pending++;
+            server.close(() => done());
+            server = null;
+        }
+        if (anvilProc) {
+            pending++;
+            anvilProc.on("exit", () => done());
+            anvilProc.kill("SIGTERM");
+            anvilProc = null;
+        }
+        if (pending === 0)
+            process.exit(0);
+        // Force exit after 3s if graceful shutdown hangs
+        setTimeout(() => process.exit(0), 3000).unref();
+    }
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    // 0. Detect chain ID from fork RPC
+    console.log(chalk.dim(`Detecting chain ID from ${options.rpcUrl}...`));
+    const chainId = await fetchChainId(options.rpcUrl);
+    console.log(chalk.dim(`Detected chain ID: ${chainId}`));
+    // 1. Start Anvil
+    console.log(chalk.dim(`Starting Anvil (forking chain ${chainId}, port ${options.anvilPort})...`));
+    anvilProc = startAnvil({
+        forkUrl: options.rpcUrl,
+        port: options.anvilPort,
+        chainId,
+    });
+    anvilProc.on("exit", (code) => {
+        if (code !== null && code !== 0) {
+            console.error(chalk.red(`Anvil exited with code ${code}`));
+            process.exit(1);
+        }
+    });
+    // 2. Wait for Anvil to be ready
+    console.log(chalk.dim("Waiting for Anvil to be ready..."));
+    await waitForAnvil(localRpcUrl);
+    console.log(chalk.dim("Anvil is ready."));
+    // 3. Start facilitator
+    console.log(chalk.dim(`Starting facilitator on port ${options.port}...`));
+    server = await startFacilitator({
+        port: options.port,
+        rpcUrl: localRpcUrl,
+        chainId,
+    });
+    const network = networkId(chainId);
+    // 4. Print summary
+    console.log(boxen([
+        `${chalk.dim("Anvil RPC")}     ${chalk.cyan(localRpcUrl)}`,
+        `${chalk.dim("Facilitator")}   ${chalk.cyan(`http://localhost:${options.port}`)}`,
+        `${chalk.dim("Network")}       ${network}`,
+        `${chalk.dim("Chain ID")}      ${chainId}`,
+        "",
+        chalk.dim("Accounts"),
+        `  ${chalk.dim("Facilitator")}  ${accounts.facilitator.address}`,
+        "",
+        `${chalk.dim("USDC")}          ${USDC_ADDRESS}`,
+        "",
+        `${chalk.dim("Fund account with:")}`,
+        `$ ${chalk.white("x402-fl fund <address> <amount>")}`,
+        "",
+        chalk.dim("Press Ctrl+C to stop."),
+    ].join("\n"), {
+        title: "x402-fl dev",
+        padding: 1,
+        borderStyle: "round",
+        borderColor: "green",
+    }));
+}

package/dist/commands/fund.d.ts

@@ -0,0 +1,9 @@
+export interface FundOptions {
+    address: `0x${string}`;
+    amount: string;
+    anvilPort: number;
+}
+/**
+ * Fund any address with ERC-20 tokens by directly manipulating Anvil storage.
+ */
+export declare function fundCommand(options: FundOptions): Promise<void>;

package/dist/commands/fund.js

@@ -0,0 +1,131 @@
+import chalk from "chalk";
+import boxen from "boxen";
+import { createTestClient, http, publicActions, keccak256, encodePacked, pad, toHex, } from "viem";
+import { createLocalChain, fetchChainId } from "../lib/chain.js";
+import { DEFAULT_DECIMALS, formatTokenAmount, parseTokenAmount, USDC_ADDRESS } from "../lib/config.js";
+import { ERC20_ABI } from "../lib/abi.js";
+/**
+ * Compute the storage slot for `mapping(address => uint256)` at a given
+ * base slot index.  Solidity stores mapping values at keccak256(key . slot).
+ */
+function balanceSlot(address, baseSlot) {
+    return keccak256(encodePacked(["bytes32", "bytes32"], [pad(address, { size: 32 }), pad(toHex(baseSlot), { size: 32 })]));
+}
+/**
+ * Probe common mapping slots (0-20) to find the correct `balanceOf` storage
+ * slot for an arbitrary ERC-20 contract.
+ *
+ * Strategy: for each candidate base slot we write a known sentinel value into
+ * the computed mapping slot, then check whether `balanceOf` returns that
+ * sentinel.  The original value is always restored before moving on.
+ */
+async function findBalanceSlot(client, contractAddress, probeAddress) {
+    const sentinel = pad(toHex(31337n * 10n ** 18n), { size: 32 });
+    for (let slot = 0; slot <= 20; slot++) {
+        const storageKey = balanceSlot(probeAddress, slot);
+        // Save the original value so we can restore it.
+        const original = await client.getStorageAt({
+            address: contractAddress,
+            slot: storageKey,
+        });
+        // Write sentinel
+        await client.request({
+            method: "anvil_setStorageAt",
+            params: [contractAddress, storageKey, sentinel],
+        });
+        // Read balanceOf and see if it matches
+        const balance = await client.readContract({
+            address: contractAddress,
+            abi: ERC20_ABI,
+            functionName: "balanceOf",
+            args: [probeAddress],
+        });
+        // Restore original value regardless of outcome
+        await client.request({
+            method: "anvil_setStorageAt",
+            params: [contractAddress, storageKey, original ?? pad("0x0", { size: 32 })],
+        });
+        if (balance === 31337n * 10n ** 18n) {
+            return slot;
+        }
+    }
+    throw new Error(`Could not detect balanceOf storage slot for contract ${contractAddress}. ` +
+        `Probed slots 0-20 with no match.`);
+}
+/**
+ * Fund any address with ERC-20 tokens by directly manipulating Anvil storage.
+ */
+export async function fundCommand(options) {
+    const { address, amount, anvilPort } = options;
+    const contractAddress = USDC_ADDRESS;
+    const rpcUrl = `http://localhost:${anvilPort}`;
+    // Detect chain ID from running Anvil instance
+    let chainId;
+    try {
+        chainId = await fetchChainId(rpcUrl);
+    }
+    catch {
+        console.error(`Error: Could not connect to Anvil at ${rpcUrl}.\n` +
+            `Make sure Anvil is running (e.g. "x402-fl dev" or "anvil --fork-url ...").`);
+        process.exit(1);
+    }
+    // Create a viem TestClient (Anvil mode) with public actions
+    const chain = createLocalChain(rpcUrl, chainId);
+    const client = createTestClient({
+        mode: "anvil",
+        chain,
+        transport: http(rpcUrl),
+    }).extend(publicActions);
+    // Read token decimals from ERC-20 metadata, default to 6
+    let decimals = DEFAULT_DECIMALS;
+    try {
+        decimals = await client.readContract({
+            address: contractAddress,
+            abi: ERC20_ABI,
+            functionName: "decimals",
+        });
+    }
+    catch {
+        // Non-standard token without decimals(); fall back to default
+    }
+    const formatAmount = (raw) => formatTokenAmount(raw, decimals);
+    // Read current balance
+    const before = await client.readContract({
+        address: contractAddress,
+        abi: ERC20_ABI,
+        functionName: "balanceOf",
+        args: [address],
+    });
+    // Detect the storage slot
+    const baseSlot = await findBalanceSlot(client, contractAddress, address);
+    const addAmount = parseTokenAmount(amount, decimals);
+    const newBalance = before + addAmount;
+    // Write the new balance to storage
+    const storageKey = balanceSlot(address, baseSlot);
+    const encodedBalance = pad(toHex(newBalance), { size: 32 });
+    await client.request({
+        method: "anvil_setStorageAt",
+        params: [contractAddress, storageKey, encodedBalance],
+    });
+    // Verify the balance was updated correctly
+    const after = await client.readContract({
+        address: contractAddress,
+        abi: ERC20_ABI,
+        functionName: "balanceOf",
+        args: [address],
+    });
+    if (after !== newBalance) {
+        console.error(`Warning: Balance mismatch after storage write.\n` +
+            `  Expected: ${formatAmount(newBalance)}\n` +
+            `  Got:      ${formatAmount(after)}`);
+    }
+    // Print confirmation
+    console.log(boxen([
+        `${chalk.dim("Token")}    ${contractAddress}`,
+        `${chalk.dim("Address")}  ${address}`,
+        "",
+        `${chalk.dim("Before")}   ${formatAmount(before)} USDC`,
+        `${chalk.dim("Added")}    ${chalk.yellow("+" + formatAmount(addAmount))} USDC`,
+        `${chalk.dim("After")}    ${chalk.green.bold(formatAmount(after))} USDC`,
+    ].join("\n"), { title: "Funded", padding: 1, borderStyle: "round", borderColor: "green" }));
+}

package/dist/lib/abi.d.ts

@@ -0,0 +1,22 @@
+export declare const ERC20_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly name: "balanceOf";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "decimals";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint8";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];

package/dist/lib/abi.js

@@ -0,0 +1,16 @@
+export const ERC20_ABI = [
+    {
+        inputs: [{ name: "account", type: "address" }],
+        name: "balanceOf",
+        outputs: [{ name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "decimals",
+        outputs: [{ name: "", type: "uint8" }],
+        stateMutability: "view",
+        type: "function",
+    },
+];

package/dist/lib/anvil.d.ts

@@ -0,0 +1,8 @@
+import { type ChildProcess } from "child_process";
+export interface AnvilOptions {
+    forkUrl: string;
+    port: number;
+    chainId: number;
+}
+export declare function startAnvil(options: AnvilOptions): ChildProcess;
+export declare function waitForAnvil(rpcUrl: string, timeoutMs?: number): Promise<void>;