NodeBridge RPC Gateway

A production-ready, multi-tenant RPC gateway providing controlled access to your private Ethereum Sepolia node infrastructure. Similar to Alchemy or Infura, but for your own nodes with enterprise-grade monitoring and security.

🚀 Features

🔐 Multi-Tenant Security

JWT-based authentication system
Unique API keys per user
Role-based access control
Input validation & sanitization

⚡ Advanced Rate Limiting

Token bucket algorithm implementation
Per-user RPS and daily limits
Automatic rate limit recovery
Real-time usage tracking

📊 Enterprise Monitoring

Prometheus metrics integration
Real-time Ethereum node health monitoring
Request latency tracking
Error rate monitoring
Usage analytics

⛓️ Flexible Multi-Chain Support

Configure and connect to multiple Ethereum-compatible chains (e.g., Ethereum Mainnet, Sepolia, custom chains) by defining environment variables with a unique prefix for each chain.
For example, ETHEREUM_EXECUTION_RPC_URL and SEPOLIA_EXECUTION_RPC_URL define two distinct chains.
The prefix (e.g., ETHEREUM, SEPOLIA), converted to lowercase, is used as the chain identifier in API paths (e.g., /ethereum/exec/..., /sepolia/cons/...).
Supports both Execution Layer (JSON-RPC) and Consensus Layer (Beacon API) for each configured chain, along with optional chain-specific Prometheus URLs.

🛡️ Production Security

Helmet.js security headers
CORS configuration
Request logging
Error handling without information leakage

🏗️ Architecture

┌─────────────┐    ┌──────────────────┐    ┌─────────────────────┐
│   Client    │───▶│  NodeBridge      │───▶│  Ethereum Node     │
│  (Web3.js)  │    │  RPC Gateway     │    │  (Execution +      │
│  (Ethers)   │    │                  │    │   Consensus)       │
│   (curl)    │    │  ┌─────────────┐ │    │                    │
└─────────────┘    │  │ Auth        │ │    └─────────────────────┘
                   │  │ Rate Limit  │ │              │
                   │  │ Metrics     │ │              │
                   │  │ Validation  │ │    ┌─────────────────────┐
                   │  └─────────────┘ │    │  Prometheus         │
                   └──────────────────┘    │  Metrics Server     │
                            │              │  (Optional)         │
                   ┌──────────────────┐    └─────────────────────┘
                   │   MongoDB        │
                   │   (Users & Usage)│
                   └──────────────────┘

🚀 Quick Start

Prerequisites

Node.js 18+
MongoDB 6.0+
Ethereum Sepolia Node (execution + consensus layers)
Prometheus (optional, for advanced monitoring)

1. Installation

# Clone the repository
git clone https://github.com/NodeBridge-Africa/rpc_gateway.git
cd rpc_gateway

# Install dependencies
yarn install

# Build the project
yarn build

2. Environment Configuration

# Copy environment template
cp .env.example .env

Update .env with your configuration. To configure chains, use environment variables prefixed with the chain's name (e.g., ETHEREUM_, SEPOLIA_). The supported suffixes are _EXECUTION_RPC_URL, _CONSENSUS_API_URL, and _PROMETHEUS_URL (optional).

# Server Configuration
PORT=8888
NODE_ENV=production

# Database
MONGO_URI=mongodb://localhost:27017/nodebridge

# Security
JWT_SECRET=your-super-secret-jwt-key-change-this-in-production

# Rate Limiting Defaults
DEFAULT_MAX_RPS=20
DEFAULT_DAILY_REQUESTS=10000

# --- Dynamic Multi-Chain Configuration ---
# Define each chain by prefixing variables with its name (e.g., ETHEREUM, SEPOLIA).
# The prefix (lowercase) will be used as the chain identifier in API paths.

# Example: Ethereum Mainnet
ETHEREUM_EXECUTION_RPC_URL=http://localhost:8545
ETHEREUM_CONSENSUS_API_URL=http://localhost:5052
# ETHEREUM_PROMETHEUS_URL=http://localhost:9091 # Optional

# Example: Sepolia Testnet (using a public provider)
SEPOLIA_EXECUTION_RPC_URL="https://sepolia.infura.io/v3/YOUR_INFURA_PROJECT_ID,https://another-sepolia-node.com/v3/YOUR_OTHER_PROJECT_ID"
SEPOLIA_CONSENSUS_API_URL=https://sepolia-beacon.infura.io/v3/YOUR_INFURA_PROJECT_ID
# SEPOLIA_PROMETHEUS_URL= # Optional

