Indexed InkBlockchain Data
Ink is the OP Stack rollup Kraken built on Ethereum, producing a block every second and posting its batch data as blobs from the first block, with permissionless fault proofs.
How to query Ink data with SonarX
Instant Data Share
Enabled on requestSnowflake, and file dumps to your object storage
Query Ink blockchain data with plain SQL from a live database inside your own Snowflake account, populated with the indexed chain dataset. There is no pipeline to build and no second copy to store. The same dataset ships as file dumps to your own object storage for lakes and warehouses that are not Snowflake.
- Full history as a Snowflake data-share
- File dumps to S3 or your own object storage
Used for:
- Analytics teams already on Snowflake that want Ink data beside their existing tables
- Fund accounting and treasury reporting that reconciles against a fixed history
- Cross-chain questions answered in one SQL statement instead of one query per chain
- Loading Ink history into BigQuery, Databricks, Redshift or a Spark lake
- Replacing a self-hosted indexer and the engineering time that keeps it running
- Serving one governed dataset to several desks without copying it per team
Kafka Streaming
Available todayEvent stream
Consume Ink activity as a continuous stream of normalized records, produced as the chain is indexed instead of polled for.
Used for:
- Trading and execution systems that act on Ink activity within seconds
- Fraud and anomaly detection that has to fire before settlement
- Live dashboards and alerting on Ink wallet or protocol activity
- Feeding a stream processor that already reads from Kafka
- Keeping an internal store hot without waiting for a batch window
- Event-driven services that would otherwise poll on a timer
Balances
Enabled on requestTables and REST
Read what a Ink address held, either as it stands now or exactly as it stood at a past block or timestamp.
- Point-in-time balance tables, as at any block or timestamp
- Real-time balances API for latest and historical balances
- Batch API for wallets, tokens and balances in bulk
Used for:
- Reconstructing Ink portfolios and NAV as at a reporting date
- Audit and reconciliation work that has to be repeatable months later
- Wallet and portfolio products that render Ink balances on page load
- Compliance checks that read one Ink address at one block height
- Refreshing holdings for a whole book of accounts on a schedule
- Tax and cost-basis workflows that need holdings at each event
Realtime API
Enabled on requestREST over the indexed dataset
Query indexed Ink records over REST, reading the same dataset the share reads, with no warehouse in the path.
Used for:
- Applications that need one answer rather than a table scan
- Customer-facing screens where query latency is visible to a user
- Services that have no data warehouse and do not want to run one
- Prototyping against production data before committing to a share
- Backend checks that run per request instead of per batch
- Teams that want indexed Ink data behind their own API layer
Ink data: frequently asked questions
What is Ink?
Ink is an Ethereum Layer 2 built by Kraken on the OP Stack, and it has been producing blocks since December 2024. It is an optimistic rollup with permissionless fault proofs: a sequencer orders transactions, batches are posted to Ethereum, and anyone may challenge a proposed state. Two choices set it apart from its Superchain siblings. Blocks arrive every second rather than every two, which was a deliberate decision for trading and DeFi applications, and the chain has posted its batch data to Ethereum as blobs since its first block, so it has no earlier calldata era. Execution is the EVM, unchanged: twenty-byte addresses, Solidity contracts, the same opcodes as the L1, and gas paid in ETH rather than in a token of its own. Because Kraken operates the network, assets can also move on and off it through the exchange rather than only through the canonical bridge.
Ink data on SonarX
SonarX indexes blocks and headers, transactions and receipts, event logs decoded against contract ABIs, execution traces including internal value transfers, and token transfers and balances. The same normalized model is used on every chain SonarX covers, so Ink joins to the other rollups and to Ethereum without a translation step.
Full historical coverage is provisioned for Ink on request. Balance tables and the balance APIs can be enabled for Ink on request. Kafka streaming carries the same records as a live topic today.
How SonarX indexes Ink
One-second blocks change the arithmetic before they change anything else: at the same transaction volume, a day here produces twice the block rows of a two-second chain, so partitioning and any metric keyed on blocks rather than transactions has to be sized for that. Uniform data availability helps in the other direction. Because batches have been blobs since the first block, reconstructing the chain from L1 follows one rule across the whole history, where older OP Stack chains switched formats partway through. The exchange path is the third consideration: assets moving through Kraken rather than the canonical bridge leave no matching L1 bridge record, so inflow analysis has to treat both routes.
What teams build with Ink data
Requests here come from trading and treasury desks more than from researchers. Flow analysis is the first: following value between the exchange, the canonical bridge and the applications on the chain, which only reconciles when both routes are in the same dataset. Position-level DeFi analytics is the second, since lending and perpetuals venues are what the one-second block time was built for and their state is a sequence of decoded events. Latency research is the third, comparing time-to-inclusion here against Unichain and the two-second Superchain chains, which needs full block history rather than samples. Compliance and monitoring teams use the same records to follow addresses that appear on several rollups at once.
Getting Ink data from SonarX
Tell us the delivery target, how far back you need and how fresh it has to be, and the share is scoped against that. Ink coverage is provisioned on request, so tell us the history depth and the delivery target and we will scope it. The published coverage matrix for every network SonarX indexes lives in the data documentation, and the rest of the catalogue is at all indexed chains.
Is there an Ink data API?
Real-time and batch APIs over indexed Ink data are enabled on request: the same indexed dataset the Snowflake share reads, served over REST once provisioned. Tell us the lookup pattern you need.
How do I get Ink data into Snowflake?
SonarX provisions a data-share into your own Snowflake account. The share appears as a database you query with SQL, so there is no pipeline to build and no second copy to store, and it stays current as SonarX advances the indexing pipeline.
How far back does Ink coverage go?
The historical data-share and file delivery cover the chain's recorded history from its first blocks in December 2024 forward, and are provisioned on request. Because the chain is young and dense, that history is a manageable backfill rather than a multi-year one.
Is Ink EVM-compatible?
Yes, fully. Ink runs the OP Stack, which means the EVM, ordinary twenty-byte addresses and standard Solidity contracts. Coverage tables that group Ink under a non-EVM heading are describing how SonarX models the dataset, not the chain: anything that works against another EVM rollup works here, including ABI decoding and proxy resolution.
Do exchange transfers and bridge transfers look the same on Ink?
No, and it changes flow analysis. Value can arrive through the canonical bridge, which has a matching record on Ethereum, or through Kraken, which supports moving assets to and from Ink directly. The second path appears on the chain as ordinary transfers from exchange-controlled addresses, so a model that counts only canonical bridge events will understate what actually arrived.