OG RPC Node
Optimistic Layer 2

Connect to OG, the optimistic rollup delivering low fees and fast transactions. Experience EVM compatibility with Layer 2 efficiency and Layer 1 security.

4 M+

Requests per Day

99.9 %

Network Uptime

< 60 ms

Average Response Time

24/7

Technical Support

Specification OG Network

Technical characteristics and available endpoints

OG Network

Mainnet & Testnet Support

Chain ID 12321
Protocol HTTPS / WSS
Uptime 99.9%
Type Optimistic Rollup
Finality ~2 seconds
EVM Compatible Yes

OG is an optimistic rollup Layer 2 solution delivering low-cost, high-speed transactions while maintaining Ethereum Layer 1 security guarantees through fraud proofs and periodic settlement. By executing transactions off-chain and optimistically assuming validity unless challenged, OG achieves 100x+ cost reduction compared to Ethereum mainnet with transaction finality in approximately 2 seconds. Full EVM compatibility enables seamless deployment of existing Solidity contracts, providing developers with familiar tooling while users benefit from Layer 2 efficiency without sacrificing Layer 1 security.

Key capabilities:

  • Optimistic rollup architecture
  • 100x+ cost reduction vs Ethereum
  • 2-second soft finality
  • 7-day fraud proof window
  • Full EVM compatibility
  • Ethereum security inheritance
  • Fraud proof mechanism
  • Fast transaction processing
  • Growing Layer 2 ecosystem

🔗 RPC Endpoints

HTTPS
https://rpc.crypto-chief.com/og/{YOUR_API_KEY}
WSS
wss://rpc.crypto-chief.com/og/ws/{YOUR_API_KEY}

Replace {YOUR_API_KEY} with your actual API key from the dashboard.

What is an OG RPC Node?

Access optimistic rollup

An OG RPC node provides applications with access to optimistic rollup infrastructure executing transactions off Ethereum Layer 1 with fraud proof protection ensuring correctness. Optimistic rollups assume transactions are valid by default (optimistic assumption), only verifying if someone challenges validity through fraud proof during 7-day window. This approach achieves massive scalability — 100x+ throughput, drastically lower fees, near-instant confirmations — while maintaining Layer 1 security guarantees. Users experience fast, cheap transactions with cryptographic assurance that funds remain secure.

Why optimistic rollups transform scalability

Ethereum Layer 1 processes ~15 transactions per second with high gas costs limiting adoption. Layer 2 solutions must scale without compromising security. Optimistic rollups achieve this balance — execute thousands of transactions off-chain, batch them together, post compressed data to Layer 1, and rely on fraud proofs for security. This provides 100x+ cost reduction with Ethereum security guarantees, enabling DeFi, gaming, and applications impossible at Layer 1 costs.

OG advantages:

  • 100x+ cheaper — dramatic cost reduction vs Ethereum L1
  • Fast finality — ~2 second soft finality
  • EVM compatible — deploy existing Solidity contracts
  • Ethereum security — inherits L1 security guarantees
  • Fraud proofs — cryptographic security mechanism
  • Scalable — thousands of TPS vs L1's ~15

Fraud proof security model

Fraud proofs provide optimistic rollup security — if sequencer posts invalid state transition (fraudulent transaction), anyone can challenge it during 7-day dispute window by submitting fraud proof to Layer 1. Invalid state gets reverted, fraudulent sequencer loses stake, challenger receives reward. This economic mechanism ensures honest behavior — attempting fraud means losing stake while honest operation earns revenue. Users gain Ethereum-level security while enjoying Layer 2 efficiency.

How fraud proofs work on OG:

  1. Sequencer executes transactions and proposes new state
  2. State posted to Ethereum L1 (assumed valid optimistically)
  3. 7-day challenge period begins for fraud proof submission
  4. Anyone can verify and challenge invalid transitions
  5. Fraud proof submitted to L1 if discrepancy found
  6. Invalid state reverted, honest state confirmed, security maintained

Bridging and finality considerations

OG provides soft finality in ~2 seconds for transactions on Layer 2 — practically instant for user experience. However, withdrawing assets from OG back to Ethereum Layer 1 requires waiting 7-day fraud proof period for absolute security. This tradeoff enables optimistic rollup efficiency — immediate transactions for Layer 2 interactions, security waiting period only for L1 exits. Most users stay on Layer 2 for fast DeFi/gaming, only bridging to L1 when necessary.

This infrastructure represents proven approach to blockchain scaling without compromising security.

Technical Documentation

Quick start for developers

Supported RPC Methods

OG supports all standard Ethereum JSON-RPC methods:

  • eth_blockNumber — current block number
  • eth_getBalance — OG token balance
  • eth_call — execute read-only contract functions
  • eth_sendRawTransaction — broadcast signed transactions
  • eth_getTransactionReceipt — get transaction confirmation
  • eth_getLogs — query event logs
  • eth_gasPrice — current gas price (100x cheaper than L1)
  • eth_estimateGas — estimate transaction gas cost
  • eth_subscribe — WebSocket event subscriptions

