walletcap 0.2.2__tar.gz → 0.2.4__tar.gz

{walletcap-0.2.2 → walletcap-0.2.4}/.circleci/config.yml

@@ -33,6 +33,14 @@ jobs:
             cd solidity/evm
             npm install --no-audit --no-fund --no-package-lock
             node check.mjs ..
+      - run:
+          name: Crash test
+          command: |
+            cd crash-test
+            npm install --no-audit --no-fund --no-package-lock
+            npm install --no-save --no-audit --no-fund --no-package-lock ../js
+            node contracts/build.mjs --check
+            node --test
 
 workflows:
   ci:

walletcap-0.2.4/.github/workflows/ci.yml

@@ -0,0 +1,80 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  javascript:
+    name: JavaScript
+    runs-on: ubuntu-latest
+    container: node:22-bookworm
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5
+      - name: Install the test dependencies
+        run: npm install --no-audit --no-fund
+        working-directory: js
+      - name: Run the suite
+        run: node --test
+        working-directory: js
+
+  python:
+    name: Python
+    runs-on: ubuntu-latest
+    container: node:22-bookworm
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5
+      - uses: astral-sh/setup-uv@d0cc045d04ccac9d8b7881df0226f9e82c39688e
+      - name: Run the suite
+        # Node is on PATH here, so the cross-language tests run rather than skip.
+        run: uv run --with pytest --python 3.12 pytest -q
+
+  solidity:
+    name: Solidity
+    runs-on: ubuntu-latest
+    container: node:22-bookworm
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5
+      - name: Install the check's dependencies
+        run: npm install --no-audit --no-fund
+        working-directory: solidity/evm
+      - name: Drive the contract on an EVM
+        run: node check.mjs ..
+        working-directory: solidity/evm
+
+  crash-test:
+    name: Crash test
+    runs-on: ubuntu-latest
+    container: node:22-bookworm
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5
+      - name: Install the crash test, on this checkout's walletcap
+        run: |
+          npm install --no-audit --no-fund --no-package-lock
+          npm install --no-save --no-audit --no-fund --no-package-lock ../js
+        working-directory: crash-test
+      - name: Check the shipped contracts match their sources
+        run: node contracts/build.mjs --check
+        working-directory: crash-test
+      - name: Run it
+        run: node --test
+        working-directory: crash-test
+
+  crash-test-agentkit:
+    name: Crash test (AgentKit)
+    runs-on: ubuntu-latest
+    container: node:22-bookworm
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5
+      - name: Pack the crash test
+        run: npm pack --pack-destination "$RUNNER_TEMP"
+        working-directory: crash-test
+      # As users run it: AgentKit installed alongside, walletcap from npm.
+      - name: Run it with Coinbase AgentKit alongside
+        run: npx -y -p "$RUNNER_TEMP"/walletcap-crash-test-*.tgz -p @coinbase/agentkit@0.10.4 walletcap-crash-test --agentkit --json > "$RUNNER_TEMP/agentkit.json"
+      - name: Check the AgentKit row
+        run: node crash-test/ci/check-agentkit.mjs "$RUNNER_TEMP/agentkit.json"

walletcap-0.2.4/.github/workflows/mcp-registry.yml

@@ -0,0 +1,47 @@
+# SPDX-License-Identifier: Apache-2.0
+# Publish server.json to the official MCP Registry (registry.modelcontextprotocol.io), by hand.
+# Run it once the npm release that server.json names is out: the registry checks that
+# walletcap@<version> on npm carries "mcpName": "io.github.coriolislabs/walletcap".
+# GitHub OIDC proves the io.github.coriolislabs namespace, so no token is stored.
+# (mcp-publisher's interactive GitHub login can't publish to an organization namespace.)
+name: MCP Registry
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    name: Publish server.json
+    runs-on: ubuntu-latest
+    env:
+      MCP_PUBLISHER_VERSION: v1.8.7
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5
+      - name: Check server.json names the npm package's version and mcpName
+        run: |
+          test "$(jq -r .version server.json)" = "$(jq -r .version js/package.json)"
+          test "$(jq -r '.packages[0].version' server.json)" = "$(jq -r .version js/package.json)"
+          test "$(jq -r .name server.json)" = "$(jq -r .mcpName js/package.json)"
+      - uses: sigstore/cosign-installer@6f9f17788090df1f26f669e9d70d6ae9567deba6 # v4.1.2
+      - name: Download mcp-publisher and verify its Sigstore bundle
+        run: |
+          set -euo pipefail
+          archive=mcp-publisher_linux_amd64.tar.gz
+          base_url="https://github.com/modelcontextprotocol/registry/releases/download/${MCP_PUBLISHER_VERSION}"
+          curl --fail --location --silent --show-error --output "$archive" "$base_url/$archive"
+          curl --fail --location --silent --show-error --output "$archive.sigstore.json" "$base_url/$archive.sigstore.json"
+          cosign verify-blob \
+            --bundle "$archive.sigstore.json" \
+            --certificate-identity "https://github.com/modelcontextprotocol/registry/.github/workflows/release.yml@refs/tags/${MCP_PUBLISHER_VERSION}" \
+            --certificate-oidc-issuer "https://token.actions.githubusercontent.com" \
+            "$archive"
+          tar xzf "$archive" mcp-publisher
+          rm -f "$archive" "$archive.sigstore.json"
+      - name: Log in to the registry with GitHub OIDC
+        run: ./mcp-publisher login github-oidc
+      - name: Publish server.json
+        run: ./mcp-publisher publish