# Example: Holesky Testnet (Execution layer only)
HOLESKY_EXECUTION_RPC_URL=https://rpc.holesky.ethpandaops.io
# HOLESKY_CONSENSUS_API_URL= # Optional

# Add more chains by following the pattern: YOURCHAINNAME_EXECUTION_RPC_URL=...
# Note on RPC URLs: For _EXECUTION_RPC_URL and _CONSENSUS_API_URL, you can provide a single URL
# or a comma-separated list of URLs (e.g., "http://node1:8545,http://node2:8545").
# Providing multiple URLs enables basic round-robin load balancing where a URL is randomly selected for each request.

Refer to src/config/env.example.ts for more detailed examples and explanations.

3. Database Setup

# Start MongoDB
sudo systemctl start mongod

# Initialize database (creates indexes, etc.)
yarn setup

4. Start the Gateway

# Development mode (with hot reload)
yarn dev

# Production mode
yarn start

The gateway will be available at http://localhost:8888

📚 API Documentation

🔐 Authentication

Register New User

POST /auth/register
Content-Type: application/json

{
  "email": "developer@example.com",
  "password": "SecurePassword123!"
}

Response:

{
  "success": true,
  "data": {
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
    "apiKey": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    "user": {
      "id": "637f4a2e8b12c45678901234",
      "email": "developer@example.com",
      "apiKey": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
      "maxRps": 20,
      "dailyRequestLimit": 10000,
      "createdAt": "2024-01-01T00:00:00.000Z"
    }
  }
}

User Login

POST /auth/login
Content-Type: application/json

{
  "email": "developer@example.com",
  "password": "SecurePassword123!"
}

Get Account Information

GET /auth/account
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...

Regenerate API Key

POST /auth/regenerate-api-key
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...

Get Usage Statistics

GET /auth/usage
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...

📱 App Management & API Keys

NodeBridge requires users to create "Apps" to obtain API keys. Each App is tied to a specific blockchain (e.g., Sepolia) and has its own unique API key. This allows for granular control and monitoring of access to different chains. Users are typically limited to a certain number of apps (e.g., 5 per user).

Create New App (and get API Key)

POST /api/v1/apps
Authorization: Bearer <USER_JWT_TOKEN>
Content-Type: application/json

{
  "name": "My First DApp",
  "description": "Optional description for my app.",
  "chainName": "Sepolia",
  "chainId": "11155111"
}

Response (Success 201):

{
  "success": true,
  "message": "App created successfully.",
  "data": {
    "app": {
      "_id": "app_id_here",
      "name": "My First DApp",
      "description": "Optional description for my app.",
      "userId": "user_id_here",
      "apiKey": "generated_api_key_here",
      "chainName": "Sepolia",
      "chainId": "11155111",
      "maxRps": 20,
      "dailyRequestsLimit": 10000,
      "requests": 0,
      "dailyRequests": 0,
      "lastResetDate": "2024-03-10T10:00:00.000Z",
      "isActive": true,
      "createdAt": "2024-03-10T10:00:00.000Z",
      "updatedAt": "2024-03-10T10:00:00.000Z"
    }
  }
}

List User's Apps

GET /api/v1/apps
Authorization: Bearer <USER_JWT_TOKEN>

Response (Success 200):

{
  "success": true,
  "message": "User applications retrieved successfully.",
  "data": {
    "apps": [
      {
        "_id": "app_id_1",
        "name": "My First DApp",
        "userId": "user_id_here",
        "chainName": "Sepolia",
        "chainId": "11155111",
        "maxRps": 20,
        "dailyRequestsLimit": 10000,
        "isActive": true,
        "createdAt": "2024-03-10T10:00:00.000Z",
        "updatedAt": "2024-03-10T10:00:00.000Z"
        // Note: apiKey is NOT returned in the list view
      },
      {
        "_id": "app_id_2",
        "name": "Another App",
        "userId": "user_id_here",
        "chainName": "Goerli",
        "chainId": "5",
        "maxRps": 25,
        "dailyRequestsLimit": 15000,
        "isActive": true,
        "createdAt": "2024-03-09T00:00:00.000Z",
        "updatedAt": "2024-03-09T00:00:00.000Z"
      }
    ]
  }
}

⚡ RPC Endpoints & API Key Usage

