Lisk RPC: A Developer's Guide (Chain ID 1135, Shutdown Oct 31)

Lisk is an OP Stack layer 2 that behaves like Ethereum: chain ID 1135, ETH for gas, two-second blocks, and standard eth_* methods. The deadline is not standard. Lisk Chain shuts down on October 31, 2026, nine days after this post. Lisk announced the closure, opened a Celo migration path, and told users to withdraw to Ethereum.

If you have assets on Lisk, the bridge clock matters more than the RPC details. This guide covers both: what the chain does today, and what to do before it stops.

The endpoint

https://rpc.swiftnodes.io/rpc/lisk?key=YOUR_API_KEY
wss://rpc.swiftnodes.io/ws/lisk?key=YOUR_API_KEY

The proxy slug is lisk. The gas token is ETH with 18 decimals. LSK is a separate ERC-20 token; on Lisk L2 it lives at 0xac485391EB2d7D88253a7F1eF18C37f4242D1A24 and reports the name Lisk, symbol LSK, and 18 decimals.

If your library does not ship a Lisk preset, define it with id 1135, currency ETH, and the HTTP URL above.

What we measured

All values were measured on October 22, 2026 through the SwiftNodes endpoint and Lisk's official RPC.

The shutdown clock

Lisk's instructions are specific:

• The chain shuts down on October 31, 2026.
• Every asset on Lisk must be withdrawn to Ethereum before then: ETH, LSK, stablecoins, bridged tokens, and anything inside a DeFi position.
• The official bridge is bridge.lisk.com. Lisk says it is the only bridge that still works.
• A normal withdrawal takes about eight days. You initiate it on Lisk, submit a prove transaction on Ethereum about an hour later, then wait seven days and claim. The challenge period starts at the prove step, not when you first click withdraw.
• Staked LSK needs an additional three-day unstaking wait. Lisk's guidance is to allow at least eleven days in total.
• After October 31 there is no recovery process.

From October 22, a plain bridge has roughly one day of slack against that eight-day estimate. A staked position does not fit the remaining window. A withdrawal still in its challenge period when the chain closes may not complete. If you are reading this later, check the closure FAQ first.

Close DeFi positions first. Pools, lending markets, and vaults cannot be bridged directly; withdraw the underlying tokens, then bridge each token. Some Lisk protocols may set earlier deadlines than the chain itself.

The LSK token on Ethereum is unaffected: same contract, same ticker, same exchanges. The LSK on Lisk L2 is the bridged ERC-20 that has to move.

The fee market is tiny, but the L1 fee is not optional

Lisk's base fee was 1,015 wei in every block we sampled. The suggested priority fee was 1,000,000 wei, or 0.001 gwei, roughly a thousand times the base fee. eth_gasPrice returned 1,001,015 wei, the sum of the two.

A type-2 transaction in our sample used a 1,200,000 wei tip and paid 1,201,015 wei effective. The tip is not a hard protocol floor, but do not copy an Ethereum fee recipe. Read eth_maxPriorityFeePerGas or eth_gasPrice at send time.

The more important number is the L1 data fee. OP Stack transactions pay two costs:

total = L2 execution fee + L1 data fee

The second term is not included in eth_gasPrice.

A plain 21,000-gas transfer in our sample used 21,000 gas at 1,202,000 wei, or 25,242,000,000 wei of L2 execution. Its receipt also carried an l1Fee of 10,127,034,807 wei. The total was 35,369,034,807 wei, about 0.0000000354 ETH, and the L1 fee was 29% of it.

For a heavier call the split changes. A 520,113-gas transaction paid 624,663,514,695 wei for L2 execution and 21,998,932,697 wei for L1 data, about 3.4% of the total. The L1 component is roughly fixed for a given transaction size, so it matters most for cheap transfers and least for heavy contract calls.

You can read the estimate before sending from the OP Stack GasPriceOracle predeploy at 0x420000000000000000000000000000000000000F:

