anon-router 0.1.0__tar.gz

anon_router-0.1.0/CLI.md

@@ -0,0 +1,81 @@
+# anon-router CLI — pay crypto for AI inference, privately, from your terminal
+
+No account, no card, no email. Deposit crypto, get an anonymous key, call any
+model. Your spends can't be linked to your deposit, and the model provider only
+ever sees the router — never you.
+
+> Testnet alpha: deposits use **Sepolia test ETH** (valueless). Don't put real
+> funds in. See [PRIVACY.md](PRIVACY.md) for exactly what is and isn't private.
+
+## Install
+
+```bash
+python3 -m venv .venv && .venv/bin/pip install .   # from this repo (Python 3.10+)
+```
+
+That puts an `anon-router` command on your PATH. It talks to the hosted router by
+default; to use your own set `export ANON_ROUTER_URL=https://your-router` (or
+`--url`).
+
+## Use it
+
+```bash
+# 1. Mint an anonymous key (no signup). This is a wallet — back up ~/.anon-router.
+anon-router account
+
+# 2a. Fund it by depositing test ETH on-chain. Put YOUR Sepolia key in a file
+#     {"private_key": "0x..."}  (or export ANON_DEPOSIT_KEY), then:
+anon-router deposit 0.001 --key myfunding.json     # waits for the credit (~30s)
+#  ...or 2b. redeem a voucher code someone gave you:
+anon-router redeem ar-XXXXXXXXXXXXXXXXXXXX
+
+# 3. Convert your balance into unlinkable ecash (this breaks the deposit link).
+anon-router claim 5000
+
+# 4. Chat — paid per request with ecash, unlinkable to your deposit.
+anon-router chat "hello there" --model openai/gpt-4o-mini
+anon-router balance
+anon-router models --search gpt
+```
+
+(Running from the repo without installing? `.venv/bin/python cli.py <same args>`.)
+
+## Use it from your agent / tool ("swap the API")
+
+Already have something that speaks the OpenAI API (Cursor, aider, the OpenAI SDK,
+your own agent)? Two ways to point it here:
+
+**Private (recommended) — run the local proxy, point your tool at it:**
+```bash
+anon-router claim 5000            # make sure your wallet has ecash
+anon-router serve                 # local proxy on http://127.0.0.1:8788/v1
+# then in your tool:  base_url = http://127.0.0.1:8788/v1   (api_key = anything)
+```
+Every request the tool makes is paid with blind-signed ecash — the router can't
+link your tool's requests to each other or to your deposit. No code changes in
+the tool. (Set `ANON_DAEMON_KEY` to require a bearer key on the proxy.)
+
+**Convenient (pseudonymous) — no local proxy:** point `base_url` at `<router>/v1`
+and use your `sk-anon-…` account key as the bearer token. Spends the account
+balance directly; simplest, but the router can link that key's requests.
+
+### Claude Code
+The proxy also speaks the Anthropic Messages API (streaming + tool use), so
+Claude Code runs against it with two env vars:
+```bash
+anon-router serve                 # local proxy, leave it running
+export ANTHROPIC_BASE_URL=http://127.0.0.1:8788
+export ANTHROPIC_API_KEY=anon-router     # any non-empty value
+claude                            # every request now pays private ecash
+```
+The model names Claude Code sends are mapped to a valid router model
+automatically; full agentic tool use works.
+
+## Or just chat in the terminal
+`anon-router chat "…"` — private (ecash), no other tool needed.
+
+## Privacy hygiene
+Fund from a fresh wallet, deposit a common round amount, spend over time, and
+rotate keys (`cli.py account`) so sessions don't link. Reach the router over its
+Tor `.onion` (`--tor`) to hide your IP. The model still reads your prompt — for
+content privacy use a `local/*` model.