Execution Layer (JSON-RPC)

Access standard Ethereum JSON-RPC methods:

The :chain parameter in the URL (e.g., ethereum, sepolia) corresponds to the lowercase version of the prefix used when defining the chain in your environment variables (e.g., ETHEREUM_EXECUTION_RPC_URL means the path /ethereum/exec/...).

POST /:chain/exec/<YOUR_API_KEY>
Content-Type: application/json

{
  "jsonrpc": "2.0",
  "method": "eth_blockNumber",
  "params": [],
  "id": 1
}

Supported Methods:

eth_blockNumber
eth_getBalance
eth_getBlockByNumber
eth_getTransactionReceipt
eth_sendRawTransaction
eth_call
All standard Ethereum JSON-RPC methods

API Key Usage Notes:

Each API key obtained from creating an "App" is specific to the chainName (e.g., "Sepolia") chosen during that app's creation.
Requests made with an API key for "Sepolia" will be routed to the Sepolia node infrastructure.
Each API key is subject to its own rate limits:
- maxRps: Maximum requests per second.
- dailyRequestsLimit: Total requests allowed per day for that specific key.
These limits are initially set by system defaults but can be adjusted by an administrator per API key.

Consensus Layer (Beacon API)

Access Ethereum consensus layer data:

The :chain parameter in the URL (e.g., ethereum, sepolia) corresponds to the lowercase version of the prefix used when defining the chain in your environment variables (e.g., SEPOLIA_CONSENSUS_API_URL means the path /sepolia/cons/...).

GET /:chain/cons/<YOUR_API_KEY>/eth/v1/beacon/headers
GET /:chain/cons/<YOUR_API_KEY>/eth/v1/beacon/blocks/head
GET /:chain/cons/<YOUR_API_KEY>/eth/v1/node/syncing

📊 Monitoring Endpoints

Health Check

GET /health

Response:

{
  "status": "healthy",
  "timestamp": "2024-01-01T12:00:00.000Z",
  "version": "1.0.0",
  "environment": "production"
}

Prometheus Metrics

GET /metrics

Returns Prometheus-formatted metrics including:

rpc_gateway_requests_total
rpc_gateway_request_duration_seconds
ethereum_execution_syncing
ethereum_consensus_head_slot
And many more...

Admin: Node Health

This endpoint now requires a chain name parameter.

GET /admin/node-health/:chain

Example: GET /admin/node-health/sepolia

Response:

{
  "timestamp": "2024-01-01T12:00:00.000Z",
  "execution": {
    "status": "healthy",
    "syncing": false,
    "endpoint": "http://localhost:8545"
  },
  "consensus": {
    "status": "healthy",
    "syncing": false,
    "head_slot": "7685000",
    "endpoint": "http://localhost:5052"
  },
  "overall": "healthy"
}

Admin: Node Metrics

This endpoint now requires a chain name parameter.

GET /admin/node-metrics/:chain

Example: GET /admin/node-metrics/sepolia

⚙️ Additional Admin Management Endpoints

The following endpoints require administrator privileges (Admin JWT Token).

Chain Management

List All Supported Chains:

GET /api/v1/admin/chains
Authorization: Bearer <ADMIN_JWT_TOKEN>

Add a New Chain:

POST /api/v1/admin/chains
Authorization: Bearer <ADMIN_JWT_TOKEN>
Content-Type: application/json

{
  "name": "ChainName",
  "chainId": "123",
  "isEnabled": true,
  "adminNotes": "Optional notes about this chain"
}

Update an Existing Chain:

PUT /api/v1/admin/chains/:chainIdToUpdate
Authorization: Bearer <ADMIN_JWT_TOKEN>
Content-Type: application/json

{
  "name": "NewChainName",
  "newChainId": "124",
  "isEnabled": false,
  "adminNotes": "Updated notes"
}

Note: All fields in the request body are optional. Provide only the fields you wish to update. :chainIdToUpdate refers to the current chainId of the chain to be modified.

Delete a Chain:

DELETE /api/v1/admin/chains/:chainIdToDelete
Authorization: Bearer <ADMIN_JWT_TOKEN>

Note: :chainIdToDelete refers to the chainId of the chain to be deleted.

Default App Settings Management

These settings apply to newly created apps.

Get Default App Settings:
```
GET /api/v1/admin/settings/app-defaults
Authorization: Bearer <ADMIN_JWT_TOKEN>
```
Response includes defaultMaxRps and defaultDailyRequestsLimit.