walletcap-0.2.4/.github/workflows/publish.yml

@@ -0,0 +1,100 @@
+# SPDX-License-Identifier: Apache-2.0
+# Publish when a GitHub Release is published, or by hand.
+# - A release tagged v<version> publishes walletcap to PyPI and npm.
+# - A release tagged crash-test-v<version> publishes walletcap-crash-test to npm, and nothing else.
+# Everything uses trusted publishing, so no token is stored. PyPI matches this repository,
+# the workflow filename (publish.yml) and the "pypi" environment, and attaches PEP 740
+# attestations. npm matches this repository, publish.yml and the "npm" environment, for
+# each of the two packages, and attaches provenance.
+name: Publish
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  pypi:
+    name: PyPI
+    if: github.event_name != 'release' || !startsWith(github.event.release.tag_name, 'crash-test-v')
+    runs-on: ubuntu-latest
+    environment: pypi
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5
+      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065
+        with:
+          python-version: "3.12"
+      - name: Check the release tag matches the package version
+        if: github.event_name == 'release'
+        env:
+          TAG: ${{ github.event.release.tag_name }}
+        run: test "$TAG" = "v$(python -c "import tomllib; print(tomllib.load(open('pyproject.toml', 'rb'))['project']['version'])")"
+      - name: Run the Python suite
+        run: |
+          python -m pip install --upgrade pytest
+          python -m pytest -q
+      - name: Build the distributions
+        run: |
+          python -m pip install --upgrade build
+          python -m build
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@7245906fb61fa33a13554f9d5fb856fe61758086 # v1.14.3
+
+  npm:
+    name: npm
+    if: github.event_name != 'release' || !startsWith(github.event.release.tag_name, 'crash-test-v')
+    runs-on: ubuntu-latest
+    environment: npm
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5
+      - uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0
+        with:
+          node-version: "22"
+          registry-url: "https://registry.npmjs.org"
+          package-manager-cache: false
+      - name: Use an npm that supports trusted publishing (11.5.1 or later)
+        run: npm install --global npm@11.21.1
+      - name: Check the release tag matches the package version
+        if: github.event_name == 'release'
+        env:
+          TAG: ${{ github.event.release.tag_name }}
+        run: test "$TAG" = "v$(node -p "require('./js/package.json').version")"
+      - name: Run the JavaScript suite
+        working-directory: js
+        run: |
+          npm install --no-audit --no-fund --no-package-lock
+          node --test
+      - name: Publish to npm with provenance
+        working-directory: js
+        run: npm publish --provenance
+
+  crash-test:
+    name: npm (crash test)
+    if: github.event_name == 'release' && startsWith(github.event.release.tag_name, 'crash-test-v')
+    runs-on: ubuntu-latest
+    environment: npm
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5
+      - uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0
+        with:
+          node-version: "22"
+          registry-url: "https://registry.npmjs.org"
+          package-manager-cache: false
+      - name: Use an npm that supports trusted publishing (11.5.1 or later)
+        run: npm install --global npm@11.21.1
+      - name: Check the release tag matches the package version
+        env:
+          TAG: ${{ github.event.release.tag_name }}
+        run: test "$TAG" = "crash-test-v$(node -p "require('./crash-test/package.json').version")"
+      - name: Run the crash test on the walletcap users get from npm
+        working-directory: crash-test
+        run: |
+          npm install --no-audit --no-fund --no-package-lock
+          node --test
+      - name: Publish to npm with provenance
+        working-directory: crash-test
+        run: npm publish --provenance