anon_router-0.1.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: anon-router
+Version: 0.1.0
+Summary: Pay crypto for AI inference, privately, from your terminal
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+Requires-Dist: web3>=7
+Requires-Dist: eth-account>=0.13
+Requires-Dist: socksio>=1.0
+
+# anon-router CLI — pay crypto for AI inference, privately, from your terminal
+
+No account, no card, no email. Deposit crypto, get an anonymous key, call any
+model. Your spends can't be linked to your deposit, and the model provider only
+ever sees the router — never you.
+
+> Testnet alpha: deposits use **Sepolia test ETH** (valueless). Don't put real
+> funds in. See [PRIVACY.md](PRIVACY.md) for exactly what is and isn't private.
+
+## Install
+
+```bash
+python3 -m venv .venv && .venv/bin/pip install .   # from this repo (Python 3.10+)
+```
+
+That puts an `anon-router` command on your PATH. It talks to the hosted router by
+default; to use your own set `export ANON_ROUTER_URL=https://your-router` (or
+`--url`).
+
+## Use it
+
+```bash
+# 1. Mint an anonymous key (no signup). This is a wallet — back up ~/.anon-router.
+anon-router account
+
+# 2a. Fund it by depositing test ETH on-chain. Put YOUR Sepolia key in a file
+#     {"private_key": "0x..."}  (or export ANON_DEPOSIT_KEY), then:
+anon-router deposit 0.001 --key myfunding.json     # waits for the credit (~30s)
+#  ...or 2b. redeem a voucher code someone gave you:
+anon-router redeem ar-XXXXXXXXXXXXXXXXXXXX
+
+# 3. Convert your balance into unlinkable ecash (this breaks the deposit link).
+anon-router claim 5000
+
+# 4. Chat — paid per request with ecash, unlinkable to your deposit.
+anon-router chat "hello there" --model openai/gpt-4o-mini
+anon-router balance
+anon-router models --search gpt
+```
+
+(Running from the repo without installing? `.venv/bin/python cli.py <same args>`.)
+
+## Use it from your agent / tool ("swap the API")
+
+Already have something that speaks the OpenAI API (Cursor, aider, the OpenAI SDK,
+your own agent)? Two ways to point it here:
+
+**Private (recommended) — run the local proxy, point your tool at it:**
+```bash
+anon-router claim 5000            # make sure your wallet has ecash
+anon-router serve                 # local proxy on http://127.0.0.1:8788/v1
+# then in your tool:  base_url = http://127.0.0.1:8788/v1   (api_key = anything)
+```
+Every request the tool makes is paid with blind-signed ecash — the router can't
+link your tool's requests to each other or to your deposit. No code changes in
+the tool. (Set `ANON_DAEMON_KEY` to require a bearer key on the proxy.)
+
+**Convenient (pseudonymous) — no local proxy:** point `base_url` at `<router>/v1`
+and use your `sk-anon-…` account key as the bearer token. Spends the account
+balance directly; simplest, but the router can link that key's requests.
+
+### Claude Code
+The proxy also speaks the Anthropic Messages API (streaming + tool use), so
+Claude Code runs against it with two env vars:
+```bash
+anon-router serve                 # local proxy, leave it running
+export ANTHROPIC_BASE_URL=http://127.0.0.1:8788
+export ANTHROPIC_API_KEY=anon-router     # any non-empty value
+claude                            # every request now pays private ecash
+```
+The model names Claude Code sends are mapped to a valid router model
+automatically; full agentic tool use works.
+
+## Or just chat in the terminal
+`anon-router chat "…"` — private (ecash), no other tool needed.
+
+## Privacy hygiene
+Fund from a fresh wallet, deposit a common round amount, spend over time, and
+rotate keys (`cli.py account`) so sessions don't link. Reach the router over its
+Tor `.onion` (`--tor`) to hide your IP. The model still reads your prompt — for
+content privacy use a `local/*` model.

anon_router-0.1.0/README.md

