Connect to Avail, the scalable data availability layer for modular blockchains. Experience validity proofs, light client verification, and infrastructure for rollups and validiums.
Requests per Day
Network Uptime
Average Response Time
Technical Support
Technical characteristics and available endpoints
Mainnet & Testnet Support
Avail is a modular data availability layer using validity proofs (KZG polynomial commitments) and data availability sampling (DAS) to provide scalable DA for rollups, validiums, and modular blockchain architectures. Through innovative techniques enabling light clients to verify data availability by sampling small random chunks rather than downloading entire blocks, Avail creates efficient infrastructure for modular designs where execution, consensus, settlement, and data availability are separated into specialized layers. This represents the future of blockchain scalability through modularization.
https://rpc.crypto-chief.com/avail/{YOUR_API_KEY}
wss://rpc.crypto-chief.com/avail/ws/{YOUR_API_KEY}
Replace {YOUR_API_KEY} with your actual API key from the dashboard.
Access modular DA infrastructure
An Avail RPC node provides applications with access to modular data availability infrastructure enabling rollups, validiums, and modular blockchains to publish transaction data efficiently and verifiably. Avail focuses exclusively on ensuring data is available and retrievable — the DA layer in modular architecture — while leaving execution, consensus, and settlement to other specialized layers. This separation enables optimization impossible in monolithic designs where all concerns compete for the same resources.
Rollups and validiums need to publish transaction data somewhere so anyone can reconstruct state and verify correctness. Posting data to expensive Layer 1s like Ethereum creates scalability bottlenecks. Avail provides dedicated, scalable DA through validity proofs and light client sampling, enabling applications to verify data availability without downloading everything. This creates the foundation for truly scalable modular blockchain architectures.
Avail advantages:
Data Availability Sampling (DAS) is Avail's breakthrough technology enabling light clients to verify data availability by randomly sampling small portions of blocks rather than downloading everything. Through erasure coding extending block data with redundancy and KZG polynomial commitments proving data correctness, Avail ensures that if enough random samples are available, the complete data must exist and be retrievable. This provides cryptographic security without requiring resource-intensive full node operation.
How DAS works on Avail:
Avail provides the data availability layer enabling modular blockchain designs where different specialized layers handle execution (rollups), settlement (base chains), consensus (validator sets), and DA (Avail). This separation allows each component to optimize independently — rollups maximize execution throughput, Avail maximizes DA scalability, settlement layers focus on security. This modular approach represents the evolution beyond monolithic blockchain designs toward specialized, composable infrastructure.
This infrastructure powers the next generation of scalable, modular blockchain architectures.
Quick start for developers
Avail uses Substrate RPC methods (JSON-RPC 2.0):
const { ApiPromise, WsProvider, Keyring } = require('@availproject/avail-js');
// Connect to Avail DA layer
const provider = new WsProvider('wss://rpc.crypto-chief.com/avail/ws/YOUR_API_KEY');
const api = await ApiPromise.create({ provider });
console.log('Connected to Avail DA');
const chain = await api.rpc.system.chain();
console.log('Chain:', chain.toString());
// Submit data to Avail DA layer
const keyring = new Keyring({ type: 'sr25519' });
const account = keyring.addFromUri('//Alice');
// Data to make available (e.g., rollup transaction batch)
const rollupBatchData = Buffer.from('rollup transaction batch data...');
// Submit data availability transaction
const tx = api.tx.dataAvailability.submitData(rollupBatchData);
const hash = await tx.signAndSend(account);
console.log('Data submitted to Avail DA layer');
console.log('Transaction hash:', hash.toHex());
// Query data availability proof
const block = await api.rpc.chain.getBlock();
const blockHash = block.block.header.hash;
const proof = await api.rpc.kate.queryProof([0], blockHash); // Query first data cell
console.log('KZG proof retrieved for light client verification');from substrateinterface import SubstrateInterface
# Connect to Avail
substrate = SubstrateInterface(
url='wss://rpc.crypto-chief.com/avail/ws/YOUR_API_KEY'
)
print('Connected to Avail DA')
print('Chain:', substrate.chain)
# Get latest block with DA information
tip_hash = substrate.get_chain_finalised_head()
block = substrate.get_block(block_hash=tip_hash)
print(f'Latest finalized block: {block["header"]["number"]}')
print(f'Block hash: {tip_hash}')
# Query block length (DA metrics)
block_length = substrate.rpc_request(
method='kate_blockLength',
params=[tip_hash]
)
print(f'Block length info: {block_length}')
# Get data availability commitments
header = block['header']
if 'extension' in header:
print('DA commitments present in header')
print(f'Commitment: {header["extension"]}')
# Light client can verify DA through sampling
print('Light clients can verify DA by sampling random cells')
print('KZG proofs ensure data correctness without full download')const { ApiPromise, WsProvider } = require('@availproject/avail-js');
const provider = new WsProvider('wss://rpc.crypto-chief.com/avail/ws/YOUR_API_KEY');
const api = await ApiPromise.create({ provider });
// Subscribe to finalized blocks with DA commitments
const unsubscribe = await api.rpc.chain.subscribeFinalizedHeads((header) => {
console.log('\n=== Avail DA Block ===');
console.log('Block number:', header.number.toNumber());
console.log('Block hash:', header.hash.toHex());
// Check for DA extension (KZG commitments)
if (header.extension) {
console.log('DA Commitments:', header.extension.toHuman());
}
// Query block length for DA metrics
api.rpc.kate.blockLength(header.hash).then(length => {
console.log('Block length:', length.toHuman());
});
});
// Monitor data submission events
api.query.system.events((events) => {
events.forEach((record) => {
const { event } = record;
if (event.section === 'dataAvailability' && event.method === 'DataSubmitted') {
console.log('\n=== Data Submitted to Avail ===');
console.log('Submitter:', event.data[0].toString());
console.log('Data length:', event.data[1].toNumber(), 'bytes');
}
});
});
console.log('Monitoring Avail DA layer activity...');Modular DA infrastructure
Purpose-built data availability infrastructure with <70ms RPC latency optimized for rollup and validium data posting.
Production infrastructure with KZG polynomial commitments achieving 99.9% uptime and cryptographic DA guarantees.
Comprehensive monitoring of data submissions, block length, sampling activity, and modular ecosystem metrics.
Worldwide deployment supporting Avail's modular data availability network for rollups and validiums.
Infrastructure designed to scale DA capacity independently from execution and settlement layers.
24/7 support from engineers specialized in data availability, KZG proofs, erasure coding, and modular architectures.
Build modular blockchains
Avail's scalable DA layer enables rollup development, validium architectures, modular blockchain designs, and applications requiring efficient data availability.
Build optimistic or ZK rollups using Avail for cost-effective, scalable data availability instead of expensive L1 posting.
Create validiums with off-chain data availability through Avail while maintaining security via validity proofs.
Develop modular blockchain architectures separating execution, settlement, consensus, and DA into specialized layers.
Build applications enabling communication between different rollups sharing Avail as common DA layer.
Launch sovereign rollups with independent execution while using Avail for trustless DA verification.
Create platforms aggregating DA demand across multiple rollups and optimizing Avail data posting.
Start building on Web3 — no credit card.
Flexible pay-as-you-go for any workload.
From $500 monthly plus 20% extra value.
Tailored solution for expert builders
All Subscription features plus: