Ink Data: Index DeFi Contracts, Tokens, and Onchain Activity

Index Ink's contract events, token transfers, and decoded transactions in one pipeline, delivered to your own database. Real-time and complete historical data, no node to run.

Ink calls itself DeFi unleashed by Kraken, an Ethereum Layer 2 built on the OP Stack and part of the Optimism Superchain. Kraken built it to move its large exchange user base onchain, pairing roughly one-second blocks and cheap, ETH-denominated gas with a DeFi-first app stack. That focus is why lending, perps, and yield activity cluster here rather than spreading across a generic L2. You can read how the team frames it at inkonchain.com.

The DeFi concentration is exactly what makes the data dense. Ink is an EVM rollup where swaps, lending positions, and token transfers stream out block after block, and the protocols that matter sit behind proxies and custom event schemas. Indexing Co covers Ink in a single pipeline, decodes the raw chain into the shape you want, and delivers it to your own PostgreSQL, warehouse, or webhook. Real-time and full history, with no node to operate.

Source Ink L2 blocks

Ingest blocks, logs, traces

Decode ABIs to events

Transform your JavaScript

Deliver your database

Why Ink data is hard

DeFi-Dense Event Streams Ink's whole reason for existing is DeFi, so the meaningful activity is lending draws, perp fills, swaps, and liquidity moves rather than a thin spread of one-off transfers. Nado's order book and Tydro's Aave-style markets each emit their own tightly typed events, and reconstructing positions means decoding all of them in order without dropping a block.

OP Stack and Superchain Specifics Ink is an OP Stack rollup that batches transactions and settles back to Ethereum L1, and it was the first Superchain network to ship permissionless fault proofs with multiple challengers. Sequencer ordering and the L1-to-L2 deposit and withdrawal lifecycle add structure that a naive EVM scraper misses. You want history that reflects how the rollup actually settles.

Bridged Assets and Cross-Chain Flow Most value on Ink arrives by bridge, with ETH and USDC moving in from Ethereum and across the Superchain before it ever touches a protocol. Following a token from a deposit through a swap and into a lending vault means tracking bridge events alongside protocol events, which a single-contract scraper cannot stitch together.

Your Own DB, Not a Hosted API Generic RPC endpoints and hosted query APIs leave you rate-limited and renting someone else's schema. Powering a DeFi dashboard, points program, or risk model on Ink means owning the data in your own store, shaped the way your product queries it, not paginating against a public endpoint.

What Indexing Co delivers for Ink

The DIY Path

Stand up and maintain the whole stack yourself.

Run an Ink archive node or wire up a third-party RPC.
Fetch and decode logs, traces, and receipts against the right ABIs.
Track proxy upgrades and per-protocol event schemas by hand.
Build backfill, reorg handling, and real-time delivery from scratch.

Indexing Co

One pipeline sources, decodes, and delivers Ink to your store.

Ink contract events, token transfers, and decoded txs in a single pipeline.
Decoded data, shaped by your JavaScript transform.
Lands in your PostgreSQL, BigQuery, warehouse, or webhook.
Real-time delivery plus complete backfilled history. No node, no RPC babysitting.

What you can index

EVM data type	On Ink, for example
Contract events and logs	Nado order fills and perp trades, Tydro supply and borrow events
Token transfers (ERC-20, ERC-721)	USDC and ETH movements, ZNS .ink domain mints
Decoded transactions and traces	Bridge deposits, smart-wallet user operations
Protocol and account state	Tydro lending positions, Nado margin balances

A transform, not a subgraph

You write the transform in JavaScript, not AssemblyScript, and change it without re-indexing from block zero. Indexing Co runs your function over each block server-side: decode the logs you care about and return rows for your destination.

// Indexing Co transform: reshape each block into rows for your database
function transform(block) {
  const results = [];
  const signatures = [
    'event Transfer(address indexed from, address indexed to, uint256 value)'
  ];

  for (const tx of block.transactions || []) {
    for (const log of tx.receipt?.logs || []) {
      const event = utils.evmDecodeLogWithMetadata(log, signatures);
      if (!event) continue;
      results.push({
        chain: block._network,
        block: Number(block.number),
        tx_hash: tx.hash,
        contract_address: log.address?.toLowerCase(),
        from: event.decoded.from,
        to: event.decoded.to,
        value: event.decoded.value,
      });
    }
  }
  return results;
}

Ink with Indexing Co

Run it yourself if

You want full control of node infrastructure and have the team to operate an Ink archive node, decode every protocol's ABIs, and build backfill and reorg handling in-house.

Use Indexing Co if

You want Ink contract events, token transfers, and decoded transactions delivered to your own database, with real-time plus complete history and no infrastructure to run.

Get a Demo Open the Console

FAQ

Do I need to run an Ink node?

No. Indexing Co sources Ink blocks, logs, and traces for you, including full historical data, so you never operate an archive node or babysit an RPC endpoint.

Can I index any protocol on Ink?

Yes. Point a pipeline at any Ink contract or set of contracts, from Nado and Tydro to ZNS or your own deployments, and we decode the events against the right ABI.

Does Indexing Co handle Ink reorgs and proxy upgrades?

Yes. The pipeline accounts for chain reorganizations and tracks proxy implementation changes so your decoded data stays correct as contracts upgrade.

Where does the Ink data go?

Into your own destination: PostgreSQL, BigQuery, a warehouse, or a webhook. You define the output schema and own the storage.

Can I get complete historical Ink data?

Yes. We backfill from your chosen start block and merge it with real-time data, so your Ink dataset is gap-free from genesis forward if you want it.

Get Started

Index Ink in minutes. Set up your first Ink contract or token pipeline without running a node.