Indexed PlumeBlockchain Data
Plume is an Arbitrum Orbit Layer 2 built for tokenized real-world assets, where token contracts check eligibility before a transfer settles and issuers keep powers an ordinary ERC-20 does not grant.
How to query Plume data with SonarX
Instant Data Share
Enabled on requestSnowflake, and file dumps to your object storage
Query Plume 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 Plume 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 Plume 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
Enabled on requestEvent stream
Consume Plume 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 Plume activity within seconds
- Fraud and anomaly detection that has to fire before settlement
- Live dashboards and alerting on Plume 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 Plume 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 Plume 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 Plume balances on page load
- Compliance checks that read one Plume 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 Plume 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 Plume data behind their own API layer
Plume data: frequently asked questions
What is Plume?
Plume is an EVM Layer 2 whose mainnet went live in 2025, built on the Arbitrum Orbit stack and settling to Ethereum. Execution is ordinary EVM: Solidity contracts, twenty-byte addresses, receipts and event logs in the shapes an EVM pipeline already reads. What is not ordinary is what gets deployed on it. Plume was built for tokenized real-world assets, so a large share of its token contracts are permissioned: they check eligibility before a transfer settles, and the issuer keeps powers an ordinary ERC-20 does not grant, including pausing, freezing, forced redemption and minting against an offchain event. PLUME is the network’s token. Valuations and attestations about the underlying assets are published onchain as contract writes, which means a figure recorded here is a stated value with a timestamp rather than a market quote.
Plume data on SonarX
SonarX indexes Plume end to end: 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 a tokenized position here joins to holdings elsewhere without a translation layer.
Full historical coverage is provisioned for Plume on request. Balance tables and the balance APIs can be enabled for Plume on request. Kafka streaming can be enabled for Plume on request.
How SonarX indexes Plume
Transfer events do not tell the whole story of who owns what on this chain. Ownership also changes through issuer actions, so mints against a subscription, freezes, forced redemptions and pauses have to be decoded and carried alongside transfers or a holder register drifts from reality within weeks. Those contracts are usually upgradeable, so decoding follows the implementation behind the proxy rather than the address that emitted the log, and a change of implementation mid-history changes the event vocabulary without changing the address. Attempted transfers that revert on an eligibility check matter too: a rejection is evidence about a holder, not an absence of activity.
What teams build with Plume data
The work here looks like asset servicing rather than like crypto analytics. Holder registers come first: who held which instrument at which block, restated as at a reporting date and reconciled against the issuer’s own record. Distribution accounting is the second, following coupon, yield or redemption payments from the contract that released them to the accounts that received them. Audit trails are the third, since a supervisor asking why an account could not receive a token wants the eligibility check that rejected it, not a summary. That work is what RWA and tokenization analytics cover across every chain SonarX indexes, and teams comparing issuance venues usually pull MANTRA alongside this one.
Getting Plume 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. Plume 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 a Plume data API?
Real-time and batch APIs over indexed Plume 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 Plume 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 Plume coverage go?
The historical data-share and file delivery cover Plume's recorded history from its 2025 mainnet launch forward, and are provisioned on request.
How does SonarX handle permissioned tokens on Plume?
As first-class records rather than as failed transfers. A tokenized asset can restrict who may hold it, so a transfer may revert on an eligibility check, and the issuer can mint, pause, freeze or redeem outside the usual transfer path. SonarX decodes those administrative calls against the implementation behind each proxy, so a holder register reconstructed from the data matches the one the issuer keeps.