mirror of
https://github.com/hanzoai/bootnode.git
synced 2026-10-25 02:31:30 +00:00
zeekayandGitHub
97321f67b0
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).
74 lines
2.4 KiB
Go
74 lines
2.4 KiB
Go
// Package store is the per-tenant persistence layer. Every method
|
|
// takes an orgID and resolves the per-org SQLite handle via
|
|
// deps.Base.Open(ctx, orgID, "bootnode") per HIP-0302.
|
|
//
|
|
// TODO(bootnode-port): when deps.Base lands as a typed client
|
|
// (`basezap.Client`), the `any` here becomes the typed handle and
|
|
// these methods grow real CRUD bodies.
|
|
package store
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
|
|
bootnodezap "github.com/hanzoai/bootnode/zap/gen"
|
|
)
|
|
|
|
// BaseClient is the per-tenant SQLite opener (HIP-0302).
|
|
type BaseClient interface {
|
|
Open(ctx context.Context, orgID, namespace string) (any, error)
|
|
}
|
|
|
|
// APIKeyStore persists API keys + projects. Production stores bcrypt
|
|
// hashes, never plaintext (Hanzo CLAUDE.md hard rule).
|
|
type APIKeyStore struct {
|
|
base BaseClient
|
|
}
|
|
|
|
// NewAPIKeyStore builds the per-tenant API-key store.
|
|
func NewAPIKeyStore(b BaseClient) *APIKeyStore { return &APIKeyStore{base: b} }
|
|
|
|
// ErrNotFound is returned when a row does not exist.
|
|
var ErrNotFound = errors.New("store: not found")
|
|
|
|
// Create writes a new API key row, hashing the plaintext with bcrypt
|
|
// before persistence.
|
|
//
|
|
// TODO(bootnode-port): port from bootnode/api/auth_keys.py:create_api_key —
|
|
// use golang.org/x/crypto/bcrypt.GenerateFromPassword with cost 12.
|
|
func (s *APIKeyStore) Create(ctx context.Context, k bootnodezap.APIKey, plaintext string) error {
|
|
_ = ctx
|
|
_ = k
|
|
_ = plaintext
|
|
return errors.New("store.APIKeyStore.Create: not implemented")
|
|
}
|
|
|
|
// List returns every API key for an org.
|
|
//
|
|
// TODO(bootnode-port): port from bootnode/api/auth_keys.py:list_api_keys
|
|
func (s *APIKeyStore) List(ctx context.Context, orgID string) ([]bootnodezap.APIKey, error) {
|
|
_ = ctx
|
|
_ = orgID
|
|
return nil, errors.New("store.APIKeyStore.List: not implemented")
|
|
}
|
|
|
|
// Revoke marks an API key as deleted (soft-delete to preserve audit).
|
|
//
|
|
// TODO(bootnode-port): port from bootnode/api/auth_keys.py:delete_api_key
|
|
func (s *APIKeyStore) Revoke(ctx context.Context, orgID, id string) error {
|
|
_ = ctx
|
|
_ = orgID
|
|
_ = id
|
|
return errors.New("store.APIKeyStore.Revoke: not implemented")
|
|
}
|
|
|
|
// VerifyPlaintext bcrypt-compares the supplied plaintext against the
|
|
// stored hash. Returns ErrNotFound if no row matches.
|
|
//
|
|
// TODO(bootnode-port): port from bootnode/api/auth_keys.py:verify_key
|
|
func (s *APIKeyStore) VerifyPlaintext(ctx context.Context, plaintext string) (bootnodezap.APIKey, error) {
|
|
_ = ctx
|
|
_ = plaintext
|
|
return bootnodezap.APIKey{}, ErrNotFound
|
|
}
|