walletcap-0.2.4/CHANGELOG.md

@@ -0,0 +1,77 @@
+<!-- SPDX-License-Identifier: Apache-2.0 -->
+# Changelog
+
+## 0.2.4 — 2026-11-06
+
+### Added
+
+- `mcpName` in the npm package and a `server.json`, so `walletcap awal-mcp` can be listed in the
+  official MCP Registry as `io.github.coriolislabs/walletcap`. `glama.json` names the maintainer
+  for Glama.
+- A docs site, https://coriolislabs.github.io/WalletCap/, with one page per integration, and
+  `llms.txt`.
+
+### Fixed
+
+- The `create` doc comment in `index.d.ts` said it defaulted to true. It defaults to false.
+
+### Changed
+
+- Package descriptions and search keywords on npm and PyPI, and a README that leads with the
+  crash test.
+
+## 0.2.3 — 2026-11-06
+
+### Changed
+
+- Releases are published from GitHub Actions with trusted publishing: npm with provenance,
+  PyPI with PEP 740 attestations. No token is stored. A GitHub Release whose tag doesn't
+  match the package version is refused.
+
+### Fixed
+
+- `AccountCapSpender` no longer locks an account after a burst of payments. An unbounded log
+  made the first payment after 3,000 tiny ones cost about 17.7M gas, past the 2^24
+  per-transaction cap. The window is now counted in 24 buckets in a fixed ring of 25 slots, so
+  every `pay` costs the same gas. A payment counts for up to one bucket (window/24) past its
+  window, never less. The window must be a multiple of 24 seconds.
+- `walletcap awal-mcp` ran `npx -y @coinbase/payments-mcp`, which is Coinbase's installer, not
+  the MCP server. It now runs the installed server, `~/.payments-mcp/bundle.js`, and says how to
+  install it when it is missing.
+- `walletcap awal-mcp` forwarded every tool it didn't count. It now passes through only the
+  tools that move no money, and counts `send` and `make_http_request_with_x402`. It refuses
+  everything else, `trade` included, and leaves those tools out of `tools/list`, unless the
+  owner names one with `--allow-tool`. JSON-RPC batches and lines that aren't JSON are refused.
+
+### Added
+
+- `budget.guardAgentKit(provider)` puts the budget on every x402 client an AgentKit
+  `X402ActionProvider` builds. The README's subclass recipe didn't compile in TypeScript,
+  where `createX402Client` is private. `tsc` now checks the recipe against AgentKit's declared
+  types in the test suite.
+
+## 0.2.2 — 2026-11-05
+
+### Changed
+
+- A mixed-case EVM address is checked against EIP-55 before it is accepted. A bad
+  checksum is refused; all-lowercase and all-uppercase hex are still accepted.
+- A Solana CAIP-10 address is reduced to its address, so it and the bare address
+  share one budget.
+- Numeric `window` values are milliseconds in Python too, matching JavaScript.
+
+### Fixed
+
+- The rolling window cannot be shortened once the budget has spend. An edit can
+  change the cap and the per-payment limit, but it cannot reset the count by
+  shrinking the window.
+
+### Added
+
+- `SECURITY.md`, `docs/threat-model.md`, `docs/vendor-disclosure.md`, and the
+  Solidity audit status in `solidity/README.md`.
+- `examples/quickstart/` in JavaScript and Python, run in CI. No wallet, chain,
+  keys or network.
+- EIP-55, Solana CAIP-10, and window-freeze tests in both languages.
+
+## 0.2.1 — 2026-11-05

{walletcap-0.2.2 → walletcap-0.2.4}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.5
 Name: walletcap
-Version: 0.2.2
-Summary: One spend budget per wallet for AI agents: counted across every process, replica, key, permission and payment rail.
+Version: 0.2.4
+Summary: Spend limits for AI agent wallets: a per-payment cap and rolling 24-hour budget that holds across restarts, kept in a SQLite file every process and the npm package share.
 Project-URL: Homepage, https://github.com/coriolislabs/WalletCap
 Project-URL: Repository, https://github.com/coriolislabs/WalletCap
 Project-URL: Issues, https://github.com/coriolislabs/WalletCap/issues
@@ -9,7 +9,7 @@ Author: Coriolis Labs Inc.
 License-Expression: Apache-2.0
 License-File: LICENSE
 License-File: NOTICE
