Merge pull request #1 from Reiers/feat/fill-missing-node-core

feat: fill missing node core P0 vertical slice

Author: Reiers

cmd/curiocore/main.go

@@ -8,6 +8,7 @@ import (
 	"errors"
 	"flag"
 	"fmt"
+	"net/http"
 	"os"
 	"path/filepath"
 	"strings"
@@ -18,8 +19,10 @@ import (
 	importer "github.com/Reiers/curio-core/internal/import"
 	"github.com/Reiers/curio-core/internal/logging"
 	"github.com/Reiers/curio-core/internal/node"
+	"github.com/Reiers/curio-core/internal/rpc"
 	"github.com/Reiers/curio-core/internal/snapshot"
 	"github.com/Reiers/curio-core/internal/status"
+	"github.com/Reiers/curio-core/internal/store"
 	"github.com/Reiers/curio-core/internal/wallet"
 )
 
@@ -72,6 +75,11 @@ func main() {
 			logger.Errorf("wallet failed: %v", err)
 			os.Exit(1)
 		}
+	case "rpc":
+		if err := cmdRPC(os.Args[2:], logger); err != nil {
+			logger.Errorf("rpc failed: %v", err)
+			os.Exit(1)
+		}
 	default:
 		usage()
 		os.Exit(1)
@@ -89,6 +97,7 @@ func usage() {
 	fmt.Println("  curiocore chain msg --decode <hex|base64> [--explain]")
 	fmt.Println("  curiocore chain coverage-report")
 	fmt.Println("  curiocore wallet new|list|show|export|import|resolve|sign|verify")
+	fmt.Println("  curiocore rpc serve [--listen :1234]")
 	fmt.Println("")
 	fmt.Println("Examples:")
 	fmt.Println("  curiocore doctor --explain")
@@ -334,8 +343,16 @@ func cmdStatus(args []string, log *logging.Logger) error {
 		if err != nil {
 			return err
 		}
+		cs := store.NewChainStore(cfg.NetworkDataDir())
+		head, _ := cs.Head()
 		if *jsonOut {
-			fmt.Println(s.JSON())
+			out := map[string]any{"status": s, "head": head}
+			b, _ := json.Marshal(out)
+			fmt.Println(string(b))
+			return nil
+		}
+		if head != nil {
+			fmt.Printf("stage=%s progress=%d%% height=%d tipset=%s updated=%s message=%s\n", s.Stage, s.Progress, head.Height, head.TipSetKey, s.UpdatedAt.Format(time.RFC3339), s.Message)
 			return nil
 		}
 		fmt.Printf("stage=%s progress=%d%% updated=%s message=%s\n", s.Stage, s.Progress, s.UpdatedAt.Format(time.RFC3339), s.Message)
@@ -357,6 +374,7 @@ func cmdDoctor(args []string, log *logging.Logger) error {
 	dataDir := fs.String("data-dir", defaultHome(), "curiocore home")
 	explain := fs.Bool("explain", false, "explain each check and remediation")
 	jsonOut := fs.Bool("json", false, "json output")
+	postImport := fs.Bool("post-import", false, "run post-import chainstore checks")
 	if err := fs.Parse(args); err != nil {
 		return err
 	}
@@ -365,6 +383,13 @@ func cmdDoctor(args []string, log *logging.Logger) error {
 	if err != nil {
 		return err
 	}
+	if *postImport {
+		post, pErr := doctor.RunPostImport(cfg.NetworkDataDir())
+		if pErr != nil {
+			return pErr
+		}
+		checks = append(checks, post...)
+	}
 	if *jsonOut {
 		b, _ := json.MarshalIndent(checks, "", "  ")
 		fmt.Println(string(b))
@@ -597,6 +622,28 @@ func cmdWallet(args []string, _ *logging.Logger) error {
 	}
 }
 
+func cmdRPC(args []string, log *logging.Logger) error {
+	if len(args) == 0 || args[0] != "serve" {
+		return errors.New("usage: curiocore rpc serve [--listen :1234] [--data-dir ~/.curiocore]")
+	}
+	fs := flag.NewFlagSet("rpc serve", flag.ContinueOnError)
+	listen := fs.String("listen", ":1234", "listen address")
+	dataDir := fs.String("data-dir", defaultHome(), "curiocore home")
+	if err := fs.Parse(args[1:]); err != nil {
+		return err
+	}
+	cfg, err := config.LoadOrDefault(*dataDir)
+	if err != nil {
+		return err
+	}
+	if err := config.InitDirs(cfg); err != nil {
+		return err
+	}
+	srv := rpc.New(cfg)
+	log.Infof("rpc listening on %s", *listen)
+	return http.ListenAndServe(*listen, srv.Handler())
+}
+
 func decodeMessage(v string) ([]byte, string, error) {
 	trim := strings.TrimSpace(v)
 	trim = strings.TrimPrefix(trim, "0x")

docs/alpha2_1-checklist.md

@@ -0,0 +1,60 @@
+# Alpha2.1 Checklist
+
+## Done
+
+- P0: Persistent blockstore introduced (`data/<network>/blockstore/*.blk`)
+- P0: Persistent chainstore with canonical head (`data/<network>/chainstore/head.json`)
+- P0: Snapshot import now materializes chain data into blockstore and commits head/state root
+- P0: Sync vertical slice now advances head incrementally after startup (post-import continuity path)
+- P0: `curiocore status` now reports real chain height from chainstore
+- P0: `curiocore doctor --post-import` checks added:
+  - chain head exists
+  - blockstore populated
+  - state root reachable
+- P1 usability: Minimal RPC surface added:
+  - `/rpc/v0/status`
+  - `/rpc/v0/chain/head`
+  - `/rpc/v0/chain/message/:cid`
+  - `/metrics`
+- Tests added for store, importer, and doctor post-import checks
+
+## What’s next
+
+- Replace incremental sync placeholder with real peer fetch + tipset/header validation pipeline
+- Add bad block cache + fork choice + reorg-safe application path
+- Add real message index for RPC message lookup
+- Add auth model for RPC endpoints
+- Add FVM apply path behind feature flag
+
+## Blocked
+
+- Full consensus/VM parity requires deeper Lotus-compatible validation execution integration
+- High-throughput SP message handling depends on real mempool + network exchange path
+
+## Complexity buckets (effort only)
+
+- **S**
+  - RPC auth middleware (local token mode)
+  - richer metrics labels and counters
+- **M**
+  - bad block cache and fork-choice module
+  - header validation pipeline with persisted checkpoints
+- **L**
+  - full state transition validation parity with Lotus/FVM
+  - production-grade p2p sync and SP traffic handling under reorg stress
+
+## How to verify
+
+1. Initialize and run fast sync/import:
+   - `curiocore init`
+   - `curiocore sync --yes --mode fast`
+2. Verify status contains height:
+   - `curiocore status`
+3. Verify post-import health:
+   - `curiocore doctor --post-import`
+4. Run RPC server:
+   - `curiocore rpc serve --listen :1234`
+5. Query endpoints:
+   - `curl localhost:1234/rpc/v0/status`
+   - `curl localhost:1234/rpc/v0/chain/head`
+   - `curl localhost:1234/metrics`

docs/gap-matrix.md

@@ -0,0 +1,77 @@
+# Curio Core Capability Gap Matrix (vs Lotus / Venus / Forest)
+
+Date: 2026-02-13
+
+Severity rubric:
+- **P0** = cannot sync reliably without it
+- **P1** = required for real-world SP traffic / stability
+- **P2** = can ship later
+
+| Capability | Lotus | Venus | Forest | Curio Core Today | Gap Severity | What we do |
+|---|---|---|---|---|---|---|
+
+## A) Chain Sync
+
+| Capability | Lotus | Venus | Forest | Curio Core Today | Gap Severity | What we do |
+|---|---|---|---|---|---|---|
+| Tipset fetch/validation pipeline | Full staged syncer + manager + validator | Full dispatcher/syncer pipeline | Full task-state-machine sync | Snapshot import + `node.StartSkeleton`; no real fetch/validate loop | **P0** | Implement staged sync pipeline: fetch -> header validate -> persist -> candidate head update |
+| Bad block handling | Built-in bad block cache/policy | Bad tipset tracking | Explicit bad-block policy/cache | None | **P0** | Add bad block cache + rejection gate before persistence |
+| Fork choice | Heaviest-chain with finality guards | Chain selector interfaces | Weight-based with validation gates | None | **P0** | Add weight comparator + head selection interface |
+| Reorg handling | Mature reorg notifications/rollback | Head update with rollback logic | Head update state machine | None | **P0** | Add canonical head update + rollback-safe state transitions |
+| Chain store persistence | Persistent chain + metadata stores | Persistent store/checkpoint/head | Persistent chain store | Only `imported.snapshot.meta` text file | **P0** | Add chain store + blockstore persistence layout |
+| Header vs full validation | Both (staged fast path then full) | Both | Both | No chain validation | **P1** | Add explicit validation stage flags, with header-only bootstrap mode |
+
+## B) State / VM Execution
+
+| Capability | Lotus | Venus | Forest | Curio Core Today | Gap Severity | What we do |
+|---|---|---|---|---|---|---|
+| FVM integration / actor execution | Yes | Yes | Yes (multi-FVM shims) | None | **P0** | Add feature-flagged apply stub with deterministic interfaces for future FVM integration |
+| Message application | Full | Full | Full | Decode helper only | **P0** | Add message decode registry + execution pipeline stubs + coverage reporting |
+| Gas accounting | Full | Full | Full | None | **P1** | Add gas accounting interfaces and test fixtures around message application flow |
+| AMT/HAMT data structures | Full | Full | Full | None | **P1** | Add adapters for AMT/HAMT traversal in state module (Go now; Rust sidecar later) |
+| State tree/CBOR decoding | Full | Full | Full | None | **P0** | Add state root resolver + basic CBOR decode path |
+
+## C) Networking
+
+| Capability | Lotus | Venus | Forest | Curio Core Today | Gap Severity | What we do |
+|---|---|---|---|---|---|---|
+| libp2p host | Yes | Yes | Yes | `network.Supported` only | **P0** | Add minimal libp2p host and peer manager |
+| gossipsub | Yes | Yes | Yes | None | **P1** | Add gossipsub subscription for blocks/messages (initial read-only) |
+| peer scoring | Yes | Yes | Yes | None | **P1** | Add baseline peer scoring config compatible with Lotus defaults |
+| hello/identify/exchange | Yes | Yes | Yes | None | **P0** | Add identify + hello + chain exchange fetch entrypoints |
+| bitswap/blockstore strategy | Yes | Partial | Yes | None | **P1** | Add block fetch strategy integrated with blockstore and backpressure |
+
+## D) Storage
+
+| Capability | Lotus | Venus | Forest | Curio Core Today | Gap Severity | What we do |
+|---|---|---|---|---|---|---|
+| blockstore | Yes | Yes | Yes | No real blockstore | **P0** | Implement persistent blockstore interface + default local backend |
+| chain datastore | Yes | Yes | Yes | No chain datastore | **P0** | Implement chain metadata store (head, tipset index, bad blocks) |
+| snapshot import compatibility (Forest assumptions) | Yes | N/A | Native | Imports bytes only; no chain graph/state wiring | **P0** | Parse imported snapshot into blockstore + set canonical head and state roots |
+| pruning strategy | Mature options | Some options | Modes include stateless patterns | None | **P2** | Defer; design after stable sync correctness |
+
+## E) RPC / API
+
+| Capability | Lotus | Venus | Forest | Curio Core Today | Gap Severity | What we do |
+|---|---|---|---|---|---|---|
+| compatible endpoints (minimal tooling set) | Broad | Broad | Growing | CLI only; no RPC server | **P0** | Add minimal RPC server: status, chain head, message lookup |
+| auth model | Token/JWT style controls | Similar | Present | None | **P1** | Add token auth middleware and local admin-only mode |
+| admin commands | Yes | Yes | Yes | CLI basics only | **P1** | Add RPC admin endpoints for sync controls and diagnostics |
+| metrics endpoint | Yes | Yes | Yes | None | **P1** | Add `/metrics` Prometheus endpoint |
+
+## F) Observability
+
+| Capability | Lotus | Venus | Forest | Curio Core Today | Gap Severity | What we do |
+|---|---|---|---|---|---|---|
+| structured logs | Yes | Yes | Yes | Basic logger | **P1** | Add sync-context fields (peer, tipset, CID, stage) |
+| metrics (prometheus) | Yes | Yes | Yes | None | **P1** | Add sync lag, fetch failures, head height, queue depth metrics |
+| tracing hooks | Partial/varies | Partial/varies | Strong async tracing | None | **P2** | Add OpenTelemetry hooks after core path stabilizes |
+
+## G) Wallet / Signing
+
+| Capability | Lotus | Venus | Forest | Curio Core Today | Gap Severity | What we do |
+|---|---|---|---|---|---|---|
+| f1/f3/f4 complete | Yes | Yes | Yes | Placeholder address/key flows | **P1** | Replace placeholders with real key derivation + validation |
+| f2 resolve | Yes | Yes | Yes | TODO stub | **P1** | Implement on-chain actor resolve via state lookup |
+| keystore security model | Mature | Mature | Mature | Local encrypted JSON (alpha) | **P1** | Harden keystore format, locking, and key material policy |
+| message signing + send flow | Full | Full | Full | Alpha sign/verify placeholders | **P1** | Add real signing + mpool send path once RPC/network path exists |

docs/rust-adoption.md

@@ -0,0 +1,49 @@
+# Curio Core Rust Adoption Decision
+
+Date: 2026-02-13
+
+## Decision
+
+**Choose Option A: Rust sidecar service (recommended), but only for data-plane heavy paths first.**
+
+This is the lowest-risk path that gives real performance upside without destabilizing consensus-critical behavior.
+
+## Where Rust goes first
+
+1. **Snapshot import + CAR parsing**
+   - High CPU/IO pressure
+   - Easy to validate with deterministic outputs
+2. **AMT/HAMT traversal and state decode acceleration**
+   - Hot loops suitable for Rust memory/perf profile
+3. **Block validation acceleration helpers (non-authoritative initially)**
+   - Run as assistive path with parity checks against Go path
+
+## What stays Go now (Lotus parity critical)
+
+- Fork choice and canonical head decision
+- Reorg application semantics
+- Network-version/upgrade policy wiring
+- RPC compatibility surface and operational controls
+- Any authoritative consensus decision until conformance harness is mature
+
+## Safest boundary choice
+
+**Boundary: sidecar over gRPC/IPC**
+
+Why:
+- Clear process isolation and crash containment
+- Versioned contracts and easier rollout/rollback
+- Better observability than raw FFI
+- Avoids GC/ownership complexity and CGO brittleness in consensus hot path
+
+## What we explicitly avoid right now
+
+- No fragile CGO/FFI in the core sync decision loop
+- No language-percentage cargo-cult migration
+- No consensus-authoritative Rust execution cutover before differential parity proof
+
+## Rollout policy
+
+- Start Rust sidecar in shadow/assist mode
+- Compare outputs against Go path
+- Promote functionality only after stable no-diff windows and replay tests

internal/doctor/doctor.go

@@ -1,6 +1,8 @@
 package doctor
 
 import (
+	"encoding/json"
+	"errors"
 	"fmt"
 	"os"
 	"os/exec"
@@ -20,6 +22,11 @@ func Run(homeDir, dataDir string) ([]Check, error) {
 	return checks, nil
 }
 
+func RunPostImport(dataDir string) ([]Check, error) {
+	checks := []Check{checkChainHead(dataDir), checkBlockstorePopulated(dataDir), checkStateRootReachable(dataDir)}
+	return checks, nil
+}
+
 func checkAria2c() Check {
 	if _, err := exec.LookPath("aria2c"); err != nil {
 		return Check{
@@ -59,3 +66,51 @@ func checkWritable(dataDir string) Check {
 	_ = os.Remove(testPath)
 	return Check{Name: "data-dir-writable", OK: true, Message: fmt.Sprintf("data dir is writable: %s", dataDir)}
 }
+
+func checkChainHead(dataDir string) Check {
+	headFile := filepath.Join(dataDir, "chainstore", "head.json")
+	b, err := os.ReadFile(headFile)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return Check{Name: "chain-head-exists", OK: false, Message: "chain head missing", Fix: "Re-run snapshot import and ensure head is committed"}
+		}
+		return Check{Name: "chain-head-exists", OK: false, Message: err.Error(), Fix: "Inspect chainstore/head.json permissions"}
+	}
+	if len(b) == 0 {
+		return Check{Name: "chain-head-exists", OK: false, Message: "chain head file empty", Fix: "Re-import snapshot"}
+	}
+	return Check{Name: "chain-head-exists", OK: true, Message: "chain head exists"}
+}
+
+func checkBlockstorePopulated(dataDir string) Check {
+	dir := filepath.Join(dataDir, "blockstore")
+	ents, err := os.ReadDir(dir)
+	if err != nil {
+		return Check{Name: "blockstore-populated", OK: false, Message: "blockstore missing", Fix: "Re-run snapshot import"}
+	}
+	if len(ents) == 0 {
+		return Check{Name: "blockstore-populated", OK: false, Message: "blockstore empty", Fix: "Re-run snapshot import"}
+	}
+	return Check{Name: "blockstore-populated", OK: true, Message: fmt.Sprintf("blockstore contains %d blocks", len(ents))}
+}
+
+func checkStateRootReachable(dataDir string) Check {
+	headFile := filepath.Join(dataDir, "chainstore", "head.json")
+	b, err := os.ReadFile(headFile)
+	if err != nil {
+		return Check{Name: "state-root-reachable", OK: false, Message: "chain head unavailable", Fix: "Re-run snapshot import"}
+	}
+	var h struct {
+		StateRoot string `json:"stateRoot"`
+	}
+	if err := json.Unmarshal(b, &h); err != nil {
+		return Check{Name: "state-root-reachable", OK: false, Message: "invalid head format", Fix: "Re-run snapshot import with latest binary"}
+	}
+	if h.StateRoot == "" {
+		return Check{Name: "state-root-reachable", OK: false, Message: "state root missing", Fix: "Import a snapshot containing state root metadata"}
+	}
+	if _, err := os.Stat(filepath.Join(dataDir, "blockstore", h.StateRoot+".blk")); err != nil {
+		return Check{Name: "state-root-reachable", OK: false, Message: "state root block not found in blockstore", Fix: "Re-run import to rebuild blockstore"}
+	}
+	return Check{Name: "state-root-reachable", OK: true, Message: "state root reachable"}
+}