Join our community of builders on Discord!

Testnet Overview

The Lightchain AI Testnet is the public network for building and testing on Lightchain AI before mainnet. It is built from the same Lightchain Geth and Prysm forks as mainnet, and it adds a sharded execution layer that is live only on the testnet.
The testnet is in public beta. It is monitored by the Lightchain team, and parts of it are still changing, including the sharded execution layer described below. Expect occasional resets, endpoint changes and short interruptions. If you run into a problem, please report it: every report helps.
Testnet LCAI has no real-world value. Get it for free from the faucet.
The testnet was reset from a new genesis on 2026-10-28 14:46:36 UTC. The chain ID is unchanged (8200), but contracts, balances and transactions from before that date no longer exist. Keep your deployment scripts version-controlled so you can redeploy.

Network Details

ParameterValue
Network NameLightchain AI Testnet
Chain ID8200
Currency SymbolLCAI
RPC URLhttps://rpc.testnet.lightchain.ai
WebSocket URLwss://rpc.testnet.lightchain.ai
Archive RPChttps://archive.testnet.lightchain.ai
Beacon APIhttps://beacon.testnet.lightchain.ai
Block Explorerhttps://testnet.lightscan.app
Faucethttps://lightfaucet.ai (2 LCAI per address every 24 hours)
The public endpoints publish no fixed rate limit and may be rate-limited during periods of high demand. If you are throttled, consider running your own testnet node.
For supported JSON-RPC methods and example requests, see the Testnet API & RPC Reference.

Chain Parameters

The Basis column says where each value comes from: Protocol values are set in the chain configuration, Observed values are read from the live testnet.
ParameterValueBasis
Slot (block) time2 secondsProtocol
Epoch6 slots (12 seconds)Protocol
FinalityAbout 24–36 seconds (the finalized checkpoint trails the head by 2 epochs)Observed
Block gas limit60,000,000Protocol
Fee ruleEIP-1559 (base fee observed at a few wei per gas when blocks are below target)Protocol / Observed
Missed slots1.27% (31 Oct 14:15 – 1 Nov 09:00 UTC)Observed
Validators21 active, 500,000 LCAI stake eachObserved
Execution clientLightchain Geth v1.17.0-lc.6Observed
Consensus clientLightchain Prysm v7.1.2-lc.2.2 (same build as mainnet)Observed
Genesis2026-10-28 14:46:36 UTCProtocol
During the beta, all 21 testnet validators are operated by the Lightchain team. The testnet is not yet decentralized.

Architecture

The testnet has two layers:
  1. The Lightchain L1 (chain 8200). A proof-of-stake chain built from Lightchain forks of Geth (execution) and Prysm (consensus). It runs smart contracts, the AI inference protocol and staking, and it is where finality comes from. Your wallet connects here.
  2. The sharded execution layer (testnet only). Seven additional EVM chains ("shards", chain IDs 82001–82007). A replicated sequencer orders their transactions and anchors every shard block to the L1. Shards add execution capacity in parallel, without making every L1 validator execute every transaction.
CodeTEXT

How a shard transaction is processed

  1. Sequencing. A shard transaction is signed with that shard's chain ID, like a transaction on any EVM network. The sequencer checks the signature, the nonce, a conservative lower bound on the sender's balance, and the minimum fee (1 gwei). It then writes the transaction to its replicated log and returns the transaction hash.
  2. Ticks. Every 500 ms the sequencer closes a tick: an ordered, signed batch of transactions for each shard.
  3. Execution. Each shard's driver fetches its batch, checks the signature, and has the execution client build exactly that block. The driver has no discretion: every shard block is a deterministic function of the signed batch. A transaction that fails at execution (for example because its sender's balance was spent in the meantime) is recorded as dropped, and its receipt returns an error so the sender can resubmit.
  4. Anchoring. About every 2 seconds (once per L1 block), the sequencer writes the new shard blocks' state, exit and batch roots to the ShardRegistry contract on the L1.
  5. Bridging. LCAI moves onto a shard through ShardBridge on the L1. A deposit is credited on the shard after the L1 deposit is final. LCAI moves back through an exit on the shard, which is claimed on the L1 against the anchored exit root.

