114 lines
4.3 KiB
Go
114 lines
4.3 KiB
Go
package rest
|
|
|
|
import (
|
|
"net/http"
|
|
"os"
|
|
"strings"
|
|
|
|
"github.com/explorer/backend/api/middleware"
|
|
"github.com/explorer/backend/api/track1"
|
|
"github.com/explorer/backend/api/track2"
|
|
"github.com/explorer/backend/api/track3"
|
|
"github.com/explorer/backend/api/track4"
|
|
)
|
|
|
|
// SetupTrackRoutes sets up track-specific routes with proper middleware
|
|
func (s *Server) SetupTrackRoutes(mux *http.ServeMux, authMiddleware *middleware.AuthMiddleware) {
|
|
// Initialize Track 1 (RPC Gateway)
|
|
rpcURL := os.Getenv("RPC_URL")
|
|
if rpcURL == "" {
|
|
rpcURL = "http://localhost:8545"
|
|
}
|
|
|
|
// Use Redis if available, otherwise fall back to in-memory
|
|
cache, err := track1.NewCache()
|
|
if err != nil {
|
|
// Fallback to in-memory cache if Redis fails
|
|
cache = track1.NewInMemoryCache()
|
|
}
|
|
|
|
rateLimiter, err := track1.NewRateLimiter(track1.RateLimitConfig{
|
|
RequestsPerSecond: 10,
|
|
RequestsPerMinute: 100,
|
|
BurstSize: 20,
|
|
})
|
|
if err != nil {
|
|
// Fallback to in-memory rate limiter if Redis fails
|
|
rateLimiter = track1.NewInMemoryRateLimiter(track1.RateLimitConfig{
|
|
RequestsPerSecond: 10,
|
|
RequestsPerMinute: 100,
|
|
BurstSize: 20,
|
|
})
|
|
}
|
|
|
|
rpcGateway := track1.NewRPCGateway(rpcURL, cache, rateLimiter)
|
|
track1Server := track1.NewServer(rpcGateway)
|
|
|
|
// Track 1 routes (public, optional auth)
|
|
mux.HandleFunc("/api/v1/track1/blocks/latest", track1Server.HandleLatestBlocks)
|
|
mux.HandleFunc("/api/v1/track1/txs/latest", track1Server.HandleLatestTransactions)
|
|
mux.HandleFunc("/api/v1/track1/block/", track1Server.HandleBlockDetail)
|
|
mux.HandleFunc("/api/v1/track1/tx/", track1Server.HandleTransactionDetail)
|
|
mux.HandleFunc("/api/v1/track1/address/", track1Server.HandleAddressBalance)
|
|
mux.HandleFunc("/api/v1/track1/bridge/status", track1Server.HandleBridgeStatus)
|
|
|
|
// Initialize Track 2 server
|
|
track2Server := track2.NewServer(s.db, s.chainID)
|
|
|
|
// Track 2 routes (require Track 2+)
|
|
track2Middleware := authMiddleware.RequireTrack(2)
|
|
|
|
// Track 2 route handlers with auth
|
|
track2AuthHandler := func(handler http.HandlerFunc) http.HandlerFunc {
|
|
return authMiddleware.RequireAuth(track2Middleware(http.HandlerFunc(handler))).ServeHTTP
|
|
}
|
|
|
|
mux.HandleFunc("/api/v1/track2/search", track2AuthHandler(track2Server.HandleSearch))
|
|
|
|
// Address routes - need to parse path
|
|
mux.HandleFunc("/api/v1/track2/address/", track2AuthHandler(func(w http.ResponseWriter, r *http.Request) {
|
|
path := r.URL.Path
|
|
parts := strings.Split(strings.TrimPrefix(path, "/api/v1/track2/address/"), "/")
|
|
if len(parts) >= 2 {
|
|
if parts[1] == "txs" {
|
|
track2Server.HandleAddressTransactions(w, r)
|
|
} else if parts[1] == "tokens" {
|
|
track2Server.HandleAddressTokens(w, r)
|
|
} else if parts[1] == "internal-txs" {
|
|
track2Server.HandleInternalTransactions(w, r)
|
|
}
|
|
}
|
|
}))
|
|
|
|
mux.HandleFunc("/api/v1/track2/token/", track2AuthHandler(track2Server.HandleTokenInfo))
|
|
|
|
// Initialize Track 3 server
|
|
track3Server := track3.NewServer(s.db, s.chainID)
|
|
|
|
// Track 3 routes (require Track 3+)
|
|
track3Middleware := authMiddleware.RequireTrack(3)
|
|
track3AuthHandler := func(handler http.HandlerFunc) http.HandlerFunc {
|
|
return authMiddleware.RequireAuth(track3Middleware(http.HandlerFunc(handler))).ServeHTTP
|
|
}
|
|
|
|
mux.HandleFunc("/api/v1/track3/analytics/flows", track3AuthHandler(track3Server.HandleFlows))
|
|
mux.HandleFunc("/api/v1/track3/analytics/bridge", track3AuthHandler(track3Server.HandleBridge))
|
|
mux.HandleFunc("/api/v1/track3/analytics/token-distribution/", track3AuthHandler(track3Server.HandleTokenDistribution))
|
|
mux.HandleFunc("/api/v1/track3/analytics/address-risk/", track3AuthHandler(track3Server.HandleAddressRisk))
|
|
|
|
// Initialize Track 4 server
|
|
track4Server := track4.NewServer(s.db, s.chainID)
|
|
|
|
// Track 4 routes (require Track 4 + IP whitelist)
|
|
track4Middleware := authMiddleware.RequireTrack(4)
|
|
track4AuthHandler := func(handler http.HandlerFunc) http.HandlerFunc {
|
|
return authMiddleware.RequireAuth(track4Middleware(http.HandlerFunc(handler))).ServeHTTP
|
|
}
|
|
|
|
mux.HandleFunc("/api/v1/track4/operator/bridge/events", track4AuthHandler(track4Server.HandleBridgeEvents))
|
|
mux.HandleFunc("/api/v1/track4/operator/validators", track4AuthHandler(track4Server.HandleValidators))
|
|
mux.HandleFunc("/api/v1/track4/operator/contracts", track4AuthHandler(track4Server.HandleContracts))
|
|
mux.HandleFunc("/api/v1/track4/operator/protocol-state", track4AuthHandler(track4Server.HandleProtocolState))
|
|
}
|
|
|