mirror of
https://github.com/hanzoai/bootnode.git
synced 2026-10-25 02:31:30 +00:00
zeekayandGitHub
fb40f6f924
Adds a Go subsystem alongside the existing Python FastAPI service so
bootnode can fold into `superbase` per HIP-0106. The Python service in
`api/bootnode/` stays untouched.
What landed:
- `schema/bootnode.zap` — public typed surface (chains, RPC, tokens,
NFTs, transfers, smart wallets, ERC-4337, gas, webhooks, fleets,
nodes, usage). No `.capnp` anywhere — ZAP only, per brand policy.
- `zap/gen/` — hand-rolled Go bindings that match what `zapc generate`
emits, so `go build` works without zapc installed locally.
- `api/mount.go` — the HIP-0106 contract:
func Mount(r chi.Router, deps Deps) error
mounts every FastAPI-parity route group through `api/handlers/`.
- `api/deps.go` — cross-subsystem ZAP client interfaces (IAM, KMS,
Base, O11y, Commerce). No business logic, no hard imports — keeps
the Bootnode module independent of sibling subsystems until they
ship their typed clients.
- `api/handlers/` — 149 chi routes mounted (Python has 150). Each
handler body is a 501 stub with a `TODO(bootnode-port)` pointing at
the Python file + symbol to port.
- `api/middleware/` — IAM-backed auth, OTEL-friendly telemetry,
per-org rate limit (stub).
- `api/store/` — per-tenant SQLite access via `deps.Base.Open(orgID,
"bootnode")` per HIP-0302.
- `api/web3/` — chain registry + RPC pool surface (production version
prefers luxfi/* over upstream go-ethereum).
- `cmd/bootnode/main.go` — standalone shim; same `api.Mount` superbase
calls in production.
- `docs/PYTHON_TO_GO_PORT.md` — endpoint-by-endpoint port map.
Build: `go build ./...` and `go vet ./...` clean. Standalone shim
smokes 200 on /health, /ready, /v1/chains; 401 on auth-required
endpoints with no JWT; 501 on every TODO route.
Out of scope (not in this commit):
- Handler bodies (Phase 2 — porting in RPC → tokens → NFTs → ...
priority order).
- superbase wiring (lands when the superbase repo opens its main).
- Python service removal (stays until handlers reach prod parity).
69 lines
1.5 KiB
Go
69 lines
1.5 KiB
Go
package middleware
|
|
|
|
import (
|
|
"net/http"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// RateLimit is a per-org sliding-window limiter. It exists as a stub
|
|
// so handlers can compose it today; the production version reads
|
|
// per-org rate limits from the api_keys table via deps.Base.
|
|
//
|
|
// TODO(bootnode-port): replace with the FastAPI rate-limit equivalent
|
|
// (Redis token bucket via deps.MQ or in-process LRU). See
|
|
// api/bootnode/api/deps.py:rate_limit.
|
|
type RateLimit struct {
|
|
mu sync.Mutex
|
|
buckets map[string]*bucket
|
|
limit int
|
|
window time.Duration
|
|
}
|
|
|
|
type bucket struct {
|
|
tokens int
|
|
resetAt time.Time
|
|
}
|
|
|
|
// NewRateLimit creates a per-key limiter (limit requests / window).
|
|
func NewRateLimit(limit int, window time.Duration) *RateLimit {
|
|
return &RateLimit{
|
|
buckets: make(map[string]*bucket),
|
|
limit: limit,
|
|
window: window,
|
|
}
|
|
}
|
|
|
|
// Wrap returns a chi middleware that keys off the org slug attached
|
|
// to the request context.
|
|
func (rl *RateLimit) Wrap(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
key := OrgID(r.Context())
|
|
if key == "" {
|
|
key = r.RemoteAddr
|
|
}
|
|
if !rl.allow(key) {
|
|
http.Error(w, "rate limited", http.StatusTooManyRequests)
|
|
return
|
|
}
|
|
next.ServeHTTP(w, r)
|
|
})
|
|
}
|
|
|
|
func (rl *RateLimit) allow(key string) bool {
|
|
rl.mu.Lock()
|
|
defer rl.mu.Unlock()
|
|
|
|
now := time.Now()
|
|
b, ok := rl.buckets[key]
|
|
if !ok || now.After(b.resetAt) {
|
|
rl.buckets[key] = &bucket{tokens: rl.limit - 1, resetAt: now.Add(rl.window)}
|
|
return true
|
|
}
|
|
if b.tokens <= 0 {
|
|
return false
|
|
}
|
|
b.tokens--
|
|
return true
|
|
}
|