Code Examples

💻

JavaScript (ethers.js) — OG Layer 2:

const { ethers } = require('ethers');

const provider = new ethers.JsonRpcProvider('https://rpc.crypto-chief.com/og/YOUR_API_KEY');

// Verify connection to OG L2
const network = await provider.getNetwork();
console.log('Chain ID:', network.chainId); // 12321
console.log('Network:', network.name); // og

// Get OG balance
const address = '0x...';
const balance = await provider.getBalance(address);
console.log('OG Balance:', ethers.formatEther(balance));

// Check gas price (dramatically cheaper than Ethereum L1)
const gasPrice = await provider.getFeeData();
console.log('Gas price:', ethers.formatUnits(gasPrice.gasPrice, 'gwei'), 'gwei');
console.log('100x+ cheaper than Ethereum mainnet!');

// Deploy contract with L2 efficiency, L1 security
const factory = new ethers.ContractFactory(abi, bytecode, wallet);
const contract = await factory.deploy();
const receipt = await contract.waitForDeployment();

console.log('Contract deployed on OG L2!');
console.log('Address:', await contract.getAddress());
console.log('Soft finality in ~2 seconds!');
console.log('Secured by Ethereum L1 fraud proofs');

// Low-cost DeFi interaction
const DEFI_PROTOCOL = '0x...';
const defiABI = [
  'function stake(uint256 amount) external',
  'function harvest() external returns (uint256)',
  'function getRewards(address user) view returns (uint256)'
];

const defi = new ethers.Contract(DEFI_PROTOCOL, defiABI, wallet);

// Stake with minimal fees
const stakeTx = await defi.stake(ethers.parseEther('100'));
await stakeTx.wait();

console.log('Staked on OG L2 with minimal gas costs!');
console.log('DeFi made affordable through L2 scaling!');
💻

Python (web3.py) — OG Integration:

from web3 import Web3

w3 = Web3(Web3.HTTPProvider('https://rpc.crypto-chief.com/og/YOUR_API_KEY'))

print('Connected to OG L2:', w3.is_connected())
print('Chain ID:', w3.eth.chain_id)  # 12321
print('Latest block:', w3.eth.block_number)

# Compare gas prices
gas_price = w3.eth.gas_price
print(f'OG L2 gas price: {w3.from_wei(gas_price, "gwei")} gwei')
print('100x+ cheaper than Ethereum mainnet!')

# Get OG balance
address = '0x...'
balance = w3.eth.get_balance(address)
print(f'OG Balance: {w3.from_wei(balance, "ether")} OG')

# Low-cost NFT minting on L2
nft_contract_address = '0x...'
nft_contract_abi = [...]

nft = w3.eth.contract(
    address=nft_contract_address,
    abi=nft_contract_abi
)

# Mint NFT with L2 efficiency
tx_hash = nft.functions.mint(
    recipient_address,
    token_uri='ipfs://...',
    metadata={'name': 'OG NFT', 'description': 'Affordable L2 minting'}
).transact({'from': minter_address})

receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
print('NFT minted on OG L2!')
print('Minting costs 100x less than Ethereum L1')
print(f'Transaction hash: {receipt["transactionHash"].hex()}')
print('Secured by Ethereum fraud proofs!')
💻

WebSocket — Monitor L2 Activity:

const { ethers } = require('ethers');
const provider = new ethers.WebSocketProvider('wss://rpc.crypto-chief.com/og/ws/YOUR_API_KEY');

let lastBlockTime = Date.now();

// Monitor fast L2 blocks
provider.on('block', async (blockNumber) => {
  const now = Date.now();
  const timeSinceLastBlock = (now - lastBlockTime) / 1000;
  lastBlockTime = now;
  
  const block = await provider.getBlock(blockNumber);
  console.log(`\n=== OG L2 Block ${blockNumber} ===`);
  console.log('Time since last:', timeSinceLastBlock.toFixed(2), 'seconds');
  console.log('Transactions:', block.transactions.length);
  console.log('Soft finality: ~2 seconds');
});

// Monitor L2 bridge events
const BRIDGE_CONTRACT = '0x...';
const depositFilter = {
  address: BRIDGE_CONTRACT,
  topics: [ethers.id('DepositFinalized(address,uint256)')]
};

provider.on(depositFilter, (log) => {
  const decoded = ethers.AbiCoder.defaultAbiCoder().decode(
    ['address', 'uint256'],
    log.data
  );
  console.log('\n=== Bridge Deposit ===');
  console.log('User:', decoded[0]);
  console.log('Amount:', ethers.formatEther(decoded[1]));
  console.log('Bridged from Ethereum L1 to OG L2');
});

