Add bitwrap -validate: full .btw → Solidity → forge → anvil pipeline

New CLI flag validates a .btw DSL file through the complete pipeline:
  parse → build schema → generate Solidity + tests → forge build →
  forge test → deploy to anvil

Usage:
  ./bitwrap -validate path/to/file.btw
  make validate BTW=path/to/file.btw

Also fixes DSL parser to handle nested map types like
map[address]map[address]uint256 (recursive parseTypeString).

Includes examples/erc20.btw as a working reference that passes
full validation including deployment.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: stackdump

Makefile

@@ -1,4 +1,4 @@
-.PHONY: build run test test-e2e test-playwright clean wasm
+.PHONY: build run test test-e2e test-playwright validate clean wasm
 
 PORT ?= 8088
 
@@ -18,6 +18,9 @@ test:
 test-e2e:
 	go test -tags e2e -timeout 600s -v ./internal/server/ -run TestFoundryE2E
 
+validate: build
+	./bitwrap -validate $(BTW)
+
 test-playwright:
 	cd e2e && npm install --silent && npx playwright install chromium 2>/dev/null; cd e2e && npx playwright test
 

cmd/bitwrap/main.go

@@ -5,13 +5,19 @@ import (
 	"flag"
 	"fmt"
 	"log"
+	"net"
 	"net/http"
 	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
 
 	"github.com/stackdump/bitwrap-io/dsl"
 	"github.com/stackdump/bitwrap-io/internal/server"
 	"github.com/stackdump/bitwrap-io/public"
 	"github.com/stackdump/bitwrap-io/internal/store"
+	"github.com/stackdump/bitwrap-io/solidity"
 )
 
 func main() {
@@ -21,6 +27,7 @@ func main() {
 	noSolgen := flag.Bool("no-solgen", false, "Disable Solidity generation endpoints")
 	keyDir := flag.String("key-dir", "", "Directory for persistent circuit keys (enables fast restarts)")
 	compile := flag.String("compile", "", "Compile a .btw file and output JSON schema to stdout")
+	validate := flag.String("validate", "", "Validate a .btw file: compile → generate Solidity → forge build → forge test → deploy")
 	flag.Parse()
 
 	if *compile != "" {
@@ -44,6 +51,10 @@ func main() {
 		return
 	}
 
+	if *validate != "" {
+		os.Exit(runValidate(*validate))
+	}
+
 	storage := store.NewFSStore(*dataDir)
 
 	publicFS, err := public.FS()
@@ -70,3 +81,149 @@ func main() {
 		log.Fatalf("Server failed: %v", err)
 	}
 }
+
+// runValidate compiles a .btw file through the full pipeline:
+// parse → build schema → generate Solidity + tests → forge build → forge test → deploy to anvil
+func runValidate(path string) int {
+	src, err := os.ReadFile(path)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "FAIL: read %s: %v\n", path, err)
+		return 1
+	}
+
+	// Step 1: Parse DSL
+	fmt.Printf("● parse %s\n", path)
+	ast, err := dsl.Parse(string(src))
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "FAIL: parse: %v\n", err)
+		return 1
+	}
+
+	// Step 2: Build metamodel schema
+	fmt.Printf("● build schema: %s\n", ast.Name)
+	schema, err := dsl.Build(ast)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "FAIL: build: %v\n", err)
+		return 1
+	}
+	fmt.Printf("  states: %d, actions: %d, arcs: %d\n",
+		len(schema.States), len(schema.Actions), len(schema.InputArcs(""))+len(schema.OutputArcs("")))
+
+	// Step 3: Generate Solidity
+	contractName := solidity.ContractName(schema.Name)
+	contractCode := solidity.Generate(schema)
+	testCode := solidity.GenerateTests(schema)
+	genesisCode := solidity.GenerateGenesis(schema.Name, solidity.GenesisConfig{}, solidity.DefaultAddresses())
+	fmt.Printf("● generate Solidity: %s.sol (%d bytes)\n", contractName, len(contractCode))
+	fmt.Printf("  tests: %sTest.t.sol (%d bytes)\n", contractName, len(testCode))
+	fmt.Printf("  genesis: %sGenesis.s.sol (%d bytes)\n", contractName, len(genesisCode))
+
+	// Step 4: Check for forge
+	if _, err := exec.LookPath("forge"); err != nil {
+		fmt.Printf("● forge not installed — skipping compilation and deployment\n")
+		fmt.Printf("PASS (parse + generate only)\n")
+		return 0
+	}
+
+	// Step 5: Set up temp Foundry project
+	dir, err := os.MkdirTemp("", "bitwrap-validate-*")
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "FAIL: tmpdir: %v\n", err)
+		return 1
+	}
+	defer os.RemoveAll(dir)
+
+	for _, sub := range []string{"src", "test", "script"} {
+		os.MkdirAll(filepath.Join(dir, sub), 0o755)
+	}
+
+	foundryToml := "[profile.default]\nsrc = \"src\"\nout = \"out\"\nlibs = [\"lib\"]\nsolc_version = \"0.8.20\"\n"
+	os.WriteFile(filepath.Join(dir, "foundry.toml"), []byte(foundryToml), 0o644)
+	os.WriteFile(filepath.Join(dir, "src", contractName+".sol"), []byte(contractCode), 0o644)
+	os.WriteFile(filepath.Join(dir, "test", contractName+"Test.t.sol"), []byte(testCode), 0o644)
+	os.WriteFile(filepath.Join(dir, "script", contractName+"Genesis.s.sol"), []byte(genesisCode), 0o644)
+
+	// Step 6: Install forge-std
+	if !runStep(dir, "install forge-std", "git", "init") {
+		return 1
+	}
+	if !runStep(dir, "install forge-std", "forge", "install", "foundry-rs/forge-std") {
+		return 1
+	}
+
+	// Step 7: Compile
+	if !runStep(dir, "forge build", "forge", "build") {
+		return 1
+	}
+
+	// Step 8: Test
+	if !runStep(dir, "forge test", "forge", "test", "-vv") {
+		return 1
+	}
+
+	// Step 9: Deploy to anvil
+	if _, err := exec.LookPath("anvil"); err != nil {
+		fmt.Printf("● anvil not installed — skipping deployment\n")
+		fmt.Printf("PASS\n")
+		return 0
+	}
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "FAIL: find free port: %v\n", err)
+		return 1
+	}
+	port := listener.Addr().(*net.TCPAddr).Port
+	listener.Close()
+
+	rpcURL := fmt.Sprintf("http://127.0.0.1:%d", port)
+	anvil := exec.Command("anvil", "--port", fmt.Sprintf("%d", port), "--silent")
+	if err := anvil.Start(); err != nil {
+		fmt.Fprintf(os.Stderr, "FAIL: start anvil: %v\n", err)
+		return 1
+	}
+	defer func() { anvil.Process.Kill(); anvil.Wait() }()
+
+	// Wait for anvil
+	for i := 0; i < 50; i++ {
+		cmd := exec.Command("cast", "chain-id", "--rpc-url", rpcURL)
+		if out, err := cmd.CombinedOutput(); err == nil && strings.TrimSpace(string(out)) == "31337" {
+			break
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+
+	privKey := "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
+	createArgs := []string{"create", fmt.Sprintf("src/%s.sol:%s", contractName, contractName),
+		"--rpc-url", rpcURL, "--private-key", privKey, "--broadcast"}
+
+	cmd := exec.Command("forge", createArgs...)
+	cmd.Dir = dir
+	out, err := cmd.CombinedOutput()
+	if err != nil || !strings.Contains(string(out), "Deployed to:") {
+		fmt.Fprintf(os.Stderr, "● deploy FAIL\n%s\n", out)
+		return 1
+	}
+
+	// Extract address
+	for _, line := range strings.Split(string(out), "\n") {
+		if strings.Contains(line, "Deployed to:") {
+			fmt.Printf("● deploy: %s\n", strings.TrimSpace(line))
+		}
+	}
+
+	fmt.Printf("PASS\n")
+	return 0
+}
+
+func runStep(dir, label, name string, args ...string) bool {
+	fmt.Printf("● %s\n", label)
+	cmd := exec.Command(name, args...)
+	cmd.Dir = dir
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "FAIL: %s\n%s\n", label, out)
+		return false
+	}
+	return true
+}

dsl/parser.go

@@ -207,7 +207,8 @@ func (p *Parser) parseRegister() (Register, error) {
 	}, nil
 }
 
-// parseTypeString reads a type like "uint256" or "map[address]uint256".
+// parseTypeString reads a type like "uint256", "map[address]uint256",
+// or nested maps like "map[address]map[address]uint256".
 func (p *Parser) parseTypeString() (string, error) {
 	tok := p.advance()
 	if tok.Type != TokenIdent {
@@ -225,11 +226,12 @@ func (p *Parser) parseTypeString() (string, error) {
 		if _, err := p.expect(TokenRBracket); err != nil {
 			return "", err
 		}
-		valTok, err := p.expect(TokenIdent)
+		// Value type can itself be a map (recursive) or a simple ident
+		valType, err := p.parseTypeString()
 		if err != nil {
 			return "", err
 		}
-		result += "[" + keyTok.Value + "]" + valTok.Value
+		result += "[" + keyTok.Value + "]" + valType
 		return result, nil
 	}
 

examples/erc20.btw

@@ -0,0 +1,58 @@
+schema ERC20 {
+  version "1.0.0"
+  domain "custody"
+  asset "erc20"
+
+  register BALANCES map[address]uint256 observable
+  register TOTAL_SUPPLY uint256
+
+  event TransferEvent {
+    from: address indexed
+    to: address indexed
+    amount: uint256
+  }
+
+  event MintEvent {
+    to: address indexed
+    amount: uint256
+  }
+
+  event BurnEvent {
+    from: address indexed
+    amount: uint256
+  }
+
+  fn(transfer) {
+    var from address
+    var to address
+    var amount amount
+
+    require(BALANCES[from] >= amount && to != address(0))
+    @event TransferEvent
+
+    BALANCES[from] -|amount|> transfer
+    transfer -|amount|> BALANCES[to]
+  }
+
+  fn(mint) {
+    var to address
+    var amount amount
+
+    require(to != address(0))
+    @event MintEvent
+
+    mint -|amount|> BALANCES[to]
+    mint -|amount|> TOTAL_SUPPLY
+  }
+
+  fn(burn) {
+    var from address
+    var amount amount
+
+    require(BALANCES[from] >= amount)
+    @event BurnEvent
+
+    BALANCES[from] -|amount|> burn
+    TOTAL_SUPPLY -|amount|> burn
+  }
+}