Components

ComponentWhat it doesWhere
SequencerOrders shard transactions; signs 500 ms ticks; anchors to the L13 nodes replicating one log with Raft (one leader, two followers)
ShardAn independent EVM chain with its own state and nonces7 shards, chain IDs 82001–82007, 42,000,000 gas per block
ShardRegistryStores each shard block's anchored rootsL1 0x0000000000000000000000000000000000003001
ShardBridgeHolds bridged LCAI; deposits to and exits from shardsL1 0x0000000000000000000000000000000000003002
InboxQueueForced inclusion: a transaction queued here must be included by the sequencer within 120 ticks (60 s)L1 0x0000000000000000000000000000000000003003

Shard endpoints

WhatWhere
Shard dashboard (live throughput, anchoring, proofs per shard)https://testnet.lightscan.app/shards
Read-only shard RPChttps://testnet.lightscan.app/api/lightchain/shard-rpc/<chainId>, for example .../shard-rpc/82001. Serves read methods only; sending transactions is refused.
You can check any shard block against what the L1 recorded for it. The shard dashboard shows the exact commands under Verify it yourself.

Other L1 components

  • AI inference protocol. AI inference runs through protocol contracts (SessionManager, JobRegistry, WorkerRegistry, AIConfig) and independent workers. See AI Inference Architecture and the Developer API.
  • Blobs. EIP-4844 blobs with KZG commitments carry encrypted inference payloads, with a separate blob fee market.

What is not live yet

We publish the limits of the beta so you can judge what the testnet does and doesn't show:
AreaCurrent state on the testnet
Sending transactions to shardsNot open yet. During the beta, Lightchain's own load tests send all shard traffic. Shards can be read publicly (see Shard endpoints). Use the L1 (8200) for your contracts.
Shard trust modelOperator-run. Lightchain runs the sequencer and the shards, and one sequencer key signs all anchors. An exit can be claimed 1 hour after its shard block is anchored (proofWindow = 3,600 s), but no fault-proof verifier is connected yet, so an anchor cannot be challenged during that hour. The bridge holds at most 5,000 LCAI in total (maxLocked).
Cross-shard callsNot built yet. Each shard is independent; value moves between shards through the L1 bridge.
Data availabilityShard batches are stored in an operator-run archive, not published on-chain.
Erasure-coded data availability (PeerDAS)Not enabled. Blobs use EIP-4844 without data-availability sampling.

Performance

Every throughput number on this page was measured on the live testnet, not on a simulator or a separate development network. Measured figures are counted from the blocks the shards actually produced, not from what the load generator sent.
What "TPS" means here. Throughput depends on how much gas each transaction uses. The figures below are for plain LCAI transfers (21,000 gas each) unless a row says otherwise. Heavier contract calls fit fewer per block.

At a glance

MetricValueBasis
Sustained throughput, 7 shards13,903 tx/s for 5 minutes, with stable fees (blocks about half full)Measured, 1 Nov 2026
Peak throughput, 7 shards21,408 tx/s (best 1 minute), with fees risingMeasured, 1 Nov 2026
Inclusion latency (submitted → in a shard block)p50 457 ms · p95 709 ms at ~10,000 tx/sMeasured, 1 Nov 2026
L1 during the testFinality stayed 2 epochs behind the head; 708 of 709 slots had a blockMeasured, 1 Nov 2026
Shard capacity7 × 42M gas every 500 ms = 588M gas/s, about 28,000 transfers/sProtocol (theoretical maximum)
L1 capacity60M gas every 2 s = 30M gas/s, about 1,400 transfers/sProtocol (theoretical maximum)

Results by stage

