Ink RPC: A Developer's Guide (Chain ID 57073)

Ink is Kraken's Ethereum layer 2, an OP Stack chain in Optimism's Superchain with one-second blocks and gas paid in ETH. Standard Ethereum tooling works unchanged. Two things catch developers out: the gas price the node suggests is far higher than what transactions on the chain actually pay, and the chain emits so many logs that unfiltered eth_getLogs runs into a result cap long before it runs into a block-range cap.

This guide is measured against the live chain on October 12, 2026, through the same endpoint SwiftNodes customers use.

The endpoint

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

viem ships Ink as a built-in chain:

import { createPublicClient, http } from "viem";
import { ink } from "viem/chains";

const client = createPublicClient({
  chain: ink,
  transport: http("https://rpc.swiftnodes.io/rpc/ink?key=YOUR_API_KEY"),
});

What we measured

Fees: don't take the suggested tip

eth_maxPriorityFeePerGas returns 1,000,000 wei and eth_gasPrice returns 1,000,297 wei (the base fee plus that tip). Neither reflects the market. Across the last 1,024 blocks of eth_feeHistory, the median of each block's median tip was 3,142 wei. The typical 10th-percentile tip was 0 and the typical 90th-percentile tip was 30,000 wei. The suggested tip is about 318 times the typical one.

That matters because many libraries fill maxPriorityFeePerGas from eth_maxPriorityFeePerGas by default. For a plain transfer:

The L1 data fee comes from a real transfer receipt from the same morning (l1Fee 723,601,447 wei), with ETH at $2,562. With the median tip, the L1 fee is about 90% of the bill. With the suggested tip, execution becomes 97% of it.

Blocks are usually light but not always: 34 of the last 1,024 were more than half full, and the busiest was 84% full. That is enough to move the base fee off its floor (it ranged from 253 to 297 wei) but not enough to make inclusion competitive. Set the tip from fee history instead of the suggestion:

const { reward, baseFeePerGas } = await client.getFeeHistory({
  blockCount: 20,
  rewardPercentiles: [75],
});
const tip = reward!.map((r) => r[0]).sort((a, b) => (a < b ? -1 : 1))[10]; // median of p75 tips
const maxFeePerGas = baseFeePerGas.at(-1)! * 2n + tip;

await wallet.sendTransaction({ to, value, maxPriorityFeePerGas: tip, maxFeePerGas });

The L1 data fee is charged on top regardless of the tip. Ink's fee oracle at 0x420000000000000000000000000000000000000F reports a baseFeeScalar of 4,424 and a blobBaseFeeScalar of 810,831. At October 12 prices that splits the L1 cost roughly 58/42 between Ethereum's execution base fee and its blob fee, so it moves with both. Use getL1Fee on the oracle to estimate it before sending, and read l1Fee from the receipt for the actual charge. Receipts also carry the newer daFootprintGasScalar field.

Logs: a result cap, not just a range cap

Ink is busy for its size. In 100 sampled blocks there were 610 user transactions, about six a second, and the last 100 blocks emitted 5,198 logs. One contract accounted for 2,935 of them, more than half.

That density means the binding limit on eth_getLogs is the number of results. An unfiltered 1,000-block query was refused every time we tried:

-32602 query exceeds max results 20000, retry with the range 58284986-58285696

The error names a range that fits, here 711 blocks, so a client can retry with it directly. The ranges we tested returned:

The answering node varies, and limits vary with it. One of them also rejected ranges over 1,000 blocks outright (block range greater than 1000 max), while another returned 10,000 blocks in a single 122 MB response. Code for the strictest case: 1,000 blocks at most per request, fewer when unfiltered, and parse the suggested range out of the error.

async function getLogsAdaptive(from: bigint, to: bigint, filter = {}) {
  const out = [];
  let start = from;
  while (start <= to) {
    let end = start + 999n > to ? to : start + 999n;
    try {
      out.push(...(await client.getLogs({ ...filter, fromBlock: start, toBlock: end })));
      start = end + 1n;
    } catch (e: any) {
      const m = /retry with the range (\d+)-(\d+)/.exec(e?.details ?? e?.message ?? "");
      if (!m) throw e;
      end = BigInt(m[2]);
      out.push(...(await client.getLogs({ ...filter, fromBlock: start, toBlock: end })));
      start = end + 1n;
    }
  }
  return out;
}

Filter by address whenever you can. The same 1,000 blocks filtered to WETH (0x4200000000000000000000000000000000000006) returned 276 logs in about a second. For decoding what comes back, see decoding event logs, and for other chains' limits, our getLogs range cap survey.

History and tracing

Ink's nodes keep full history. eth_getBalance at block 1 answered. debug_traceBlockByNumber with callTracer returned full traces near the head, at block 1,000,000 and at a block a third of the way through the chain's history, and Parity-style trace_block works too. Ink is one of the OP Stack chains where both tracing families are available through our endpoint.

Finality

safe trailed the head by 358 blocks (about 6 minutes) and finalized by 2,054 blocks (about 34 minutes). Both are longer than on many OP Stack chains. If you credit deposits on finalized, budget over half an hour. In our halt survey across 110 chains, Ink had no gap of 10 minutes or more between August 25 and October 6. For background, see soft vs hard finality on L2s.

Summary

• OP Stack chain, chain ID 57073, ETH for gas, 1-second blocks.
• The node suggests a 1,000,000-wei tip; the median paid is about 3,000 wei. Set tips from eth_feeHistory.
• At the median tip a transfer costs about $0.002, mostly L1 data fee.
• eth_getLogs is capped at 20,000 results; unfiltered queries hit it within a few hundred blocks. Filter, page, and use the range the error suggests.
• Full archive with debug_* and trace_*; finalized is about 34 minutes behind.

Ink endpoints and status are on our Ink RPC page, alongside the rest of the 128 chains on one key. SwiftNodes has a free tier to try it.