Products

Data Access Portal API SQD Network Supported Chains

Development SDK SQD Cloud SQD 360

Solutions

By Use Case DeFi & Trading Analytics AI Agents Wallets & Payments Compliance All Solutions

By Industry Stablecoins RWA All Customers

Developers

Get Started Documentation Subsquid Subsquid Labs Dev Chat

Resources

Learn Guides Compare Blog Videos Changelog

Company About Ecosystem Brand Assets

Customers Pricing

Talk to us

Home / Solutions / RWA

RWA

Onchain data for tokenized assets: issuance, transfers, and control events

A tokenized treasury fund is a regulated security that lives on a public chain. SQD serves the events it emits, issuance, transfers, and the issuer's own control events, decoded and keyed by topic0, across 225+ networks. The events a curated token API leaves out are the ones a monitoring desk needs.

Talk to us See a real fund, decoded

225+ Networks

Every log Standard + issuer events

Per-chain Pinned contracts

Genesis Full history

Trusted by leading teams

The problem

A tokenized treasury fund's onchain record is the events its contract emits

Every mint, redemption, transfer, and freeze is a log the fund's contract writes onchain, decodable against its ABI. Beyond the ERC-20 Transfer, BUIDL pairs each mint with an Issue event, and ERC-3643 (T-REX) tokens emit a shared compliance vocabulary of freezes, pauses, and recoveries. Curated token APIs are built around the ERC-20 surface of transfers and balances, so those issuer control events tend not to be exposed as queryable, decoded data. Reading the logs directly off the Portal is what returns the events a monitoring desk needs.

A real fund

BlackRock's BUIDL, its onchain life in one query

BUIDL is the BlackRock USD Institutional Digital Liquidity Fund, a tokenized money-market fund (0x7712...2aec). It is permissioned: only approved wallets hold it, and each share tracks a dollar. One bounded query returns every BUIDL log in a block. At block 25,344,852 it distributed yield by minting new shares to 33 whitelisted wallets in a single transaction, each a separate mint:

Daily yield issuance new shares (BUIDL)

0xed71…cf72 4,693.97
0xf2f4…510f 871.21
0xe6a8…13b8 499.56
0x12c0…b0b4 362.81
0xce90…ada6 262.96
and 28 more in the same transaction, down to 0.03 BUIDL

Real, from transaction 0x9214…0e2d (2026-06-18). Each row is a Transfer from the zero address, the largest 4,693.97 shares.

The query is one filter on the asset's contract over one block. No node, no per-issuer integration:

your terminal

curl -s -X POST https://portal.sqd.dev/datasets/ethereum-mainnet/stream \

-H 'content-type: application/json' \

-d '{

"type": "evm",

"fromBlock": 25344852, "toBlock": 25344852,

"logs": [{ "address": ["0x7712c34205737192402172409a8f7ccef8aa2aec"] }],

"fields": { "log": { "topics": true, "data": true, "transactionHash": true } }

A monitoring agent reads the issuance off the Transfer-from-zero rows, matching topic0 to the known ERC-20 signature. The same query on a wider window is the fund's full issuance and transfer history. Pinned to a fixed block, you can run it and get exactly this.

Beyond Transfer

The control events a curated API leaves out

A regulated token emits more than transfers, and the extra events ride in the same log stream. Every BUIDL mint is paired with an Issue(address,uint256,uint256) event the standard ERC-20 ABI does not recognize. Tokens built on the ERC-3643 (T-REX) standard emit a shared compliance vocabulary:

EventWhat it records

AddressFrozenAccount frozen or unfrozen
TokensFrozenPartial balance frozen
PausedTransfers halted
RecoverySuccessTokens recovered to a new wallet

ERC-3643 (T-REX) compliance events, signatures from TokenySolutions/T-REX

The Portal hands back every log keyed by topic0, the standard ones and the issuer-specific ones alike; you decode the issuer events against the ABI. Curated token APIs are built around the ERC-20 surface (transfers and balances), so these control events tend not to be exposed as queryable, decoded data. That is the harder thing, and it is the point of reading logs directly off the Portal.

One gotcha: pin the per-chain contract, not the ticker. An event signature is global, and the same symbol can resolve to a different token on another chain. Resolving BUIDL on Base does not return BlackRock's fund; it lands on an unrelated token with 18 decimals instead of 6, so a symbol-based filter would watch the wrong contract and misread every amount.

What the data is, and isn't

Movement and control events, not balances or reserves

Events, not a balance series

The data is the events the contract emits: issuance, transfers, control actions, each with a block and a transaction. Holder positions over time, concentration ratios, and NAV are aggregations you build on those rows, not fields the API returns.

Onchain trail, not proof of reserves

Onchain events attest to onchain actions only. The BUIDL issuance proves shares were minted to those wallets; it does not prove the offchain treasuries behind them. A precise, timestamped trail of onchain activity, kept separate from proof of reserves. See the full walkthrough in the RWA monitoring guide.

Asset class coverage

Any tokenized asset, the same query shape

SQD does not gate which RWA protocols are supported. Any tokenized contract on a supported chain is indexable through the same decoded-log query.

Tokenized treasuries T-Bills, government bonds, and money-market funds: issuance, redemption, and yield-distribution events

Real estate Fractional property tokens: rental-yield distributions, ownership transfers, and cap-table changes

Private credit Onchain lending facilities: draw-down, repayment, and default-monitoring events

Commodities Tokenized gold, carbon credits, and commodity derivatives with settlement events

Fund shares Tokenized LP positions and fund participation units with subscription and redemption flows

Permissioned standards ERC-1404 and ERC-3643 / T-REX allowlist and transfer-restriction events, decoded

Capabilities

Built for RWA at scale

Asset lifecycle in the log stream

Issuance (a Transfer from the zero address), redemptions, transfers, and the issuer's own events, each with the exact block and transaction. The same query over a wider window is the asset's full issuance and transfer history, decoded from one endpoint.

Issuer control events, not just transfers

A regulated token emits more than Transfer. BUIDL pairs each mint with an Issue event; ERC-3643 (T-REX) tokens emit AddressFrozen, TokensFrozen, Paused, and RecoverySuccess. The Portal hands back every log keyed by topic0, the standard and issuer-specific alike, to decode against the ABI.

Cross-chain, one query shape

A fund deployed on Ethereum, Polygon, and Arbitrum is the same decoded-log query with the dataset name and per-chain contract swapped. Pin the per-chain address: an event signature is global, and the same ticker can resolve to an unrelated token on another chain.

Built for your own models

The data is the events the contract emits, not a reconstructed per-holder balance series. Holder positions, concentration ratios, and NAV are aggregations you build on your own rows, from the issuance and transfer history the Portal serves.

Why SQD

What you would build yourself

The events a regulated asset emits are public and onchain. The work is in reading the ones a curated token API is not built to expose.

Building it yourself With SQD

Issuer control events
Yourself Curated token APIs are built around the ERC-20 surface of transfers and balances, so issuer events like Issue or a T-REX freeze are not exposed as queryable, decoded data.

With SQD The Portal hands back every log keyed by topic0, the standard events and the issuer-specific ones alike, to decode against the ABI.
Contract vs ticker
Yourself A symbol-based filter watches the wrong contract: BUIDL on Base resolves to an unrelated token with 18 decimals instead of 6, so every amount is misread.

With SQD Pin the per-chain contract, and the same decoded-log query runs on each chain with only the dataset name and address swapped.
Issuance history
Yourself Reconstruct a fund's mint and transfer history from a node or a per-issuer integration, one setup per asset.

With SQD One filter on the asset's contract returns every issuance and transfer; the same query on a wider window is the full history from genesis.
Protocol coverage
Yourself A curated provider maintains a fixed list of pre-integrated RWA protocols; an asset it has not added is not queryable.

With SQD Any tokenized contract on a supported chain is indexable through the same decoded-log query, with no gate on which protocols are supported.

See this on your own contracts

Tell us the chains and contracts you care about, and we will show you the query that returns them.

Talk to us Try the public API

Use cases

What teams build with SQD

Tokenized treasury and fund issuance dashboards
Issuance and redemption tracking with block-level evidence
Issuer control-event monitoring (freezes, pauses, recoveries)
Transfer-restriction and allowlist event trails
Cross-chain asset reconciliation for multi-chain deployments
Inputs for NAV and holder models you build on your own rows

Background reading

Tokenized stocks on Robinhood Chain: equities as ERC-20 tokens

Robinhood issues tokenized stocks as plain ERC-20s on its Arbitrum Orbit L2: the contracts behind TSLA, NVDA, and the SpaceX token, issuance and redemptions at the zero address, and a real after-hours trade read straight from the chain.

ERC-8056: how tokenized stocks split onchain

The scaled-UI standard behind Robinhood stock tokens: uiMultiplier, TransferWithScaledUI, and the first real multiplier changes read from the chain, including a 2:1 adjustment scheduled for a Monday market open.

RWA monitoring agents: tracking tokenized-asset events across chains

Permissioned tokens emit compliance events a stablecoin never does. Monitor freezes, pauses, and recoveries across every chain an asset lives on.

Frequently asked questions

How does SQD index tokenized RWAs?

Point a query, or a Squid SDK indexer, at the asset's contract address per chain, and the Portal returns every log it emits: mints (a Transfer from the zero address), redemptions, transfers, and the issuer's own events, decoded against the ABI. Holder positions and NAV are aggregations you build on those rows, not fields the API returns.

Which RWA protocols are covered?

SQD does not maintain a curated list of pre-integrated RWA protocols. Any tokenized RWA contract on a supported chain is indexable: tokenized treasuries, money-market funds, real-estate tokens, private-credit positions, and permissioned standards (ERC-20, ERC-1404, ERC-3643 / T-REX) all use the same query shape. You index the specific contracts you care about; SQD does not gate which protocols are supported.

Can I get a verifiable trail of a tokenized asset's activity?

Yes: every issuance, transfer, and control event the contract emits, each with its exact block and transaction hash, which you can verify against the chain itself. For permissioned tokens, allowlist and transfer-restriction events are decoded alongside transfers, evidence that transfers occurred between approved holders. This is an onchain activity trail, not a proof that the offchain assets exist; keep proof-of-reserves separate.

How does the data flow into ERP or accounting systems?

SQD outputs to standard databases and warehouses: PostgreSQL and ClickHouse via the Squid SDK; MongoDB, SQLite, Parquet, BigQuery, Snowflake, Databricks, and any custom sink via the Pipes SDK. ERP and accounting systems integrate against these databases the same way they would any other transactional source. SQD provides the onchain side; the join with off-chain identity, custody, or KYC data happens in your existing systems.