Update Default App Settings:

PUT /api/v1/admin/settings/app-defaults
Authorization: Bearer <ADMIN_JWT_TOKEN>
Content-Type: application/json

{
  "defaultMaxRps": 50,
  "defaultDailyRequestsLimit": 20000
}

App-Specific Limit Management

Administrators can override the default limits for individual apps.

Update Limits for a Specific App:

PUT /api/v1/admin/apps/:appId/limits
Authorization: Bearer <ADMIN_JWT_TOKEN>
Content-Type: application/json

{
  "maxRps": 100,
  "dailyRequestsLimit": 50000
}

Note: maxRps and dailyRequestsLimit are optional in the request. Provide one or both to update.

💻 Usage Examples

Web3.js Integration

const Web3 = require("web3");

// Initialize with your NodeBridge gateway
const web3 = new Web3("http://localhost:8888/ethereum/exec/YOUR-API-KEY");

async function example() {
  // Get latest block number
  const blockNumber = await web3.eth.getBlockNumber();
  console.log("Latest block:", blockNumber);

  // Get account balance
  const balance = await web3.eth.getBalance(
    "0x742d35Cc6634C0532925a3b8D8B8c8B8A8B8B8B8"
  );
  console.log("Balance:", web3.utils.fromWei(balance, "ether"), "ETH");
}

Ethers.js Integration

const { JsonRpcProvider } = require("ethers");

// Initialize provider
const provider = new JsonRpcProvider("http://localhost:8888/ethereum/exec/YOUR-API-KEY");

async function example() {
  // Get network information
  const network = await provider.getNetwork();
  console.log("Network:", network.name, "Chain ID:", network.chainId);

  // Get block information
  const block = await provider.getBlock("latest");
  console.log("Latest block hash:", block.hash);
}

cURL Examples

# Get latest block number
curl -X POST http://localhost:8888/ethereum/exec/YOUR-API-KEY \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

# Get consensus layer sync status
curl http://localhost:8888/ethereum/cons/YOUR-API-KEY/eth/v1/node/syncing

# Check gateway health
curl http://localhost:8888/health

🧪 Testing

Test Structure

110 Total Tests across multiple categories
Unit Tests: No dependencies, fast execution
Integration Tests: Full workflow testing
Database Tests: MongoDB operations
Metrics Tests: Prometheus metrics validation

Running Tests

# Run all tests
yarn test

# Run only unit tests (no MongoDB required)
yarn jest --selectProjects unit-tests

# Run only database tests
yarn jest --selectProjects database-tests

# Run with coverage report
yarn test:coverage

# Run specific test file
yarn jest tests/auth.test.ts

# Watch mode for development
yarn test:watch

Test Categories

🔧 Unit Tests (No external dependencies)

JWT token creation/validation
Password hashing (bcrypt)
Rate limiting algorithms
Utility functions

🔗 Integration Tests (Full system)

Complete user registration → API usage workflow
Rate limiting enforcement
Error handling scenarios
Performance benchmarks

�� Database Tests (MongoDB required)

User model operations
Authentication routes
Usage tracking
Data persistence

📊 Metrics Tests (Prometheus integration)

Custom metrics collection
Default Node.js metrics
Request tracking
Performance measurements

📊 Monitoring & Analytics

Prometheus Metrics

The gateway exposes comprehensive metrics for monitoring:

Gateway Performance Metrics

rpc_gateway_requests_total - Request counts by endpoint/user
rpc_gateway_request_duration_seconds - Request latency histograms
rpc_gateway_active_connections - Current connections
rpc_gateway_rate_limit_hits_total - Rate limiting events

Ethereum Node Health Metrics

ethereum_execution_syncing - Execution layer sync status
ethereum_consensus_syncing - Consensus layer sync status
ethereum_consensus_head_slot - Current consensus head slot
ethereum_node_health_status - Overall node health score

System Metrics

process_* - Node.js process metrics
nodejs_* - Node.js runtime metrics
http_* - HTTP server metrics

Grafana Dashboard Setup

Create monitoring dashboards with:

{
  "dashboard": {
    "title": "NodeBridge RPC Gateway",
    "panels": [
      {
        "title": "Request Rate",
        "targets": ["rate(rpc_gateway_requests_total[5m])"]
      },
      {
        "title": "Request Latency",
        "targets": [
          "histogram_quantile(0.95, rpc_gateway_request_duration_seconds_bucket)"
        ]
      },
      {
        "title": "Node Sync Status",
        "targets": ["ethereum_execution_syncing", "ethereum_consensus_syncing"]
      }
    ]
  }
}