-Keywords: agent-payments,ai-agents,budget,guardrails,spend-limit,stablecoin,usdc,x402
+Keywords: agent-payments,agent-wallet,ai-agent,ai-agents,budget,guardrails,spend-limit,spending-limit,stablecoin,usdc,x402
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
@@ -22,19 +22,63 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 
 <!-- SPDX-License-Identifier: Apache-2.0 -->
-# walletcap
+# walletcap: spend limits for AI agent wallets
 
-[![CircleCI](https://dl.circleci.com/status-badge/img/circleci/9kf5Wo9wYAuLZHsV9nFTQC/Pcdc3JTt5shsZfYpip6SBB/tree/main.svg?style=svg)](https://app.circleci.com/pipelines/circleci/9kf5Wo9wYAuLZHsV9nFTQC/Pcdc3JTt5shsZfYpip6SBB)
+[![npm](https://img.shields.io/npm/v/walletcap?label=npm)](https://www.npmjs.com/package/walletcap)
+[![PyPI](https://img.shields.io/pypi/v/walletcap?label=PyPI)](https://pypi.org/project/walletcap/)
+[![CI](https://github.com/coriolislabs/WalletCap/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/coriolislabs/WalletCap/actions/workflows/ci.yml)
+[![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue)](https://github.com/coriolislabs/WalletCap/blob/main/LICENSE)
 
-**Your agent's spending limit forgets. This one doesn't.** By ShadowPath.
+**Spend limits for AI agent wallets that pay in USDC: a per-payment cap and a rolling 24-hour
+budget that holds across restarts, replicas and payment rails.** walletcap plugs into x402
+clients, Coinbase CDP's x402 spend controls, Coinbase AgentKit, the Coinbase Agentic Wallet CLI
+and payments MCP server, and Coinbase Spend Permissions. By ShadowPath.
 
-Agent payment kits count "spent so far" per process, per key, per permission or per
-period. So a restart, a second replica, one more key, or the next period hands the agent a
-fresh budget. walletcap counts **per wallet**: one budget that every process,
-replica, key, permission and payment rail spends from.
+## Crash test: CDP's controls let $1,600–$1,700 past a $150 cap, walletcap lets $0
 
-The owner creates the budget once. Opening it never creates one; pass `create: true` only
-for a demo or first-run setup:
+`npx walletcap-crash-test` puts Coinbase's agent spend controls through four ordinary events (a
+restart, 10 replicas, 10 replicas on a shared store, and a payee who asks for EURC), then puts
+walletcap through the same events. CDP's x402 controls are set as Coinbase's README shows, then
+run again on walletcap's `cdpStore` as this README shows. Spend Permissions run Coinbase's
+deployed contract code on a local EVM. Every agent is held to $50 a payment and $150 in any 24
+hours, in USDC on Base. It runs offline in about 15 seconds and sends nothing.
+
+```console
+$ npx walletcap-crash-test
+```
+
+| CDP x402 spend controls | CDP's controls | walletcap guard | walletcap cdpStore |
+|---|---|---|---|
+| restart, then pay again | $300 signed · $150 over | $150 signed · $0 over | $150 signed · $0 over |
+| 10 replicas | $1,500 signed · $1,350 over | $150 signed · $0 over | $150 signed · $0 over |
+| 10 replicas, shared store 1 ms away | $350 signed · $200 over | $150 signed · $0 over | $150 signed · $0 over |
+| payee asks for EURC, not USDC | 1,000 EURC signed, counted as $0 | refused before signing | refused before signing |
+
+| Spend Permissions | SpendPermissionManager | AccountCapSpender |
+|---|---|---|
+| a second permission | $300 pulled · $150 over | $150 pulled · $0 over |
+| across a period boundary, 1 second apart | $300 pulled · $150 over | $150 pulled · $0 over |
+
+Past the $150 cap: $1,700 and 1,000 EURC with CDP's controls, $300 with Spend Permissions; $0
+with walletcap's guard, its cdpStore and AccountCapSpender. The shared-store row varies from
+run to run: in eight runs on 6 November 2026 it was $100 over five times and $200 over three
+times. Those runs used `@coinbase/cdp-sdk` 1.61.0, `@x402/core` 2.30.0, SpendPermissionManager
+1.0.0 and walletcap 0.2.3.
+
+Add `--agentkit` for Coinbase AgentKit's row: the agent approves a 1¢ offer, and AgentKit signs
+the merchant's first-listed $1.00 on Base mainnet. walletcap, at 2¢ a payment, refuses it before
+signing. [The crash test's README](https://github.com/coriolislabs/WalletCap/tree/main/crash-test)
+says exactly what runs.
+
+## Install and use
+
+```console
+$ npm install walletcap     # Node 22.13+, no dependencies
+$ pip install walletcap     # Python 3.11+, no dependencies
+```
+
+The owner creates the budget once. Opening it never creates one; pass `create: true` only for a
+demo or first-run setup:
 
 ```console
 $ npx walletcap set --wallet 0xYourAgentWallet --per-payment 50 --per-day 150
@@ -57,8 +101,18 @@ with budget.pay("$12.50"):
     send_usdc(payee, "12.50")
 ```
 
-`npm install walletcap` (Node 22.13+) · `pip install walletcap` (Python 3.11+) ·
-no dependencies · Apache-2.0
+| Integration | Install | Use |
+|---|---|---|
+| [Any x402 client](https://github.com/coriolislabs/WalletCap/blob/main/docs/x402-spending-limit.md) (`@x402/core`, `@x402/fetch`) | `npm install walletcap` | `budget.guard(client)` |
+| [Coinbase CDP x402 spend controls](https://github.com/coriolislabs/WalletCap/blob/main/docs/coinbase-cdp-spend-controls.md) | `npm install walletcap @coinbase/cdp-sdk` | `store: budget.cdpStore({ asset: USDC })` in `applySpendControls` |
+| [Coinbase AgentKit](https://github.com/coriolislabs/WalletCap/blob/main/docs/coinbase-agentkit-spending-limit.md) | `npm install walletcap @coinbase/agentkit` | `budget.guardAgentKit(new X402ActionProvider())` |
+| [Coinbase Agentic Wallet CLI](https://github.com/coriolislabs/WalletCap/blob/main/docs/coinbase-agentic-wallet-budget.md) | `npm install walletcap awal` | `npx walletcap awal x402 pay <url>` |
+| [Coinbase payments MCP server](https://github.com/coriolislabs/WalletCap/blob/main/docs/coinbase-agentic-wallet-budget.md#the-mcp-server-one-entry-in-the-clients-config) | `npx @coinbase/payments-mcp install --client other --no-auto-config` | MCP server command: `npx walletcap awal-mcp --wallet 0x…` |
+| [Coinbase Spend Permissions](https://github.com/coriolislabs/WalletCap/blob/main/docs/coinbase-spend-permissions-cap.md) | deploy `solidity/src/AccountCapSpender.sol` (testnet only, unaudited) | the agent calls `pay(permission, amount, payee)` |
+| [Python](https://github.com/coriolislabs/WalletCap/blob/main/docs/python-agent-spending-limit.md) | `pip install walletcap` | `with budget.pay("$12.50"):` |
+
+Each link opens a page with a full snippet. The [Use it](#use-it) section below covers every
+integration too.
 
 ## Try it without a wallet
 
@@ -209,16 +263,23 @@ $ npx walletcap awal x402 pay https://api.example.com/data   # instead of: npx a
 $ npx walletcap awal send 0.05 0xRecipient --chain base       # instead of: npx awal send …
 ```
 
-For an MCP client such as Claude Desktop, start Coinbase's server behind walletcap. It runs
-`npx -y @coinbase/payments-mcp`; put another command after `--`.
+For an MCP client such as Claude Desktop, start Coinbase's server behind walletcap. Install the
+server once: `npx @coinbase/payments-mcp install --client other --no-auto-config` puts it in
+`~/.payments-mcp`, and walletcap runs `~/.payments-mcp/bundle.js` from there. (`npx
+@coinbase/payments-mcp` is the installer, not the server.) To run another server, put its
+command after `--`.
 
 ```json
 { "mcpServers": { "payments": { "command": "npx", "args": ["walletcap", "awal-mcp", "--wallet", "0xYourAgentWallet"] } } }
 ```
 
 - `send` and `x402 pay` (over MCP, `send` and `make_http_request_with_x402`) are checked against
-  the wallet's budget before the wallet signs anything, and counted. Every other command and tool
-  is the wallet's own.
+  the wallet's budget before the wallet signs anything, and counted. Every other CLI command is
+  the wallet's own.
+- Over MCP, the tools that move no money (balance, address, sign-in, bazaar search, payment
+  discovery) pass through. Any other tool, `trade` or one the server adds later, is refused and
+  left out of the tool list: walletcap can't count it. `--allow-tool <name>` lets one through,
+  uncounted. JSON-RPC batches are refused.
 - An x402 payment is priced from the endpoint's own 402 answer, and the wallet is capped at exactly
   that amount, so it refuses to sign for more.
 - A payment the payee confirms as settled counts for one window. One it doesn't confirm keeps
@@ -234,21 +295,20 @@ For an MCP client such as Claude Desktop, start Coinbase's server behind walletc
 
 ### Coinbase AgentKit
 
-AgentKit's x402 actions build their own x402 client on every call. Put the budget on that client
-with a three-line subclass, and every payment is checked against the wallet's budget before it
-is signed, whatever terms the merchant sends:
+AgentKit's x402 actions build their own x402 client on every call. `budget.guardAgentKit()` puts
+the budget on every client the provider builds, so each payment is checked against the wallet's
+budget before it is signed, whatever terms the merchant sends:
 
 ```js
 import { X402ActionProvider } from '@coinbase/agentkit';
 
-class BudgetedX402ActionProvider extends X402ActionProvider {
-  async createX402Client(walletProvider) {
-    return budget.guard(await super.createX402Client(walletProvider));
-  }
-}
-// AgentKit.from({ walletProvider, actionProviders: [new BudgetedX402ActionProvider()] })
+const x402 = budget.guardAgentKit(new X402ActionProvider());
+// AgentKit.from({ walletProvider, actionProviders: [x402] })
 ```
 
+It compiles in TypeScript, where a subclass can't override AgentKit's private
+`createX402Client`. Tested against the shape of AgentKit 0.10.4.
+
 ### Coinbase Spend Permissions, on chain
 
 For a limit the agent's own code can't go around, `solidity/src/AccountCapSpender.sol` is the
@@ -256,7 +316,9 @@ spender for Spend Permissions. Deploy it with the SpendPermissionManager, the ag
 address, the cap, the window, the per-payment max and the payees allowed. Grant Spend
 Permissions to the contract instead of the agent; the agent calls
 `pay(permission, amount, payee)`. Every permission the account grants it then shares one
-rolling cap.
+rolling cap. The window is counted in 24 buckets, so every payment costs the same gas however
+many came before it; a payment counts for up to one bucket (window/24) past its window, never
+less.
 
 ## The owner's controls
 
@@ -313,10 +375,13 @@ only for a demo or a first-run setup.
 | `js/` | the npm package `walletcap`: the budget, the x402 guard, the CDP store, the CLI, and the Agentic Wallet CLI wrapper and MCP proxy |
 | `src/walletcap/` | the PyPI package `walletcap`, on the same file format |
 | `solidity/` | `AccountCapSpender`, the on-chain cap for Coinbase Spend Permissions |
+| `crash-test/` | the crash test: CDP's spend controls and walletcap through the same events, in dollars |
 | `tests/` | the Python suite, including the tests that drive both languages against one budget file |
+| `docs/` | the docs site for GitHub Pages: one page per integration, each with a full snippet, plus the threat model |
+| `llms.txt` | a summary of the package and links to the docs, for language models |
 
 ```console
-$ cd js && npm install && node --test            # 61 tests
+$ cd js && npm install && node --test            # 65 tests
 $ uv run --with pytest pytest -q                 # 59 tests, from the repository root
 $ cd solidity/evm && npm install && node check.mjs ..   # the contract on an EVM, no Foundry needed
 $ cd solidity && forge test                      # the contract's canonical tests, if you have Foundry
@@ -324,7 +389,9 @@ $ cd solidity && forge test                      # the contract's canonical test
 
 The JavaScript suite runs the x402 guard against x402's own client and fetch wrapper, and runs
 restarts and racing replicas as separate processes, and drives the Agentic Wallet wrapper and
-MCP proxy against stand-ins for Coinbase's wallet and MCP server. The Python suite covers the ledger, the API,
+MCP proxy against stand-ins for Coinbase's wallet and MCP server. It builds AgentKit's x402
+client the way AgentKit 0.10.4 does, and type-checks the AgentKit recipe with `tsc` against
+AgentKit's declared types. The Python suite covers the ledger, the API,
 the CLI and one budget shared between both languages. `solidity/evm/check.mjs` compiles the
 contract with solc-js and drives it on an in-process EVM, covering what the Foundry tests cover.