@@ -0,0 +1,132 @@
+# anon-router
+
+Pay crypto for AI inference. An OpenAI-compatible endpoint where you deposit
+ETH/USDC, get an API key, and call any model — the provider never sees a name
+or a card, and the payment rail can't link a request to the deposit that
+funded it.
+
+## Try the demo (local)
+
+```bash
+./run_e2e.sh            # anvil + contracts + router + watcher, asserts 7/7 stages
+# then open the site:
+#   http://127.0.0.1:8402   (KEEP=1 ./run_e2e.sh leaves it running)
+```
+
+The site (`web/index.html`): click **Get API key** (no signup), **deposit ETH**
+from any wallet, watch credits land in ~2s, and **chat** — or point Cursor / any
+OpenAI client at the base URL with that key. Fewer steps than OpenRouter.
+
+## What's built
+
+| Lane | What it gives you | Trust |
+|---|---|---|
+| **Simple** (`sk-anon-*` bearer key + `CreditVault`) | deposit → key → any OpenAI client | custodial (operator holds float) |
+| **Ecash** (blind-signed tokens) | unlinkable prepaid credits | trusted mint |
+| **Channel** (confetti zk payment channels, on-chain escrow) | deposits escrowed on-chain, unlinkable per-request payments | trust-minimized: operator can't steal/freeze |
+| **Free** (`local/*`) | self-hosted models, no payment | — |
+
+**Verification:** the on-chain contract has three independent code reviews
+(Fable, Codex, Kimi) plus a machine-checked Lean proof of its safety core
+(conservation, no-theft, terminality) — see [VERIFICATION.md](VERIFICATION.md).
+The settlement core is also written in the [Verity](https://veritylang.com) Lean
+EDSL that compiles to EVM. Testnet-only; nothing is deployed to a public chain.
+
+---
+
+Payer-anonymous, OpenAI-compatible inference proxy. Prepay for credits, spend them as blind-signed bearer tokens: the router can verify every payment but cannot link any request to the deposit that funded it, or link two requests to each other.
+
+v1 rail is Cashu-style blind signatures (BDHKE) with a trusted mint. The channel lane replaces the trusted mint with confetti zk payment channels (see `../zk-payments-confetti/PROTOCOL.md`) so the router also cannot steal or freeze deposits.
+
+## How it works
+
+1. Deposit (dev: free faucet; prod: USDC) and receive blind-signed tokens in power-of-two credit denominations. 1 credit = $0.0001.
+2. Each `/v1/chat/completions` request attaches tokens in the `X-Cash` header as prepayment.
+3. The router verifies + burns the tokens, proxies to the upstream (OpenRouter), reads the exact USD cost from usage accounting, and holds the overpayment under a one-time receipt (`X-Change-Receipt` response header).
+4. The wallet redeems the receipt for fresh blind-signed change tokens.
+
+Blinding means the mint signs tokens without seeing them, so issued tokens and spent tokens are cryptographically unlinkable. Amount is bound by using one mint key per denomination.
+
+## Quickstart
+
+```bash
+python3 -m venv .venv && .venv/bin/pip install -r requirements.txt
+cp .env.example .env   # set OPENROUTER_API_KEY
+.venv/bin/uvicorn server:app --host 127.0.0.1 --port 8402
+
+# in another shell
+.venv/bin/python cli.py topup 50000          # $5 of dev credits
+.venv/bin/python cli.py chat "hello there"   # pays per request
+.venv/bin/python cli.py balance
+```
+
+Any OpenAI-compatible client works against `http://127.0.0.1:8402/v1` if it can attach the `X-Cash` header per request (the CLI/wallet does this automatically).
+
+## Selling credits (vouchers)
+
+The MVP resale loop: the operator funds an OpenRouter account wholesale, sells voucher codes through any channel (USDC, WeChat, resellers), and buyers redeem codes for anonymous credits. The mint sees which voucher a redemption came from but cannot link the resulting tokens to any later request (blind signatures).
+
+```bash
+# operator, on the router box:
+.venv/bin/python admin.py issue 50000          # prints a code worth $5
+.venv/bin/python admin.py list                 # ledger of issued/redeemed
+
+# buyer, anywhere:
+python cli.py redeem ar-XXXXXXXXXXXXXXXXXXXX   # code → anonymous credits
+python cli.py chat "hello" --model openai/gpt-4o-mini
+```
+
+Set `DEV_FAUCET=0` in `.env` for any deployment where credits are sold.
+
+## Trust-minimized channel lane (confetti, M4a)
+
+An opt-in payment lane where the buyer's deposit is governed by the confetti
+zk payment channel instead of trusting the mint. See [confetti/README.md](confetti/README.md).
+
+```bash
+python cli.py channel open 5000                       # deposit 5000 credits
+python cli.py chat "hello" --model openai/gpt-4o-mini --channel
+python cli.py channel status
+```
+
+Each request builds a payment proof, the router verifies and countersigns it,
+and a stale/rolled-back close is provably challengeable. M4a runs off-chain
+against an in-memory referee with the reference (non-ZK) prover; M4b adds the
+on-chain contract and the real STARK prover.
+
+## Free local lane
+
+Models prefixed `local/` route to a free upstream (RTX 3080 PC running Ollama, reached via ssh tunnel) and require no payment. For user testing without spending credits:
+
+```bash
+ssh -f -N -L 11435:127.0.0.1:11434 pc3080   # once per boot
+.venv/bin/python cli.py chat "hello" --model local/qwen3:8b
+```
+
+Override the upstream with `LOCAL_UPSTREAM` in `.env`.
+
+## Honest limitations (v1)
+
+- The mint is trusted with float: it could refuse redemption. v2 (confetti channels) removes this.
+- Payment unlinkability is not payer anonymity: use fresh connections/proxy for transport privacy. Requests within one HTTP session are linkable by the connection itself.
+- Prepay is a fixed amount per request, not a per-model max-cost estimate.
+- Streaming change redemption requires polling the receipt after the stream ends.
+- Dev faucet stands in for the USDC deposit watcher.
+
+## Milestones
+
+- **v0** — blind-signature mint, OpenRouter proxy, exact-cost metering. Done.
+- **Voucher resale** — operator sells codes, buyers redeem for anonymous credits. Done.
+- **Simple lane** — `CreditVault` deposit → bearer key → any OpenAI client; site + watcher. Done.
+- **M4a** — confetti off-chain channel protocol + router lane. Done.
+- **M4b** — on-chain escrow (`ConfettiChannels`), deposits leave custody, 3-reviewer + Lean-proof gate. Done (local Anvil).
+- **Verity** — settlement core written in Lean, compiled to EVM. In progress.
+- **M4b-real** — SP1 Groth16 verifier replacing the mock. In progress (Docker/colima).
+
+## Roadmap
+
+- USDC deposit lane (same as `CreditVault`, ERC-20 `transferFrom`)
+- Known-answer sampling audits of upstreams, published scores
+- new-api/one-api payment module (中转站 integration)
+- Durable persistence of the router's off-chain state (dedup/inbox/XMSS)
+- Public deploy to Ethereum Sepolia (operator holds the key; counsel gate first)

anon_router-0.1.0/anon_router.egg-info/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: anon-router
+Version: 0.1.0
+Summary: Pay crypto for AI inference, privately, from your terminal
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+Requires-Dist: web3>=7
+Requires-Dist: eth-account>=0.13
+Requires-Dist: socksio>=1.0
+
+# anon-router CLI — pay crypto for AI inference, privately, from your terminal
+
+No account, no card, no email. Deposit crypto, get an anonymous key, call any
+model. Your spends can't be linked to your deposit, and the model provider only
+ever sees the router — never you.
+
+> Testnet alpha: deposits use **Sepolia test ETH** (valueless). Don't put real
+> funds in. See [PRIVACY.md](PRIVACY.md) for exactly what is and isn't private.
+
+## Install
+
+```bash
+python3 -m venv .venv && .venv/bin/pip install .   # from this repo (Python 3.10+)
+```
+
+That puts an `anon-router` command on your PATH. It talks to the hosted router by
+default; to use your own set `export ANON_ROUTER_URL=https://your-router` (or
+`--url`).
+
+## Use it
+
+```bash
+# 1. Mint an anonymous key (no signup). This is a wallet — back up ~/.anon-router.
+anon-router account
+
+# 2a. Fund it by depositing test ETH on-chain. Put YOUR Sepolia key in a file
+#     {"private_key": "0x..."}  (or export ANON_DEPOSIT_KEY), then:
+anon-router deposit 0.001 --key myfunding.json     # waits for the credit (~30s)
+#  ...or 2b. redeem a voucher code someone gave you:
+anon-router redeem ar-XXXXXXXXXXXXXXXXXXXX
+
+# 3. Convert your balance into unlinkable ecash (this breaks the deposit link).
+anon-router claim 5000
+
+# 4. Chat — paid per request with ecash, unlinkable to your deposit.
+anon-router chat "hello there" --model openai/gpt-4o-mini
+anon-router balance
+anon-router models --search gpt
+```
+
+(Running from the repo without installing? `.venv/bin/python cli.py <same args>`.)
+
+## Use it from your agent / tool ("swap the API")
+
+Already have something that speaks the OpenAI API (Cursor, aider, the OpenAI SDK,
+your own agent)? Two ways to point it here:
+
+**Private (recommended) — run the local proxy, point your tool at it:**
+```bash
+anon-router claim 5000            # make sure your wallet has ecash
+anon-router serve                 # local proxy on http://127.0.0.1:8788/v1
+# then in your tool:  base_url = http://127.0.0.1:8788/v1   (api_key = anything)
+```
+Every request the tool makes is paid with blind-signed ecash — the router can't
+link your tool's requests to each other or to your deposit. No code changes in
+the tool. (Set `ANON_DAEMON_KEY` to require a bearer key on the proxy.)
+
+**Convenient (pseudonymous) — no local proxy:** point `base_url` at `<router>/v1`
+and use your `sk-anon-…` account key as the bearer token. Spends the account
+balance directly; simplest, but the router can link that key's requests.
+
+### Claude Code
+The proxy also speaks the Anthropic Messages API (streaming + tool use), so
+Claude Code runs against it with two env vars:
+```bash
+anon-router serve                 # local proxy, leave it running
+export ANTHROPIC_BASE_URL=http://127.0.0.1:8788
+export ANTHROPIC_API_KEY=anon-router     # any non-empty value
+claude                            # every request now pays private ecash
+```
+The model names Claude Code sends are mapped to a valid router model
+automatically; full agentic tool use works.
+
+## Or just chat in the terminal
+`anon-router chat "…"` — private (ecash), no other tool needed.
+
+## Privacy hygiene
+Fund from a fresh wallet, deposit a common round amount, spend over time, and
+rotate keys (`cli.py account`) so sessions don't link. Reach the router over its
+Tor `.onion` (`--tor`) to hide your IP. The model still reads your prompt — for
+content privacy use a `local/*` model.

anon_router-0.1.0/anon_router.egg-info/SOURCES.txt

@@ -0,0 +1,26 @@
+CLI.md
+README.md
+anthropic_proxy.py
+cli.py
+ec.py
+mint.py
+pyproject.toml
+serve_ecash.py
+wallet.py
+anon_router.egg-info/PKG-INFO
+anon_router.egg-info/SOURCES.txt
+anon_router.egg-info/dependency_links.txt
+anon_router.egg-info/entry_points.txt
+anon_router.egg-info/requires.txt
+anon_router.egg-info/top_level.txt
+confetti/__init__.py
+confetti/chain.py
+confetti/channel.py
+confetti/hashes.py
+confetti/merkle.py
+confetti/relation.py
+confetti/sp1.py
+confetti/wire.py
+confetti/wots.py
+tests/test_confetti.py
+tests/test_sp1_prover.py

anon_router-0.1.0/anon_router.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

anon_router-0.1.0/anon_router.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+anon-router = cli:main

anon_router-0.1.0/anon_router.egg-info/requires.txt

@@ -0,0 +1,4 @@
+httpx>=0.27
+web3>=7
+eth-account>=0.13
+socksio>=1.0

anon_router-0.1.0/anon_router.egg-info/top_level.txt

@@ -0,0 +1,7 @@
+anthropic_proxy
+cli
+confetti
+ec
+mint
+serve_ecash
+wallet