The load went up in steps of 5 minutes each. Every shard produced 2 blocks per second at every step, including when blocks were completely full.
Offered loadIncluded (7 shards)Shard gas usedLatency p50 · p95Shard base fee
3,000 tx/s2,993 tx/s11%395 ms · 646 msstable
6,000 tx/s5,961 tx/s21%419 ms · 670 msstable
10,000 tx/s9,952 tx/s36%457 ms · 709 msstable
14,000 tx/s13,903 tx/s50%500 ms · 754 msstable
18,000 tx/s17,613 tx/s63%547 ms · 803 msrising
22,000 tx/s21,328 tx/s (stage ended after 2 minutes)76% (up to 100%)611 ms · 881 msrising fast
Why throughput above about 14,000 tx/s doesn't last. Shards use the EIP-1559 fee market: when blocks are more than half full, the base fee goes up with every block. Up to 14,000 tx/s the blocks stayed at about half full and the base fee didn't change. At 18,000 tx/s the base fee rose for the whole stage, and at 22,000 tx/s it rose fast enough that the test wallets could no longer pay after 2 minutes, which ended the test. This is the fee market working as designed: it prices out load above the target. So about 14,000 tx/s is the rate the shards can sustain at stable fees, and about 21,000 tx/s is a short peak. A planned 30-minute stage was not run, because the test wallets had run out of LCAI. The sustained figure above is therefore over 5 minutes.

Method

  • Network: the live testnet: the 7 shards (82001–82007), the 3-node sequencer, and the L1 (8200) they anchor to. Nothing was reconfigured for the test.
  • Load: Lightchain's stress load generator, sending signed transactions from 3,000 funded test wallets per shard at a fixed offered rate, raised in steps of 5 minutes. It ran on the sequencer's host and sent to the sequencer over the host network, so the results measure the chain, not the public internet.
  • Counting: included transactions per second come from the shard blocks themselves (transaction count and gas used per block). The first 30 seconds and the drain at the end of each stage are excluded.
  • Health: throughout the test, every validator machine was checked every 30 seconds (finality, peers, validator errors, attestations), together with the sequencer's anchoring lag, errors and disk. The test would have stopped automatically if finality fell more than 4 epochs behind.

Check the numbers yourself

Shard blocks are public, so anyone can count the transactions in them. For example, the latest block of shard 1 (replace "latest" with a hex block number such as "0x9c777" for a specific block):
CodeBASH
Shard blocks are produced every 500 ms, so the transactions in two consecutive blocks are one second of that shard's throughput. Add up the 7 shards for the network total.

Limits of these numbers

  • Shard load came from a single source with transfers only. Real traffic mixes transaction types and arrives through public RPC endpoints, which have their own limits.
  • During the beta, the sequencer and all 7 shards run on one machine (an AMD EPYC 9254 server). The numbers are a measurement of that setup, not a ceiling of the design.
  • Latency is measured by the load generator, from sending a transaction to seeing it in a shard block. It doesn't include L1 anchoring or finality.
  • The L1 is not yet at full health outside the test: in the hours around it, about 0.7% of L1 slots had no block. We are investigating. So far the missed slots haven't affected finality or shard block production.
  • The shards are not yet open to public transactions (see What is not live yet), so these figures describe capacity, not current usage.

Getting Started

Follow these guides in order to get up and running on the testnet:
  1. Connect to Testnet — Add the Lightchain AI Testnet to your wallet.
  2. Get Testnet Tokens — Claim free LCAI from the faucet.
  3. Deploy a Smart Contract — Deploy your first contract on the testnet.
  4. Interact with Contracts — Read and write to your deployed contracts.
  5. Verify a Contract — Verify your contract source code on the block explorer.

Reporting Issues

The testnet is in beta and is monitored by the Lightchain team. If something doesn't work as you expect, please tell us in Discord — #dev-support. A good report includes:
  • what you did, what you expected, and what happened instead;
  • the time (UTC) and the endpoint you used (for example https://rpc.testnet.lightchain.ai);
  • the transaction hash, block number or contract address, if there is one;
  • the exact error message, or a screenshot.
Security issues: don't post vulnerabilities in public channels. Contact the team privately through Discord first.

Testnet Changelog

Date (UTC)Change
2026-11-01Live load test of the sharded execution layer; results in Performance.
2026-10-30From about 15:46 to 21:00 UTC the public RPC showed a stale chain after a network partition. The chain kept producing and finalizing blocks throughout. The public RPC now fails over between several nodes.
2026-10-28Testnet reset to a new genesis (chain ID 8200 unchanged); sharded execution layer with 7 shards relaunched.

Last updated: 1 November 2026