🚀 Production Deployment

Environment Preparation

# 1. Install Node.js 18+
curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt-get install -y nodejs

# 2. Install MongoDB
wget -qO - https://www.mongodb.org/static/pgp/server-6.0.asc | sudo apt-key add -
sudo apt-get install -y mongodb-org

# 3. Install PM2 for process management
npm install -g pm2

Production Configuration

# Production .env
NODE_ENV=production
PORT=8888

# Use production MongoDB cluster
MONGO_URI=mongodb://mongo1,mongo2,mongo3/nodebridge?replicaSet=rs0

# Strong JWT secret (generate with: openssl rand -hex 64)
JWT_SECRET=a1b2c3d4e5f6789012345678901234567890abcdef1234567890abcdef123456

# Production node endpoints
EXECUTION_RPC_URL=http://internal-eth-node:8545
CONSENSUS_API_URL=http://internal-beacon-node:5052

# Monitoring
PROMETHEUS_URL=http://prometheus:9090

# Adjusted limits for production
DEFAULT_MAX_RPS=100
DEFAULT_DAILY_REQUESTS=1000000

Process Management

# Build for production
yarn build

# Start with PM2
pm2 start ecosystem.config.js

# Monitor
pm2 status
pm2 logs nodebridge-gateway
pm2 monit

Docker Deployment

# Dockerfile
FROM node:18-alpine

WORKDIR /app
COPY package*.json ./
RUN yarn install --frozen-lockfile
COPY . .
RUN yarn build

EXPOSE 8888
CMD ["yarn", "start"]

# Build and run
docker build -t nodebridge-gateway .
docker run -d \
  -p 8888:8888 \
  --env-file .env \
  --name nodebridge \
  nodebridge-gateway

Reverse Proxy (Nginx)

server {
    listen 80;
    server_name rpc.yourdomain.com;

    location / {
        proxy_pass http://localhost:8888;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # Rate limiting
        limit_req zone=api burst=100 nodelay;
    }
}

🛡️ Security Best Practices

1. Environment Security

# Never commit .env files
echo ".env*" >> .gitignore

# Use environment-specific secrets
export JWT_SECRET="$(openssl rand -hex 64)"

2. Network Security

Run behind reverse proxy (Nginx/Apache)
Use HTTPS/TLS in production
Implement IP whitelisting if needed
Configure firewall rules

3. Database Security

Enable MongoDB authentication
Use connection encryption
Regular backups
User privilege management

4. Application Security

Input validation on all endpoints
Rate limiting enforcement
Audit logging
Regular dependency updates

🔧 Development Guide

Project Structure

rpc_gateway/
├── src/                          # Source code
│   ├── config/                   # Configuration files
│   ├── middlewares/              # Express middlewares
│   │   ├── auth.middleware.ts    # JWT authentication
│   │   └── rateLimit.middleware.ts # Rate limiting
│   ├── models/                   # Database models
│   │   └── user.model.ts         # User schema & methods
│   ├── routes/                   # API route handlers
│   │   ├── auth.routes.ts        # Authentication endpoints
│   │   └── proxy.routes.ts       # RPC proxy endpoints
│   ├── services/                 # Business logic
│   │   └── metrics.service.ts    # Prometheus metrics
│   └── server.ts                 # Application entry point
├── tests/                        # Test suite
│   ├── auth.test.ts             # Authentication tests
│   ├── integration.test.ts      # Full workflow tests
│   ├── metrics.simple.test.ts   # Metrics collection tests
│   ├── middleware.test.ts       # Middleware tests
│   ├── proxy.test.ts           # RPC proxy tests
│   ├── unit.test.ts            # Unit tests
│   ├── user.model.test.ts      # Database model tests
│   └── helpers/                # Test utilities
├── docs/                       # Additional documentation
├── package.json               # Dependencies & scripts
├── tsconfig.json             # TypeScript configuration
├── jest.config.js            # Test configuration
└── README.md                 # This file

Environment Variables

Variable	Description	Default	Required
`PORT`	Server port	`8888`	No
`NODE_ENV`	Environment	`development`	No
`MONGO_URI`	MongoDB connection	`mongodb://localhost:27017/nodebridge`	Yes
`JWT_SECRET`	JWT signing secret	-	Yes
`CHAINNAME_EXECUTION_RPC_URL`	RPC URL for 'CHAINNAME' execution layer. Replace `CHAINNAME` with chain ID (e.g., `ETHEREUM`).	-	Yes (for each configured chain)
`CHAINNAME_CONSENSUS_API_URL`	Beacon API URL for 'CHAINNAME' consensus layer. Replace `CHAINNAME` as above.	-	No (Optional, per chain)
`CHAINNAME_PROMETHEUS_URL`	Prometheus URL for 'CHAINNAME' specific metrics. Replace `CHAINNAME` as above.	-	No (Optional, per chain)
`DEFAULT_MAX_RPS`	Rate limit (requests/second)	`20`	No
`DEFAULT_DAILY_REQUESTS`	Daily request limit	`10000`	No
`ENABLE_METRICS`	Enable gateway's Prometheus metrics endpoint (`/metrics`)	`true`	No

Development Workflow

Setup Development Environment

git clone <repository>
cd rpc_gateway
yarn install
cp .env.example .env
# Edit .env with your settings

Run in Development Mode
```
yarn dev  # Starts with hot reload
```
Run Tests During Development
```
yarn test:watch  # Continuous testing
```

Before Committing

yarn lint        # Check code style
yarn test        # Run full test suite
yarn build       # Verify build

🤝 Contributing

We welcome contributions! Please read our contribution guidelines below.

🚀 Getting Started

Fork the Repository

# Click "Fork" on GitHub, then clone your fork
git clone https://github.com/YOUR-USERNAME/rpc_gateway.git
cd rpc_gateway

Set Up Development Environment

# Install dependencies
yarn install

# Copy environment file
cp .env.example .env
# Edit .env with your local settings

# Start MongoDB (if running locally)
sudo systemctl start mongod

# Run tests to ensure everything works
yarn test

Create Feature Branch

git checkout -b feature/your-feature-name
# or
git checkout -b fix/issue-description

📝 Development Guidelines

Code Style

We use TypeScript with strict typing and ESLint for code quality:

# Check code style
yarn lint

# Auto-fix style issues
yarn lint:fix

# Type checking
yarn type-check

Style Guidelines:

Use TypeScript strict mode
Prefer const over let
Use meaningful variable names
Add JSDoc comments for public functions
Follow existing naming conventions

Testing Requirements

All contributions must include appropriate tests:

# Run all tests
yarn test

# Run tests in watch mode during development
yarn test:watch

# Check test coverage
yarn test:coverage

Testing Guidelines:

Unit tests for utility functions and pure logic
Integration tests for API endpoints
Database tests for model operations
Maintain >90% test coverage
Mock external dependencies appropriately

Commit Convention

We follow Conventional Commits:

# Feature commits
git commit -m "feat: add consensus layer health monitoring"

# Bug fixes
git commit -m "fix: resolve rate limiting edge case"

# Documentation
git commit -m "docs: update API documentation"

# Tests
git commit -m "test: add integration tests for auth flow"

# Refactoring
git commit -m "refactor: optimize metrics collection"

🐛 Bug Reports

When reporting bugs, please include:

Clear Description: What happened vs. what you expected
Reproduction Steps: Detailed steps to reproduce the issue
Environment Info: OS, Node.js version, MongoDB version
Error Logs: Complete error messages and stack traces
Configuration: Relevant .env settings (redacted secrets)

Template:

## Bug Description

Brief description of the issue

## Steps to Reproduce

1. Step one
2. Step two
3. Step three

## Expected Behavior

What should happen

## Actual Behavior

What actually happens

## Environment

- OS: Ubuntu 22.04
- Node.js: v18.17.0
- MongoDB: v6.0.8
- Gateway Version: v1.0.0

## Error Logs

Error logs here


## Configuration
```env
# Redacted .env content


### 💡 Feature Requests

For new features, please:

1. **Check Existing Issues**: Avoid duplicates
2. **Describe Use Case**: Why is this feature needed?
3. **Propose Solution**: How should it work?
4. **Consider Alternatives**: Other ways to solve the problem?

**Template:**
```markdown
## Feature Request

### Problem/Use Case
Describe the problem this feature would solve

### Proposed Solution
How should this feature work?

### Alternatives Considered
Other approaches you've considered

### Additional Context
Any other relevant information

🔧 Development Areas

We welcome contributions in these areas:

🔐 Security & Authentication

OAuth 2.0 / OpenID Connect integration
API key rotation mechanisms
Advanced rate limiting strategies
Audit logging improvements

📊 Monitoring & Analytics

Additional Prometheus metrics
Grafana dashboard templates
Alerting rule definitions
Performance optimization

🌐 Network & Protocols

WebSocket support
Additional blockchain networks
Protocol optimizations
Connection pooling

🧪 Testing & Quality

Performance benchmarks
Load testing scenarios
Security testing
Documentation improvements

🚀 DevOps & Deployment

Docker improvements
Kubernetes manifests
CI/CD pipeline enhancements
Infrastructure as Code

📋 Pull Request Process

Ensure Tests Pass

yarn test          # All tests must pass
yarn lint          # No linting errors
yarn build         # Must build successfully

Update Documentation
- Update README.md if adding features
- Add API documentation
- Include inline code comments
- Update changelog if applicable
Create Quality PR
- Clear title and description
- Reference related issues
- Include test evidence
- Add screenshots for UI changes
Review Process
- Automated CI checks must pass
- Code review by maintainers
- Testing in development environment
- Final approval and merge

📞 Getting Help

Questions: Open a GitHub Discussion
Bug Reports: Create a GitHub Issue
Security Issues: Email security@yourdomain.com
Feature Ideas: Start with a GitHub Discussion

🏆 Recognition

Contributors will be:

Listed in CONTRIBUTORS.md
Mentioned in release notes
Credited in documentation
Invited to maintainer discussions

📖 Additional Resources

📚 Documentation

🛠️ Tools & Libraries

Express.js - Web framework
MongoDB - Database
Prometheus - Metrics collection
Jest - Testing framework

🔗 Related Projects

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

MIT License Summary

✅ Commercial use allowed
✅ Modification allowed
✅ Distribution allowed
✅ Private use allowed
❗ Liability and warranty limitations apply

Name		Name	Last commit message	Last commit date
Latest commit History 39 Commits
.github		.github
scripts		scripts
src		src
tests		tests
wiki		wiki
.dockerignore		.dockerignore
.gitignore		.gitignore
CONTRIBUTING.md		CONTRIBUTING.md
Dockerfile		Dockerfile
README.md		README.md
babel.config.js		babel.config.js
jest.config.js		jest.config.js
package.json		package.json
setup.sh		setup.sh
tsconfig.json		tsconfig.json
yarn.lock		yarn.lock

NodeBridge-Africa/rpc_gateway

Folders and files

Latest commit

History

Repository files navigation

NodeBridge RPC Gateway

🚀 Features

🔐 Multi-Tenant Security

⚡ Advanced Rate Limiting

📊 Enterprise Monitoring

⛓️ Flexible Multi-Chain Support

🛡️ Production Security

🏗️ Architecture

🚀 Quick Start

Prerequisites

1. Installation

2. Environment Configuration

3. Database Setup

4. Start the Gateway

📚 API Documentation

🔐 Authentication

Register New User

User Login

Get Account Information

Regenerate API Key

Get Usage Statistics

📱 App Management & API Keys

Create New App (and get API Key)

List User's Apps

⚡ RPC Endpoints & API Key Usage

Execution Layer (JSON-RPC)

Consensus Layer (Beacon API)

📊 Monitoring Endpoints

Health Check

Prometheus Metrics

Admin: Node Health

Admin: Node Metrics

⚙️ Additional Admin Management Endpoints

Chain Management

Default App Settings Management

App-Specific Limit Management

💻 Usage Examples

Web3.js Integration

Ethers.js Integration

cURL Examples

🧪 Testing

Test Structure

Running Tests

Test Categories

📊 Monitoring & Analytics

Prometheus Metrics

Gateway Performance Metrics

Ethereum Node Health Metrics

System Metrics

Grafana Dashboard Setup

🚀 Production Deployment

Environment Preparation

Production Configuration

Process Management

Docker Deployment

Reverse Proxy (Nginx)

🛡️ Security Best Practices

1. Environment Security

2. Network Security

3. Database Security

4. Application Security

🔧 Development Guide

Project Structure

Environment Variables

Development Workflow

🤝 Contributing

🚀 Getting Started

📝 Development Guidelines

Code Style

Testing Requirements

Commit Convention

🐛 Bug Reports

🔧 Development Areas

🔐 Security & Authentication

📊 Monitoring & Analytics

Packages