feat(runner): Solidity & Flow EVM support

.gitignore

@@ -46,3 +46,4 @@ runner/public/*.wasm
 !runner/public/codegen-wasm_exec.js
 skills/.registry.json
 .superpowers/
+.nx/

ai/chat/Dockerfile

@@ -4,7 +4,7 @@ RUN npm install -g bun
 WORKDIR /app
 
 # Workspace root config + lockfile
-COPY package.json bun.lock ./
+COPY package.json bun.lock nx.json ./
 
 # Shared monorepo packages (needed for workspace:* resolution)
 COPY packages/ ./packages/
@@ -18,11 +18,8 @@ RUN node -e "const p=require('./package.json');p.workspaces=['packages/*','ai/ch
 # Install all workspace deps
 RUN cd ai/chat/web && bun install
 
-# Build shared packages (generate dist/ via tsup)
-RUN cd packages/flow-passkey && bun run build \
- && cd ../auth-core && bun run build \
- && cd ../flowtoken && bun run build \
- && cd ../flow-ui && bun run build
+# Build shared packages (nx resolves dependency order via tag:package)
+RUN npx nx run-many -t build --projects=tag:package
 
 # Copy app source and build
 COPY ai/chat/web/ ./ai/chat/web/

ai/chat/web/app/api/runner-chat/route.ts

@@ -12,6 +12,8 @@ import { buildSkillsPrompt, createLoadSkillTool } from "@/lib/skills";
 
 const CADENCE_MCP_URL =
   process.env.CADENCE_MCP_URL || "https://cadence-mcp.up.railway.app/mcp";
+const FLOW_EVM_MCP_URL =
+  process.env.FLOW_EVM_MCP_URL || "https://flow-evm-mcp.up.railway.app/mcp";
 
 // Mode -> model + thinking config (mirrors main chat)
 const MODE_CONFIG = {
@@ -166,8 +168,8 @@ const walletTools = {
   }),
 };
 
-const SYSTEM_PROMPT = `You are a Cadence programming assistant embedded in Cadence Runner.
-Your primary job is to help users write, edit, and debug Cadence smart contract code for Flow.
+const SYSTEM_PROMPT = `You are a Cadence & Solidity programming assistant embedded in Cadence Runner.
+Your primary job is to help users write, edit, and debug smart contract code for Flow — both Cadence and Solidity (Flow EVM).
 
 ## CRITICAL: Always use editor tools for code changes
 
@@ -223,6 +225,16 @@ Always call \`get_wallet_info\` first to check if a signer is available before a
   - FlowToken: 0x1654653399040a61
   - FUSD: 0x3c5959b568896393
 
+## Solidity / Flow EVM guidelines
+
+- Flow EVM is a full EVM environment on Flow — Solidity contracts deploy and run natively.
+- Flow EVM Mainnet chain ID: 747, Testnet chain ID: 545.
+- Use \`pragma solidity ^0.8.24;\` or later. The runner bundles solc 0.8.24.
+- .sol files compile client-side via solc WASM. When an EVM wallet is connected, contracts auto-deploy.
+- After deployment, the Interact tab lets users call read/write functions on the deployed contract.
+- You have Flow EVM MCP tools to query on-chain EVM data (balances, transactions, contracts, tokens, etc.).
+- For cross-VM patterns, users can call Solidity contracts from Cadence via \`EVM.run()\`.
+
 Keep responses concise and implementation-focused.${buildSkillsPrompt()}`;
 
 function sanitizeProjectFiles(files?: RunnerProjectFile[]): RunnerProjectFile[] {
@@ -305,12 +317,16 @@ export async function POST(req: Request) {
     projectFiles: sanitizeProjectFiles(projectFiles),
   })}`;
 
-  const cadenceMcp = await safeMcpTools(CADENCE_MCP_URL);
+  const [cadenceMcp, flowEvmMcp] = await Promise.all([
+    safeMcpTools(CADENCE_MCP_URL),
+    safeMcpTools(FLOW_EVM_MCP_URL),
+  ]);
 
   const allTools = {
     ...editorTools,
     ...walletTools,
     ...cadenceMcp.tools,
+    ...flowEvmMcp.tools,
     loadSkill: createLoadSkillTool(),
   };
 
@@ -340,7 +356,10 @@ export async function POST(req: Request) {
     tools: allTools,
     stopWhen: stepCountIs(10),
     onFinish: async () => {
-      await cadenceMcp.client?.close();
+      await Promise.all([
+        cadenceMcp.client?.close(),
+        flowEvmMcp.client?.close(),
+      ]);
     },
   });
 

backend/internal/api/blockscout_proxy.go

@@ -17,6 +17,14 @@ func (s *Server) proxyBlockscout(w http.ResponseWriter, r *http.Request, upstrea
 	if q := r.URL.RawQuery; q != "" {
 		target += "?" + q
 	}
+	// Append API key for rate limit bypass
+	if s.blockscoutAPIKey != "" {
+		sep := "?"
+		if r.URL.RawQuery != "" {
+			sep = "&"
+		}
+		target += sep + "apikey=" + s.blockscoutAPIKey
+	}
 
 	req, err := http.NewRequestWithContext(r.Context(), http.MethodGet, target, nil)
 	if err != nil {

backend/internal/api/routes_registration.go

@@ -179,9 +179,18 @@ func registerFlowRoutes(r *mux.Router, s *Server) {
 	r.HandleFunc("/flow/contract/{identifier}/{id}", s.handleFlowGetContractVersion).Methods("GET", "OPTIONS")
 	r.HandleFunc("/flow/evm/transaction", s.handleFlowListEVMTransactions).Methods("GET", "OPTIONS")
 	r.HandleFunc("/flow/evm/transaction/{hash}", s.handleFlowGetEVMTransaction).Methods("GET", "OPTIONS")
+	r.HandleFunc("/flow/evm/transaction/{hash}/internal-transactions", s.handleFlowGetEVMTransactionInternalTxs).Methods("GET", "OPTIONS")
+	r.HandleFunc("/flow/evm/transaction/{hash}/logs", s.handleFlowGetEVMTransactionLogs).Methods("GET", "OPTIONS")
+	r.HandleFunc("/flow/evm/transaction/{hash}/token-transfers", s.handleFlowGetEVMTransactionTokenTransfers).Methods("GET", "OPTIONS")
 	r.HandleFunc("/flow/evm/token", s.handleFlowListEVMTokens).Methods("GET", "OPTIONS")
 	r.HandleFunc("/flow/evm/token/{address}", s.handleFlowGetEVMToken).Methods("GET", "OPTIONS")
 	r.HandleFunc("/flow/evm/address/{address}/token", s.handleFlowGetEVMAddressTokens).Methods("GET", "OPTIONS")
+	r.HandleFunc("/flow/evm/address/{address}/nft", s.handleFlowGetEVMAddressNFTs).Methods("GET", "OPTIONS")
+	r.HandleFunc("/flow/evm/address/{address}/transactions", s.handleFlowGetEVMAddressTransactions).Methods("GET", "OPTIONS")
+	r.HandleFunc("/flow/evm/address/{address}/internal-transactions", s.handleFlowGetEVMAddressInternalTxs).Methods("GET", "OPTIONS")
+	r.HandleFunc("/flow/evm/address/{address}/token-transfers", s.handleFlowGetEVMAddressTokenTransfers).Methods("GET", "OPTIONS")
+	r.HandleFunc("/flow/evm/address/{address}", s.handleFlowGetEVMAddress).Methods("GET", "OPTIONS")
+	r.HandleFunc("/flow/evm/search", cachedHandler(30*time.Second, s.handleFlowEVMSearch)).Methods("GET", "OPTIONS")
 	r.HandleFunc("/flow/node", s.handleListNodes).Methods("GET", "OPTIONS")
 	r.HandleFunc("/flow/node/{node_id}", s.handleGetNode).Methods("GET", "OPTIONS")
 	r.HandleFunc("/flow/node/{node_id}/reward/delegation", s.handleNotImplemented).Methods("GET", "OPTIONS")
@@ -194,6 +203,7 @@ func registerFlowRoutes(r *mux.Router, s *Server) {
 	r.HandleFunc("/flow/coa/{address}", s.handleGetCOAMapping).Methods("GET", "OPTIONS")
 	r.HandleFunc("/flow/account/{address}/labels", s.handleFlowAccountLabels).Methods("GET", "OPTIONS")
 	r.HandleFunc("/flow/search", cachedHandler(30*time.Second, s.handleSearch)).Methods("GET", "OPTIONS")
+	r.HandleFunc("/flow/search/preview", s.handleSearchPreview).Methods("GET", "OPTIONS")
 }
 
 func registerAccountingRoutes(r *mux.Router, s *Server) {

backend/internal/api/routes_test.go

@@ -92,12 +92,23 @@ var specExcludedRoutes = map[string]bool{
 	// Alias: /contract/{id}/version/{id} same as /contract/{id}/{id}
 	"/flow/contract/{identifier}/version/{id}": true,
 	// Analytics aliases (content blockers block "analytics")
-	"/analytics/daily": true,
-	"/analytics/daily/module/{module}":   true,
-	"/analytics/transfers/daily":         true,
-	"/analytics/big-transfers":           true,
-	"/analytics/top-contracts":           true,
-	"/analytics/token-volume":            true,
+	"/analytics/daily":                  true,
+	"/analytics/daily/module/{module}":  true,
+	"/analytics/transfers/daily":        true,
+	"/analytics/big-transfers":          true,
+	"/analytics/top-contracts":          true,
+	"/analytics/token-volume":           true,
+	// EVM proxy routes (proxied to Blockscout, not our own API)
+	"/flow/evm/transaction/{hash}/internal-transactions": true,
+	"/flow/evm/transaction/{hash}/logs":                  true,
+	"/flow/evm/transaction/{hash}/token-transfers":       true,
+	"/flow/evm/address/{address}/transactions":           true,
+	"/flow/evm/address/{address}/internal-transactions":  true,
+	"/flow/evm/address/{address}/token-transfers":        true,
+	"/flow/evm/address/{address}":                        true,
+	"/flow/evm/address/{address}/nft":                    true,
+	"/flow/evm/search":                                   true,
+	"/flow/search/preview":                               true,
 }
 
 // TestAllRoutesInSpec ensures every registered public route has an OpenAPI spec entry.

backend/internal/api/server_bootstrap.go

@@ -126,6 +126,7 @@ type Server struct {
 	httpServer         *http.Server
 	startBlock         uint64
 	blockscoutURL      string // e.g. "https://evm.flowindex.dev"
+	blockscoutAPIKey   string // optional API key for Blockscout rate limit bypass
 	backfillProgress   *BackfillProgress
 	priceCache         *market.PriceCache
 	webhookHandlers      WebhookRouteRegistrar
@@ -162,7 +163,8 @@ func NewServer(repo *repository.Repository, client FlowClient, port string, star
 		repo:          repo,
 		client:        client,
 		startBlock:    startBlock,
-		blockscoutURL: bsURL,
+		blockscoutURL:    bsURL,
+		blockscoutAPIKey: os.Getenv("BLOCKSCOUT_API_KEY"),
 		priceCache:    market.NewPriceCache(),
 	}
 	for _, opt := range opts {

backend/internal/api/v1_handlers_evm.go

@@ -1,6 +1,9 @@
 package api
 
 import (
+	"encoding/json"
+	"io"
+	"log"
 	"net/http"
 	"strings"
 
@@ -35,3 +38,108 @@ func (s *Server) handleFlowGetEVMToken(w http.ResponseWriter, r *http.Request) {
 	}
 	s.proxyBlockscout(w, r, "/api/v2/tokens/0x"+address)
 }
+
+func (s *Server) handleFlowGetEVMTransactionInternalTxs(w http.ResponseWriter, r *http.Request) {
+	hash := strings.ToLower(strings.TrimPrefix(mux.Vars(r)["hash"], "0x"))
+	s.proxyBlockscout(w, r, "/api/v2/transactions/0x"+hash+"/internal-transactions")
+}
+
+func (s *Server) handleFlowGetEVMTransactionLogs(w http.ResponseWriter, r *http.Request) {
+	hash := strings.ToLower(strings.TrimPrefix(mux.Vars(r)["hash"], "0x"))
+	s.proxyBlockscout(w, r, "/api/v2/transactions/0x"+hash+"/logs")
+}
+
+func (s *Server) handleFlowGetEVMTransactionTokenTransfers(w http.ResponseWriter, r *http.Request) {
+	hash := strings.ToLower(strings.TrimPrefix(mux.Vars(r)["hash"], "0x"))
+	s.proxyBlockscout(w, r, "/api/v2/transactions/0x"+hash+"/token-transfers")
+}
+
+func (s *Server) handleFlowGetEVMAddressNFTs(w http.ResponseWriter, r *http.Request) {
+	address := normalizeAddr(mux.Vars(r)["address"])
+	s.proxyBlockscout(w, r, "/api/v2/addresses/0x"+address+"/nft")
+}
+
+func (s *Server) handleFlowGetEVMAddress(w http.ResponseWriter, r *http.Request) {
+	addr := normalizeAddr(mux.Vars(r)["address"])
+
+	// Build upstream request manually so we can read + enrich the response body.
+	target := s.blockscoutURL + "/api/v2/addresses/0x" + addr
+	if q := r.URL.RawQuery; q != "" {
+		target += "?" + q
+	}
+	if s.blockscoutAPIKey != "" {
+		sep := "?"
+		if strings.Contains(target, "?") {
+			sep = "&"
+		}
+		target += sep + "apikey=" + s.blockscoutAPIKey
+	}
+
+	req, err := http.NewRequestWithContext(r.Context(), http.MethodGet, target, nil)
+	if err != nil {
+		writeAPIError(w, http.StatusInternalServerError, "failed to build upstream request")
+		return
+	}
+	req.Header.Set("Accept", "application/json")
+
+	resp, err := blockscoutClient.Do(req)
+	if err != nil {
+		log.Printf("blockscout proxy error: %v", err)
+		writeAPIError(w, http.StatusBadGateway, "upstream blockscout unavailable")
+		return
+	}
+	defer resp.Body.Close()
+
+	// Non-200: stream through unchanged.
+	if resp.StatusCode != http.StatusOK {
+		w.Header().Set("Content-Type", resp.Header.Get("Content-Type"))
+		w.WriteHeader(resp.StatusCode)
+		io.Copy(w, resp.Body)
+		return
+	}
+
+	// Read full body for potential enrichment.
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		writeAPIError(w, http.StatusBadGateway, "failed to read upstream response")
+		return
+	}
+
+	// Attempt COA enrichment; any failure falls through to returning original body.
+	enriched := false
+	if coaRow, coaErr := s.repo.GetFlowAddressByCOA(r.Context(), addr); coaErr == nil && coaRow != nil {
+		var data map[string]interface{}
+		if jsonErr := json.Unmarshal(body, &data); jsonErr == nil {
+			data["flow_address"] = "0x" + coaRow.FlowAddress
+			data["is_coa"] = true
+			if out, marshalErr := json.Marshal(data); marshalErr == nil {
+				body = out
+				enriched = true
+			}
+		}
+	}
+	_ = enriched // not needed further; kept for clarity
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+	w.Write(body)
+}
+
+func (s *Server) handleFlowGetEVMAddressTransactions(w http.ResponseWriter, r *http.Request) {
+	addr := normalizeAddr(mux.Vars(r)["address"])
+	s.proxyBlockscout(w, r, "/api/v2/addresses/0x"+addr+"/transactions")
+}
+
+func (s *Server) handleFlowGetEVMAddressInternalTxs(w http.ResponseWriter, r *http.Request) {
+	addr := normalizeAddr(mux.Vars(r)["address"])
+	s.proxyBlockscout(w, r, "/api/v2/addresses/0x"+addr+"/internal-transactions")
+}
+
+func (s *Server) handleFlowGetEVMAddressTokenTransfers(w http.ResponseWriter, r *http.Request) {
+	addr := normalizeAddr(mux.Vars(r)["address"])
+	s.proxyBlockscout(w, r, "/api/v2/addresses/0x"+addr+"/token-transfers")
+}
+
+func (s *Server) handleFlowEVMSearch(w http.ResponseWriter, r *http.Request) {
+	s.proxyBlockscout(w, r, "/api/v2/search")
+}