// Monitor low-cost DeFi transactions
const DEFI_CONTRACT = '0x...';
const defiFilter = {
  address: DEFI_CONTRACT,
  topics: [ethers.id('Swapped(address,uint256,uint256)')]
};

provider.on(defiFilter, (log) => {
  console.log('\n=== DeFi Swap on L2 ===');
  console.log('100x cheaper than Ethereum L1');
  console.log('Making DeFi accessible to everyone!');
});

console.log('Monitoring OG optimistic rollup Layer 2...');

OG Best Practices

  • Leverage L2 Efficiency: Design for high-frequency, low-cost interactions
  • Bridge Understanding: Educate users about 7-day withdrawal period to L1
  • Soft Finality: Build UX around ~2 second L2 confirmation times
  • Fraud Proof Awareness: Understand security model and challenge periods
  • Gas Optimization: While cheaper, still optimize gas for efficiency
  • L1 Settlement: Monitor periodic L1 state submissions
  • Testing: Thoroughly test on OG testnet before mainnet deployment

Why choose us?

Layer 2 rollup infrastructure

100x Cost Reduction

Infrastructure delivering 100x+ lower costs than Ethereum L1 with <60ms RPC latency.

Fraud Proof Security

Production infrastructure with Ethereum security guarantees through fraud proof mechanism achieving 99.9% uptime.

L2 Analytics

Comprehensive monitoring of L2 transactions, bridge activity, fraud proofs, and L1 settlement metrics.

Global Infrastructure

Worldwide deployment supporting OG's optimistic rollup ecosystem.

Scalable Throughput

Infrastructure designed to scale with thousands of TPS on Layer 2 while settling to L1.

Rollup Experts

24/7 support from engineers specialized in optimistic rollups, fraud proofs, and L2 architecture.

Examples of Use

Build on Layer 2

OG's optimistic rollup enables affordable DeFi protocols, low-cost NFT platforms, high-frequency gaming, and applications requiring L2 efficiency with L1 security.

Affordable DeFi

Build DeFi protocols accessible to everyone with 100x lower transaction costs enabling micro-transactions and frequent interactions.

Low-Cost NFTs

Launch NFT marketplaces and platforms where minting and trading cost pennies instead of dollars.

Gaming Applications

Create blockchain games with frequent on-chain actions made economically viable through L2 efficiency.

DEX Platforms

Develop decentralized exchanges with low-cost swaps enabling competitive pricing and better UX.

Social Applications

Build social platforms where every interaction happens on-chain without prohibitive gas costs.

E-commerce Integration

Create blockchain e-commerce where payment settlements cost fraction of traditional fees.

Got questions?
we are here to help

OG is an optimistic rollup Layer 2 delivering 100x+ cost reduction compared to Ethereum with ~2 second finality and fraud proof security.

Optimistic rollups assume transactions are valid by default, only verifying if challenged through fraud proofs, enabling massive scalability with L1 security.

Fraud proofs are cryptographic challenges proving sequencer posted invalid state transition, triggering reversion and ensuring honest behavior.

OG provides 100x+ cost reduction compared to Ethereum Layer 1 while maintaining equivalent security guarantees.

Yes, OG is fully EVM-compatible. Deploy existing Solidity smart contracts using standard Ethereum development tools.

Withdrawing from OG L2 to Ethereum L1 requires 7-day fraud proof challenge period for maximum security.

Soft finality (~2 seconds) means transactions are confirmed on L2 quickly while absolute finality requires L1 settlement and fraud proof period.

OG is the native token used for transaction fees, network operations, and Layer 2 functionality.

Yes, we provide RPC access to both OG mainnet (Chain ID 12321) and testnet for development and testing.

OG enables affordable DeFi through 100x+ cost reduction making micro-transactions, frequent trading, and complex protocols economically viable.

Pricing that grows with your needs.

Free

Start building on Web3 — no credit card.

$0
  • 5 reqs/sec RPC
  • 5 reqs/min Unified API
  • Ultimate chains
  • WSS, Statistics
  • Community support

Pay for use

Flexible pay-as-you-go for any workload.

From $10
  • 400 reqs/sec RPC
  • 300 reqs/min Unified API
  • 10 reqs/min AML
  • EventStream
  • Ultimate chains
  • WSS, Whitelists, Statistics
  • Support portal

Subscription

From $500 monthly plus 20% extra value.

From $500
  • 700 reqs/sec RPC
  • 500 reqs/min Unified API
  • 5 reqs/sec AML
  • EventStream
  • Ultimate chains
  • WSS, Whitelists, Statistics
  • Support portal

Enterprise

Tailored solution for expert builders

Custom terms

All Subscription features plus:

  • Flexible rate limits
  • Engineering team support
  • Custom SLA
  • Personal manager