Kraken built Ink to be the “house of DeFi on the Superchain,” and on October 6, 2026 the numbers on DefiLlama said that house mostly trades derivatives: about $334 million of perpetuals volume in 24 hours against $2.7 million on spot DEXs. Ink is an Ethereum Layer 2 on the OP Stack, incubated by Kraken, with one-second blocks, ETH as the gas token, and chain ID 57073. This guide answers the question “what is Ink?” by covering how it works, what you can verify onchain yourself, where its trust model sits, what the DeFi stack on top looks like, and how to get RPC access on Chainstack.
Not to be confused with ink!, the Rust-based smart-contract language for Polkadot and Substrate. This article is about the Ethereum Layer 2.
Why Kraken built a Layer 2
Ink went live on mainnet on December 18, 2024, months ahead of the early-2025 target Kraken had set, as a member of the Optimism Superchain. The Optimism Foundation granted Kraken 25 million OP tokens, worth about $58 million at the time, to support the integration. CoinDesk quoted Andrew Koller, identified there as Ink’s founder, calling the launch “just the beginning.”
Ink is described as Kraken-incubated, and a nonprofit Ink Foundation supports the network. In its June 2025 token announcement the foundation said its directors were choosing to remain anonymous as a matter of security, according to The Block, so there is no public leadership roster to cite beyond the founder named at launch.
Kraken shows up in the product mainly as distribution. The Ink docs say Kraken charges zero withdrawal fees for Ink network transfers, that Ink does not host its own bridge portal and points users to partner bridges, and that the chain runs an Ink Builder Program with three tracks (Spark, Forge, and Echo).
How Ink works: sequencer, blobs, and fault proofs
Ink follows the standard OP Stack design. A single sequencer orders transactions and produces a block every second: ten consecutive blocks sampled on October 6, 2026 were each exactly one second apart. Batches of transaction data are posted to Ethereum, in the form of blobs or calldata, and claims about the chain state are secured by fraud proofs rather than validity proofs.
L2BEAT classifies Ink as a Stage 1 optimistic rollup (checked October 6, 2026). State claims go through an interactive fraud-proof game in which challengers and defenders pass a clock that starts at 3 days 12 hours, and anyone can propose state roots. All data needed to construct a proof is published on Ethereum, in the form of blobs or calldata. If the sequencer stops, users can force transactions through L1 with up to a 12-hour delay.
L2BEAT also flags the weak spots. Both regular and emergency upgrades need approval from both a Security Council and the Foundation, there is no delay on regular upgrades, and users get no exit window against an unwanted upgrade. A centralized sequencer could also front-run user transactions. Stage 1 means the proof system works and users can exit without the operator. It does not mean the upgrade keys are gone.
🚀 Reading Ink at scale means archive history and traces. Global Nodes on Chainstack serve Ink Mainnet with archive data and
debug_*andtrace_*on paid plans. See Ink on Chainstack.
Verify it yourself
Ink’s public endpoint listed in its docs is enough to check the three claims above. The script reads the chain ID, measures the gap between the last ten block timestamps, and reads the Ethereum block that Ink’s L1Block predeploy says it derived from, then compares it with the Ethereum head. Swap in your own endpoints for production use.
const rpc = async (url, method, params = []) =>
(await (await fetch(url, {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
})).json()).result;
const INK = "https://rpc-gel.inkonchain.com"; // or your Chainstack Ink endpoint
const ETH = "YOUR_ETHEREUM_ENDPOINT";
const chainId = parseInt(await rpc(INK, "eth_chainId"), 16);
const tip = parseInt(await rpc(INK, "eth_blockNumber"), 16);
// Timestamps of the last 10 blocks: every gap should be 1 second
const stamps = [];
for (let n = tip - 10; n <= tip; n++) {
const block = await rpc(INK, "eth_getBlockByNumber", ["0x" + n.toString(16), false]);
stamps.push(parseInt(block.timestamp, 16));
}
// L1Block predeploy: number() returns the Ethereum block Ink derived from
const l1Origin = parseInt(await rpc(INK, "eth_call", [
{ to: "0x4200000000000000000000000000000000000015", data: "0x8381f58a" }, "latest",
]), 16);
const l1Head = parseInt(await rpc(ETH, "eth_blockNumber"), 16);
console.log("chain ID ", chainId);
console.log("gaps (s) ", stamps.slice(1).map((t, i) => t - stamps[i]).join(" "));
console.log("L1 origin ", l1Origin, "| Ethereum head", l1Head, "| behind by", l1Head - l1Origin);Run on October 6, 2026, it printed chain ID 57073, ten gaps of exactly 1 second, and an L1 origin 6 to 7 blocks behind the Ethereum head across runs, which is the sequencer deriving Ink blocks from a very recent Ethereum block.
Fees: an execution fee plus an L1 data fee
Every Ink transaction pays two fees: an execution fee on Ink, and a security fee for publishing its data to Ethereum. The Ink docs say the second is generally the larger one. A plain ETH transfer on October 6, 2026 told a different story. The gas estimate was 21,000, the base fee 268 wei, and eth_maxPriorityFeePerGas returned 1,000,000 wei (0.001 gwei). Across two runs the total estimated fee was about 2.3e-8 ETH, of which the L1 data fee was 1.5e-9 to 2.0e-9 ETH, roughly 7% to 9%. The data cost is small enough that the priority fee dominates.
The practical point is that eth_estimateGas alone covers only the execution side. Use the L1 fee helpers when you need a total, as in the Ink tooling guide. The block gas limit observed was 30,000,000. Ink also documents a paymaster for gasless transactions.
import { createPublicClient, http, formatEther, parseEther } from "viem";
import { ink } from "viem/chains";
import { publicActionsL2 } from "viem/op-stack";
const client = createPublicClient({
chain: ink,
transport: http("YOUR_CHAINSTACK_ENDPOINT"),
}).extend(publicActionsL2());
const tx = { account: "YOUR_WALLET_ADDRESS", to: "YOUR_RECIPIENT_ADDRESS", value: parseEther("0.001") };
console.log("Execution + L1 data fee:", formatEther(await client.estimateTotalFee(tx)), "ETH");
console.log("L1 data fee only:", formatEther(await client.estimateL1Fee(tx)), "ETH");The Ink ecosystem: perps first, lending second
Two flagship apps are tied to the chain’s own team. Nado is a central-limit-order-book DEX for spot and perpetuals with unified margin across both, and it runs on Ink. Tydro is a white-label instance of Aave v3 with Ink-specific incentives. The Block reported its rollout in October 2025, with wrapped ETH, kBTC, USDG, USDT0, and GHO among the supported assets.
The DefiLlama chain page on October 6, 2026 showed $209.9 million in DeFi TVL across 70 protocols (the chart above shows the swing: above $500 million at the early-2026 peak, roughly $120 million over the summer), $169.9 million in stablecoins, $334 million of perpetuals volume and $2.7 million of DEX volume over 24 hours, and about 11,100 active addresses. L2BEAT reports a larger figure, $419.5 million total value secured, because it counts assets differently, with BTC derivatives alone making up 43.8% of it. Treat all three as different yardsticks and check the live pages before quoting any of them.
Third-party DeFi infrastructure keeps arriving. The onchain exchange Aero announced on October 1 that it is coming to Ink:
On October 2, The Graph said Ink is fully streamable with Substreams, so indexers get every block in full detail:
And OpenSea announced trading support for Ink tokens and NFTs the same day:
The INK token: announced, not launched
The Ink Foundation announced an INK token on June 17, 2025. According to The Block, the supply is capped at 1 billion tokens, the cap cannot be changed through governance, and the token will have no role in governing the chain. Its first stated use is liquidity aggregation through an Aave-based protocol, and users have since accumulated points that represent claims on a future airdrop.
The token has not launched. The Ink docs FAQ still says there is no information to share about a token or airdrop, and the foundation has not published a launch date that we could confirm. Everything above describes stated plans only. Gas on Ink is paid in ETH, and the token plays no role in governing the chain.
How Ink compares with Ethereum and other OP Stack chains
Against Ethereum, the differences that matter to a builder are the block cadence, the fee split, and the lack of a public mempool.
| Property | Ethereum | Ink |
|---|---|---|
| Block time | About 12 s | 1 s (ten gaps measured on October 6, 2026) |
| Settlement | Itself | Ethereum, through posted batch data and fault proofs |
| Gas token | ETH | ETH |
| Chain ID | 1 | 57073 |
| Fees | One gas fee | Execution fee plus L1 data fee |
| Mempool | Public | None exposed: pending-transaction subscriptions deliver nothing |
| Tracing | debug_* and trace_*, depending on the client | debug_* and trace_* on op-reth (paid plan on Chainstack) |
Against its OP Stack peers, Ink sits at the same stage on L2BEAT. Its proof setup matches OP Mainnet and Unichain, while Base, which decoupled from Optimism Superchain governance in March 2026, now runs a TEE and ZK multiproof. The table summarizes the figures read from each project’s L2BEAT page on October 6, 2026.
| Chain | Stage | State validation | Forced inclusion | Total value secured |
|---|---|---|---|---|
| Ink | 1 | Interactive fraud proofs, 3d 12h clocks | Up to 12 h | $419.9M |
| Base | 1 | Single-round fraud proofs with a TEE and ZK multiproof (since May 26, 2026) | Up to 12 h | $16.4B |
| OP Mainnet | 1 | Interactive fraud proofs, 3d 12h clocks | Up to 12 h | $2.0B |
| Unichain | 1 | Interactive fraud proofs, 3d 12h clocks | Up to 12 h | $93.6M |
On paper metrics Ink is a near-clone of OP Mainnet. What differs is the product on top, the perps-heavy usage, and the distribution through Kraken. Ink’s docs also say sub-second blocks are coming, without a date.
📖 Related reads: for how OP Stack chains get below one-second confirmations, see What are Flashblocks?. For another trading-platform Layer 2 on a different stack, see What is Robinhood Chain?
Getting RPC access to Ink
The public endpoint in the Ink docs, https://rpc-gel.inkonchain.com, is fine for exploration. On October 6, 2026 it answered as op-reth/v2.5.0-rc.1, rejected eth_getLogs ranges above 1,000 blocks with “block range greater than 1000 max,” and rejected debug_*, txpool_*, and pending-filter calls as “not whitelisted.” It did not rate-limit a burst of 60 parallel requests.
Chainstack added Ink Mainnet on Global Nodes on October 5, 2026, as the release notes record, after earlier availability on Dedicated Nodes. Global Nodes serve archive data, debug_* and trace_* on paid plans, and HTTPS and WebSocket endpoints. Dedicated Nodes remain the option for isolated op-reth infrastructure, and the Unlimited Node add-on suits sustained subscriptions. Chainstack serves Ink Mainnet only: there is no Ink testnet in the console.
Three behaviors differ from a typical EVM chain, all documented in the Ink tooling guide. Pending transactions are never delivered, because they stay with the sequencer. Filters created on a Global Node live on one backend, so poll eth_getLogs over an explicit range or hold a WebSocket subscription. And eth_getProof serves the latest block only.
How to get an Ink RPC endpoint on Chainstack
- Log in to the Chainstack console (or create an account)
- Create a new project
- Select Ink as your blockchain protocol
- Choose Mainnet and Global Node
- Deploy the node
- Open Access and credentials and copy your HTTPS and WebSocket endpoints
🚀 Deploy Ink Mainnet on Global Nodes in the console, or request an isolated node on the Ink page.
Conclusion
Ink is a standard OP Stack chain with a non-standard business model. The technical design is the same Stage 1 setup that OP Mainnet and Unichain run: one sequencer, data on Ethereum, interactive fraud proofs, and a 12-hour forced-inclusion exit. What sets it apart is the stack on top, a derivatives-heavy DeFi ecosystem led by Nado and Tydro, and Kraken as the distribution channel, while the foundation’s directors remain anonymous and the INK token has not launched.
For builders that makes Ink an easy chain to deploy on and a chain whose risk sits in the places L2BEAT already flags: upgrade keys, a centralized sequencer, and unconfirmed token plans. Build for the OP Stack behaviors, which are the L1 data fee, no pending-transaction feed, and short block-count limits, keep ETH-denominated assumptions in config, and put archive reads and traces on an endpoint built for them.
Chainstack serves Ink Mainnet on Global Nodes with archive data, so you can run the checks in this article on your own endpoint.
FAQs
What is Ink?
Ink is an Ethereum Layer 2 built on the OP Stack and incubated by Kraken, part of the Optimism Superchain. It launched on mainnet on December 18, 2024, produces a block every second, uses ETH for gas, and has chain ID 57073.
Is Ink the same as the ink! smart contract language?
No. ink! is a Rust-based smart-contract language for Polkadot and Substrate chains. Ink, the subject of this article, is Kraken’s EVM-compatible Layer 2 and runs standard Solidity contracts.
Does Ink have a token?
An INK token has been announced, with a 1 billion supply cap and no governance role, but it has not launched. Gas on Ink is paid in ETH, and the Ink docs FAQ still says there is nothing to share on a token or airdrop.
How long do withdrawals from Ink take?
Ink does not host its own bridge portal, and its docs point users to partner bridges. L2BEAT describes a fault-proof game in which each side’s clock starts at 3 days 12 hours, so a native withdrawal back to Ethereum is not instant.
Is Ink secure?
L2BEAT rates Ink as Stage 1: fault proofs are live, proposers are permissionless, data is on Ethereum, and users can force transactions through L1. It also flags that upgrades need approval from both a Security Council and the Foundation with no delay on regular upgrades and no exit window, and that a centralized sequencer could extract MEV.
Does Chainstack support Ink?
Yes. Ink Mainnet is available on Global Nodes with archive data and debug_* and trace_* on paid plans, and on Dedicated Nodes for isolated infrastructure. There is no Ink testnet on Chainstack.
Additional resources
- Ink documentation — the official docs, including network information and the builder programs
- L2BEAT: Ink — stage, proof system, and risk summary
- DefiLlama: Ink — live TVL, stablecoins, and volume
- Ink tooling — MetaMask, ethers.js, viem, web3.py, Foundry, and Hardhat setup on Chainstack
- Debug and trace APIs — what is available on Ink
- Ink on Chainstack — protocol facts at a glance
- Chainstack introduces Ink Global Nodes support — the announcement