import { Contract, JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://rpc.swiftnodes.io/rpc/lisk?key=YOUR_API_KEY");
const oracle = new Contract(
  "0x420000000000000000000000000000000000000F",
  ["function getL1Fee(bytes) view returns (uint256)"],
  provider
);
const l1Fee = await oracle.getL1Fee(serializedTx); // signed tx bytes

The predeploy is Fjord-era: isFjord() returned 1, l1BaseFee() was 40,191,418 wei, and baseFeeScalar() was 127,543 at the time of measurement. Use the oracle rather than recreating Lisk's formula from scratch.

One system transaction per block

A 300-block sample contained 318 transactions, which looks like more activity than it is. Exactly 300 of them were type 0x7e deposit transactions, one per block, sent to the L1 attributes predeploy at 0x4200000000000000000000000000000000000015. Those transactions carry the L1 fee parameters into L2.

Only 18 transactions were user activity: nine type-2 and nine legacy type-0, from 14 senders to 10 recipients. That is 0.06 user transactions per block. The average block used 59,829 gas out of a 60,000,000 gas limit, or 0.1%.

Do not use raw transaction count as a demand signal on Lisk. Subtract the one deposit per block first. If you are indexing, filter by transaction type or by sender; otherwise your pipeline will process a system transaction every two seconds and report activity that is not user activity.

Finality is a batch marker, not the withdrawal clock

Lisk is an optimistic rollup, so there are two different clocks:

• The finalized RPC tag tells you when a block is considered final by the node's derivation pipeline.
• The bridge's seven-day challenge period is a separate contract-level window for withdrawing to Ethereum.

Do not confuse them. In our sample, safe and finalized both returned the same block, about 2,150 blocks behind the head, or roughly 72 minutes at two-second blocks. The tag moves in steps, when a batch or output root lands, not on every block.

That 72-minute figure is a snapshot, not a guarantee. An earlier measurement on the same chain put finalized several hours back. Treat finalized as a backend- and batch-dependent marker. If your application needs a fixed confirmation rule, wait a fixed number of blocks or use a finality service. The finalized block tag across 62 chains shows how much this varies. For indexers, key on (txHash, logIndex), keep a rollback path, and do not credit a deposit before the source chain is final.

Logs: 100,000 blocks and 20,000 results

Lisk's upstream has two hard limits. A query can span at most 100,000 blocks, and it can return at most 20,000 results. The error messages are explicit:

query exceeds max block range 100000
query exceeds max results 20000, retry with the range 38859278-38924008

The second error suggests a smaller range that fits the result cap. Use it. A 100,000-block unfiltered query on October 22 exceeded the result cap, but a 100,000-block query filtered to the LSK token returned 2,479 logs, and the same range filtered to USDC.e returned 1,593. The cap is on results, so an address or topic filter can turn a failing query into a passing one.

Some backends behind the load-balanced route also reject unfiltered queries with a different message:

block is out of range

That is backend behavior, not a chain rule. Pin an address filter and a bounded range, and retry a different endpoint if your provider returns that error. On SwiftNodes, the free tier adds a 100-block span cap per eth_getLogs request; paid plans remove that span cap and leave the upstream limits.

The practical loop is:

let step = 2_000n;
for (let from = start; from <= end; ) {
  const to = from + step - 1n > end ? end : from + step - 1n;
  try {
    await client.getLogs({ address, fromBlock: from, toBlock: to });
    from = to + 1n;
  } catch {
    step /= 2n;
  }
}

For the general pattern, see eth_getLogs range caps.

Archive, tracing, and the method table

Historical state was available on the default route in our tests. eth_getCode at sampled blocks from 1,000,000 to 38,000,000 answered without &archive=1, so Lisk's archive posture is better than some pruned-default chains. Pin the block and test the exact endpoint you will use; the archive switch is documented in the API reference.

The tracer requirement is the same trap as on other geth-family backends. Passing {} returns Tracer object with 'tracer' param is required for debug_traceTransaction, so pass {"tracer":"callTracer"} explicitly. Debug and trace methods are paid-plan features on SwiftNodes; the free tier serves the standard read methods, capped eth_getLogs, and newHeads only.

The WebSocket endpoint needs an API key. On the official Lisk socket, both newHeads and a logs subscription were accepted; newHeads delivered a header in 1.7 seconds. For production, use wss://rpc.swiftnodes.io/ws/lisk?key=YOUR_API_KEY, subscribe to newHeads for block updates, and backfill logs over HTTP after any reconnect. The reconnection rules are the same as on Ethereum; see WebSocket reconnection without losing events.

If you are migrating off Lisk

The Celo migration path is optional, and it is not a lift-and-shift. Celo is a different chain with chain ID 42220, its own gas and fee-currency rules, and a fresh contract deployment. Addresses will change. Transactions signed for Lisk will not replay on Celo, and hard-coded 1135 values need to be removed.

A short checklist:

1. Stop new deployments. Inventory every contract, token, and DeFi position; snapshot addresses and export the logs and state you need for accounting.
2. Close DeFi positions before bridging. Protocol deadlines may be earlier than October 31.
3. Unlock staked LSK, wait three days, unstake, claim any rewards, then bridge. The combined timeline no longer fits the remaining window.
4. Bridge through bridge.lisk.com only, with Lisk as the source and Ethereum as the destination. About an hour later, submit the prove transaction on Ethereum; the seven-day challenge starts there. Claim after the challenge period, using ETH on Ethereum for gas.
5. If you move to Celo, redeploy and re-verify every contract. Update RPC URLs, chain IDs, explorers, indexers, and wallet presets. Our Celo RPC guide covers the fee-currency differences.

The Lisk docs also have a Celo migration guide and a chain closure FAQ. Read them before moving anything; the bridge steps and dates are the authoritative source.

Summary

• Lisk L2 uses chain ID 1135, ETH gas, two-second blocks, and a 60,000,000 gas limit.
• It shuts down on October 31, 2026. Withdraw to Ethereum before then; the official bridge takes about eight days and staking adds three more.
• The base fee was 1,015 wei, but the L1 data fee is a real part of the total. Use the GasPriceOracle at 0x420...000F and read l1Fee from the receipt.
• One system deposit per block means raw transaction counts overstate activity. eth_getLogs is capped at 100,000 blocks and 20,000 results upstream, and at 100 blocks on the free tier. safe and finalized are batch markers, not the withdrawal clock.

Lisk endpoints and method support are on our Lisk RPC page. The chain still works today, but the useful work is no longer building on it; it is getting assets and data off it before October 31. If you need a like-for-like OP Stack home, Celo is the migration path Lisk itself points to.

Start free if you want to test the endpoint with your own key; no card is required.