From fd9bdee4f551cbde065456d8529cd93e3ab37fc3 Mon Sep 17 00:00:00 2001 From: Roscanta Date: Tue, 24 Feb 2026 17:03:17 +0300 Subject: [PATCH] nodecore page changes --- pages/_meta.json | 2 +- pages/nodecore-open-source-rpc-stack.mdx | 127 +++++++++++++++++++++++ pages/nodecore.mdx | 81 --------------- 3 files changed, 128 insertions(+), 82 deletions(-) create mode 100644 pages/nodecore-open-source-rpc-stack.mdx delete mode 100644 pages/nodecore.mdx diff --git a/pages/_meta.json b/pages/_meta.json index 89421b2..37dbd7f 100644 --- a/pages/_meta.json +++ b/pages/_meta.json @@ -23,7 +23,7 @@ "type": "separator", "title": "NodeCore" }, - "nodecore": "What is NodeCore", + "nodecore-open-source-rpc-stack": "What is NodeCore", "nodecore-quickstart": "Quickstart", "-- Methods Documentation": { "type": "separator", diff --git a/pages/nodecore-open-source-rpc-stack.mdx b/pages/nodecore-open-source-rpc-stack.mdx new file mode 100644 index 0000000..6a0b3db --- /dev/null +++ b/pages/nodecore-open-source-rpc-stack.mdx @@ -0,0 +1,127 @@ +import { Meta } from "../components/Meta"; + + + +## **1. What is NodeCore?** + +**NodeCore is an open-source, self-hosted RPC infrastructure stack that lets teams run and control their own blockchain connectivity layer.** + +At its core, NodeCore acts as a high-performance load balancer and routing engine, distributing traffic across multiple nodes and providers to optimize latency, reliability, and cost — without relying on managed SaaS RPC services. + +It is designed for teams that require infrastructure sovereignty, performance tuning, and vendor independence while maintaining production-grade resilience. + +## **Why teams deploy NodeCore** + +Organizations adopt NodeCore to: + +- Eliminate dependency on single RPC providers +- Control routing logic and performance policies internally +- Reduce infrastructure costs at scale +- Run hybrid setups combining self-hosted and third-party nodes +- Maintain uptime during upstream outages + +## **Design Goals** + +NodeCore is built around four core infrastructure principles: + +### **1. Cost Efficiency** + +Smart caching combined with price-aware routing minimizes redundant upstream calls and optimizes provider spend without compromising performance. + +### **2. Performance-Aware Routing** + +NodeCore continuously evaluates provider latency, error rates, and throughput to select the most suitable upstream for every request. Underperforming providers are automatically deprioritized. + +### **3. Resilient Error Handling** + +Automated retries, hedged parallel requests, and circuit-breaker logic protect applications from upstream instability and long-tail latency spikes. + +### **4. Operational Simplicity** + +NodeCore centralizes routing, usage analytics, and provider monitoring into a unified control layer. It simplifies multi-provider infrastructure management. + +## **Who is NodeCore for?** + +### **Best fit for:** + +- Web3 infrastructure and DevOps teams running their own nodes +- dApps with backend-originated traffic from one or few regions +- Enterprises requiring on-prem or VPC-contained RPC traffic +- Teams combining multiple RPC vendors for redundancy and cost control + +### **Less ideal for:** + +- Applications with globally distributed, browser-originated traffic +- Frontend-heavy dApps requiring edge routing worldwide +- Teams seeking fully managed, no-ops RPC infrastructure + +In these cases, a managed global routing solution such as NodeCloud may be more appropriate. + +## **Key Features** + +### **1. Intelligent Cost-Aware Routing** + +Routes requests using real-time latency, error-rate, and pricing metrics to balance performance and cost. + +### **2. Multi-Chain / Multi-Protocol Support** + +Compatible with Ethereum-like chains, Solana, Cosmos, Bitcoin, TON, Polkadot, Near, Starknet, and more across JSON-RPC, WebSocket, gRPC, and REST. + +### **3. Aggressive, Correctness-Aware Caching** + +Supports memory, Redis, and Postgres caching layers to reduce redundant traffic and upstream load. + +### **4. Real-Time Metrics & Observability** + +Exports Prometheus metrics and OpenTelemetry traces out-of-the-box for deep performance monitoring. + +### **5. Streaming-First Response Handling** + +Streams large payloads by default to minimize memory footprint and improve throughput. + +### **6. Resilient Error Handling** + +Retries, hedging, and circuit-breaker protections ensure consistent uptime. + +### **7. NodeCloud Bridge (Optional)** + +Sync API keys, usage budgets, and analytics with NodeCloud for hybrid deployments. + +## **System Architecture** + +NodeCore sits between client applications and upstream RPC providers: + +**Client → NodeCore Load Balancer → Cache Layer → Providers → Metrics & Tracing** + +| **Component** | **Purpose** | +| --- | --- | +| Load Balancer | Accepts client RPC traffic and routes upstream | +| Routing Engine | Applies latency, cost, and reliability policies | +| Provider Adapters | Connects to JSON-RPC, WS, gRPC, REST endpoints | +| Cache Layer | Stores frequent read queries | +| Metrics & Tracing | Prometheus + OTEL observability | +| NodeCloud Bridge | Hybrid key and billing sync | + +## **Reliability Design Principles** + +NodeCore is built around production resilience: + +- No single-provider dependency (N+1 routing) +- Hedged reads to reduce long-tail latency +- Circuit breakers eject failing nodes +- Checksum-verified read caching +- Automatic rate-limit discovery + +## **Deployment Scenarios** + +Common production setups include: + +- Routing across Infura + Alchemy + self-hosted nodes +- Backend traffic balancing from a single region +- Hybrid NodeCore + NodeCloud failover +- Private RPC infrastructure for enterprise workloads + +--- \ No newline at end of file diff --git a/pages/nodecore.mdx b/pages/nodecore.mdx deleted file mode 100644 index 51f53d0..0000000 --- a/pages/nodecore.mdx +++ /dev/null @@ -1,81 +0,0 @@ -import { Meta } from "../components/Meta"; - - - -## What is NodeCore? - -NodeCore is a high-performance, on-premise RPC load-balancing solution designed for performance-critical teams, that demand speed, reliability, and control. It intelligently distributes traffic across multiple providers or nodes, optimizing not only cost efficiency but also key performance metrics such as latency and error rates. - -NodeCore is designed with four primary goals: - -- Cost efficiency. - - NodeCore minimizes costs through a combination of a configurable smart caching system and a routing algorithm that take into accounts prices of different providers. This ensures optimal spending without compromising performance. -- Performance-aware routing. - - By continuously collecting and evaluating a broad set of provider metrics, the platform selects the most suitable upstream for each request. Underperforming providers are automatically penalized to maintain consistent quality. -- Resilient error handling. - - NodeCore implements automated retries, parallel requests to reduce long-tail latencies, and dynamically adjusts routing decisions based on provider error rates. -- Operational simplicity. - - Managing multiple RPC providers can be complex. NodeCore centralizes monitoring, usage statistics, and cost tracking across providers, making multi-provider infrastructure easier to operate. - -### Who is it for? - -- Web3 infrastructure & DevOps teams running their own nodes -- Enterprises that must keep traffic on‑prem or in VPC -- Builders who want to combine multiple RPC vendors for cost or redundancy - -### Key Features - -- **Intelligent cost‑aware routing** (latency, error‑rate & price) - - Selects the most suitable provider based on real-time performance metrics and pricing, ensuring optimal speed, cost-efficiency, and reliability. -- **Multi‑chain / multi‑protocol:** JSON‑RPC, WS, gRPC, REST - - Compatible with a wide range of blockchain ecosystems — including Ethereum-like chains, Solana, Cosmos, Bitcoin, Ton, Polkadot, Near, and Starknet — and interfaces such as JSON-RPC, WebSocket, gRPC, and REST. -- **Aggressive, correctness‑aware caching:** memory, Redis, Postgres - - Minimizes redundant traffic by caching frequent requests and reducing load on upstream providers. -- **Real‑time metrics:** Prometheus & OpenTelemetry out‑of‑the‑box - - A centralized interface (available in the enterprise edition) to track provider performance, usage statistics, and cost metrics in real time. -- **Streaming‑first responses:** low memory footprint for large payloads - - Responses are streamed by default to minimize memory footprint and handle large payloads efficiently. -- **Resilient error handling:** retries, hedging, circuit‑breaker -- **NodeCloud bridge (optional):** key management & usage billing - -## Architecture Overview - -| Component | Purpose | -| --------------------- | --------------------------------------------------- | -| **Load Balancer** | Accepts client RPC & distributes to upstreams | -| **NodeCraft Engine** | Modular core implementing caching, routing, retries | -| **Provider Adapters** | Connectors for REST/JSON‑RPC/WS/gRPC per chain | -| **Metrics & Tracing** | Prometheus exporter & OTLP spans | -| **NodeCloud Bridge** | Syncs keys, budgets & usage to NodeCloud | - -### Trust · Availability · Resiliency Principles - -- No single‑provider dependency – smart hedging to _N + 1_ nodes -- Read‑only cache protected by checksum to prevent poisoning -- Circuit‑breaker automatically ejects misbehaving nodes - -## Feature Highlights / Capabilities - -### Load Balancing - -- Round‑robin, p90 latency, weighted‑cost, sticky‑key routing -- Parallel hedged reads to reduce long‑tail latency -- Automatic rate‑limit discovery per provider - -### Observability Integrations - -- `/metrics` endpoint for Prometheus scraping -- Ready‑made Grafana dashboard JSON -- Distributed tracing via OpenTelemetry (OTLP) - -### Extensibility & Modularity - -- gRPC plugin API for custom rating logic -- WebHooks for external scoring -- Lua filters for per‑method overrides _(experimental)_ - -### Security & Data Control - -- Runs entirely within your cluster / bare‑metal -- mTLS between NodeCore peers -- Per‑key auth with JWT, SIWE, or IP allow‑lists