INDX

Invest in the market, not the project. INDX builds ETF-style indexes of Robinhood Chain projects

[INDX @INDXdepth]

https://t.co/sgT1UnvFdR

[INDX @INDXdepth]

Can't decide which Robinhood Chain microcap to back? Don't. Own all of them.

INDX Small Cap Utility-ETF is one token that holds a basket of 10 micro-cap Robinhood Chain projects:

$ORBIO $INDEX $WALLET $DELTA $MUSEBOOK $STANDARD $PRISM $STATICS $HOOKR $PROLOGUE, plus a slice of USDG.

Think of it like an index fund or ETF, but onchain, 24/7, and with its own market-making Engine built in.

Why a basket beats picking one

Microcaps move hard in both directions. Picking one is a coin flip on which team ships, which chart runs, and which one quietly dies.

With INDX you don't have to guess:

📈 One runs, you're in it. If a project with a 10% weight doubles, your whole position is up about 10%, without needing to have picked it.
📉 One dumps, it's cushioned. If a project with a 10% weight goes to zero, you're down about 10%, not 100%. No single project can make up more than 15% of the basket.
🔁 It stays balanced. Every project has a target weight and a band around it. When one drifts out of line, the Engine pulls it back.
🔍 The line-up is reviewed. Every 30 days the basket is re-screened against a published methodology: Robinhood Chain utility projects under a $50M market cap. Projects can come in and go out.

The Engine: what makes INDX different

Most index products are passive. INDX isn't.

⚙️ INDX runs its own trading pools for every project in the basket, powered by a Uniswap v4 hook we call the Engine.
💧 Part of the basket (Depth) sits in those pools as liquidity, so INDX helps make the markets it holds.
🎯 The Engine watches every project's weight and adjusts the pool fees to match. If the basket holds too much of a token, buying it from the pool gets cheaper and selling into it gets dearer, so normal trading pulls the basket back to target.
💰 The trading fees those pools earn go back into the basket, which lifts the value of every INDX.

Other baskets pay to rebalance. INDX gets paid to.

🔜 Coming soon: Settlement. Hold INDX and earn a share of the Engine's fees, paid out in USDG.

What it means for you

✅ Exposure to the whole Robinhood Chain small-cap scene in one click
✅ No research rabbit hole, no picking winners
✅ Rebalancing done for you, automatically, onchain
✅ The basket earns trading fees while you hold
✅ Everything is visible: live NAV, history charts, every swap and fee, all read straight from the chain

What you need

✅ USDG on Robinhood Chain (minimum $5)
✅ A little ETH on Robinhood Chain for gas (about $1)

How to get INDX

1️⃣ Go to https://t.co/ACuNyu75UP → Launch app
2️⃣ Connect your wallet. If you're on the wrong network, it asks to switch you to Robinhood Chain. Say yes.
3️⃣ Click Deposit and type how much USDG
4️⃣ The app shows exactly what it'll buy for you, and the network fee, and fills in everything else
5️⃣ Tick the box → Deposit → your wallet asks twice (approve, then deposit)

That's it. INDX Small Cap Utility lands in your wallet.

Where are my INDX?

📊 In the app, open Portfolio to see your INDX, what they're worth, and exactly how much of each project you own.
🦊 In MetaMask, go to Import tokens and paste the INDX address:
0x100Df87128Be9A3D0A30f86493723248569d206f

How do I get out?

Withdraw tab → pick how much → get it back as USDG, or as the 10 tokens themselves.
Taking it back as the 10 tokens can never be switched off, by anyone.

🎥 Watch the full walkthrough below
🌐 https://t.co/ACuNyu75UP

[INDX @INDXdepth]

Charts and history are live on INDX 📈

This morning we said it was running locally. It's now in production.

What's new in the app:

📈 NAV per share, TVL and Engine Depth, charted back to launch
📊 Hourly volume for every market
🔁 Every swap per market: size, direction, the fee the Engine charged, and who traded
🧾 A cleaner activity feed: one line per deposit or withdrawal, fee changes only when a fee actually moves, each Engine cycle as a single entry

Why this, why now:

Until today the app showed you the index as it is right now. Live NAV, live Depth, live fees. What it couldn't show was how it got there.

An index you can't look back on is an index you have to take on trust. We'd rather you didn't have to.

So everything on these charts comes straight from the chain. NAV is read from the contracts at past blocks, hour by hour since launch. Volume is built from the Flow events our Engine hook emits on every swap, not estimated from prices.

You'll notice two gaps in the NAV line. We left them in on purpose:

⛔ Sep 24, ~5h: launch day. PRISM's price oracle went stale when bot trading overwrote its price history faster than the oracle could use it. We gave the pool a longer history and it's been solid since.
⛔ Sep 25, ~2h: our keeper ran out of gas and stopped recording prices. Topped up, back within minutes.

In both, the contracts refused to price the index rather than guess. Deposits paused; withdrawals kept working, because they never need a price. A chart that joined those dots would be showing you prices the index never had.

It's also how you check the Engine is doing its job: you can watch fees move, see the flow they pull in, and follow Depth over time, market by market.

Launch → live Engine → live stats → full history. Every piece is on the chain, and now you can see all of it.

https://t.co/UNB3uz3DXC

[INDX @INDXdepth]

@RobinhoodApp talking index options this week. timing's funny.

because what a lot of people haven't clocked yet is how much of that index world is already sitting onchain.

gold, silver, oil, treasuries. robinhood has all of them live on Robinhood Chain as tokenized ETFs, trading 24/7, priced by chainlink.

right now they mostly just sit in pools, and people trade them one at a time.

nobody has put them together yet.

we've spent the week looking at exactly that. how the tokens behave, what the issuer can and can't do to them, where the liquidity actually is, and what an index needs to hold them safely.

the answer turned out to be the same Engine we launched INDX with, plus a few things real-world assets need that crypto doesn't.

contracts are built. tests are green.

onchain, indexes can hold a lot more than crypto.

more soon.

[Robinhood @RobinhoodApp]

Trading the Nasdaq-100 goes beyond ETFs.

Mat Cashman and @Nasdaq's Kevin Davitt break down how NDX and XND index options work, how they differ from ETF options, and how traders can use them to express a market view and manage risk.

[INDX @INDXdepth]

Today on INDX: charts and history.

Until now the app has shown you the index as it is right now: NAV, TVL, Depth, fees, all read live from the chain. What it couldn't show was how it got there.

The catch: history isn't something you can read from a contract. The chain only knows the present. To draw a chart you have to go back and ask what the index was worth at every point along the way.

So we built an indexer that does exactly that. It replays the chain from the launch block and calls the router, vault and share contracts at past blocks, rebuilding hourly NAV per share, TVL and Engine Depth back to day one. After that it takes a fresh snapshot about every 10 minutes.

Volume works the same way. Every swap through an INDX pool fires a Flow event from the Engine's hook, so each market's volume is built from real trades, not estimates.

Coming to the app today:
📈 NAV, TVL and Depth history since launch
📊 Hourly volume for every market
🔁 Every swap per market: size, direction, fee
🧾 A cleaner activity feed: one line per deposit, fee changes only when they move

Running locally already. Today it goes to production 🔧

Oh, and someone said new basket? 👀

Small Cap Utility was the first. It won't be the last. Same Engine, same Depth, a whole new set of markets.

RWA season incoming?

More soon.

[INDX @INDXdepth]

INDX dev log, day 2

This morning we showed the Engine running. It's a Uniswap v4 hook on every INDX pool. beforeSwap returns a fee override on each swap, based on where
that market's inventory sits against its band. Overweight markets get a cheaper buy fee and a dearer sell fee;

underweight markets get the reverse. The base fee is 0.30%, bounded between 0.05% and 2%. afterSwap emits a Flow event for every trade, so volume comes straight from chain events rather than being estimated.

Buybacks. We did our first INDX buybacks today.

Pool sync shipped. There's a new PoolSync contract, deployed with CREATE2

- PoolSync: https://t.co/pD0acw7yL6
- Keeper swap route (UniV2V3Venue): https://t.co/RJiY6uPD8H

Before the Engine adds Depth, the keeper compares each pool's price to the oracle. If a pool has drifted, it swaps through the PoolManager with sqrtPriceLimit set to the oracle price, so the pool can't overshoot. Empty pools are skipped, and each pool runs on its
own so one revert can't block the rest.

All 8 pools with liquidity synced on the first run. The Engine also refuses to add Depth to any pool more than 1% off the oracle.

Keeper hardening. The keeper is one process on three timers: price records every 250s, pool sync every 20 minutes, and an Engine cycle (updateAllFees → allocateDepthMany) every 4 hours.

Each transaction now goes through its own queue with a 30s RPC timeout and a bounded wait for its receipt, so one slow call can't stall the jobs behind it. The faster price recording keeps the v4 TWAP fed: it needs 5 observations in a 30-minute window.

PRISM oracle fix. The PRISM v3 pool's TWAP went stale because bot trading was overwriting its 128 price observations faster than the oracle's window. We raised its observation
cardinality to 400, and pricing recovered.

Engine stats on the app. Every market shows its Depth, utilization, live buy and sell fees, and 24h Flow. 24h Flow is one eth_getLogs over about 860k blocks of hook Flow events, keyed by pool id, summing the USDG side of each swap. There's no backend in the way.

App fixes. Wallet disconnect and switch account, a wrong-network fallback instead of a blank page, and a fix for a deposit showing "failed" when it had actually gone through.

Gas estimates now have headroom, and receipt polling carries on through RPC errors instead of giving up. Earnings is marked "Soon" until settlement is live. The docs list every deployed contract.

Tomorrow: charts and history. It's running on locally now:

- The indexer calls the router, vault and share at past blocks to rebuild hourly NAV per share, TVL and Engine Depth back to the launch block. While it follows the chain, it adds a snapshot every 6,000 blocks, about every 10 minutes. Hours when the index couldn't be priced are left as gaps, not zeros.

- Hourly volume per market, from Flow events bucketed by pool id and read on the USDG side.
- Every swap listed per market, with size, direction, fee and trader.
- A cleaned-up activity feed. The indexer logs every event, so the feed shows one line per deposit or withdrawal, a fee change only when a fee actually moved, and each Engine cycle's Depth moves as a single line.

Next step is hosting the indexer, then it goes live.

[INDX @INDXdepth]

Three $INDX buybacks executed onchain today.

Alongside everything we’ve been shipping across INDX, we’ve also been steadily putting capital back into the market.

Today was simple:

→ Buyback 01 executed
→ Buyback 02 executed
→ Buyback 03 executed
→ all three settled on Robinhood Chain

TX 01
https://t.co/LqoQH1B0Th

TX 02
https://t.co/dGtwYIRNaz

TX 03
https://t.co/yadjDkfs3G

We’re building the index, the markets underneath it, and the economics around it at the same time.

Three buybacks today.

Back to shipping.

[INDX @INDXdepth]

Shipped: live Engine stats in the INDX app.

Every one of the Engine's nine markets now shows exactly what it's doing, read straight from the chain:

Depth: the value of the liquidity the index is providing in that market's pool, at the Reserve's own prices.

24h Flow: everything traded through that pool in the last day. Read directly from our hook: every swap through an INDX pool writes an on-chain Flow record, so there's no indexer or database in between.

Utilization: how much of the Engine's Depth target that market is using.

Fee: the live buy and sell fee our hook charges, set by the Engine.

Band status: where the constituent sits against its target Band.

That last pair is where you can watch the Engine think. Right now musebook sits underweight: the index holds less of it than the methodology says it should. So the Engine has moved its fees: buying musebook from our pool now costs 0.44%, selling it into our pool only 0.24%.

Every trade that takes the cheaper side pushes musebook back into the basket,
and the index collects the fee while it happens. When a token drifts overweight it flips the other way, and when it's back inside its Band the fee eases back to the 0.30% base.

Small, rate-limited steps between 0.05% and 2%, recalculated every cycle.

A normal index pays the market to rebalance it. INDX gets the market to rebalance it and takes the fee, and now you can see it doing it, market by market.

It's early and the pools are small, but every number on that page is real and live. It also sets up what's next: the fees those markets earn are what settlement will pay out to holders, every 8 hours, weighted by how long you held. Now you'll be able to watch them build.

https://t.co/WnxwOZW9cH

[INDX @INDXdepth]

Depth

A question we get a lot: where does the money actually go when you deposit into INDX?

Most of it goes exactly where you'd expect. Your USDG buys the ten constituents at their target weights, and they sit in the Vault. That part is the Core Reserve, and it's what backs every index share.

A capped slice doesn't sit still. We call it Depth. Up to 5% of the Reserve is put to work as liquidity in INDX's own Uniswap v4 pools, one for each constituent that has a market, each paired with USDG. When someone trades that token through our pool, the index is on the other side of the trade and earns the fee. That fee goes straight back into the Reserve.

A few things keep that from being reckless. The cap is enforced by the Vault itself, with a hard ceiling that can never go above 30%. Depth is valued at what the pools actually hold, priced by the oracle, not at what we put in, so the number you see is the number that's really there. Before a single unit of liquidity goes into a pool, the pool's price
has to agree with the oracle within 1%, so nobody can push a thin pool and make the index buy in at a bad price. And when you withdraw, if the index needs capital that's working in a pool, it pulls it back in the same transaction. Your exit never waits on the pools.

So the index isn't only holding these tokens. It's providing liquidity for them, and getting paid for it.

[INDX @INDXdepth]

Upgrade to the Engine above: pool sync, shipped this morning.

The Engine only adds liquidity to an INDX pool when its price agrees with our oracle within 1%. Deliberate: liquidity in a pool that's drifted from the market is a free arbitrage at the index's expense.

The catch: a young pool nobody trades drifts as its tokens move elsewhere, the guard keeps it locked, and it stays small and untraded.

So the Engine fixes it itself. Every 20 minutes the keeper checks all 9 pools against the oracle and trades any drifted one back, with a price limit set exactly at the oracle price, so Uniswap v4 stops the swap right there. It runs from the keeper's own wallet and can't touch the index's funds.

First run this morning, 8 pools corrected in under a minute:
ORBIO +16.7% → 0.00%
PROLOGUE −16.1% → 0.00%
musebook +14.6% → 0.00%

Pools on the market price, guard satisfied, Depth flowing. The index keeps its own markets honest 🔧

[INDX @INDXdepth]

Two live reads from the INDX stack on Robinhood Chain. No mockups. Both are pulled straight from mainnet while they run.

The first one is the Engine. Each of our nine markets has a target weight and a Band around it, set by the index methodology. The Engine reads the Reserve, works out where every
constituent actually sits against its Band, and turns that into two numbers per market: a buy fee and a sell fee. In band, both sit at the base. When a token drifts overweight, selling it into our pool gets cheaper and buying it gets more expensive, and underweight flips that around. The fee moves in bounded, rate-limited steps between 0.05% and 2%,
so it steers without whipsawing. The history at the bottom isn't a log file we wrote. Every line is an on-chain transaction: fees set across all nine markets, Depth deployed into the pools.

The second one is where that decision actually lands: the pools and our hook. In Uniswap v4, a hook's permissions are encoded in the bits of its contract address, and the PoolManager reads them from there. Ours has exactly two switched on, beforeSwap and afterSwap, and nothing else. On every swap, beforeSwap (a read-only function) returns the fee for that trade's direction, and v4 applies it as an override for that one swap. afterSwap writes a Flow record on-chain: who traded, in which direction, at what fee, and how much moved. That's the raw material for our flow history. It returns a zero delta, so the hook can't take a cent out of any trade and can't touch liquidity. That isn't a promise; v4 enforces it from the address.

The column worth looking at in that screenshot is the gap. Every pool's price is checked against our oracle before a single unit of liquidity goes in, and if the pool has drifted more than 1% from the market, the Engine refuses and waits. Small caps move fast, and adding liquidity to a pool that's out of line with the market is how naive liquidity strategies bleed: you're offering the next trader a free arbitrage. So the guard comes first, every time.

Put the two together and you get the whole idea behind INDX. The index doesn't just hold its constituents, it runs the markets for them. It uses its own position to set the price of every trade, so the market gets paid to pull the basket back toward its targets, while the guard makes sure it only ever commits capital at fair prices.

Same Uniswap v4 primitive everyone has access to. We just pointed it at the index itself.

Everything's verified and public if you want to read the contracts: https://t.co/pIXXm8e3sO

[INDX @INDXdepth]

The problem:

Most on-chain index tokens are dead money, and it's worth being specific about why.

You deposit, the index buys the basket, and then the capital just sits in a vault. It earns nothing. The tokens it holds keep trading every day in markets the index takes no part in, and the index never sees a cent of that activity.

Then the basket drifts, because prices move, and the index has to rebalance. That means selling what went up and buying what went down, usually in one visible transaction, straight into whatever liquidity happens to exist. In deep markets that's a small cost. In small caps it's a real one: thin books, wide spreads, and a rebalance anyone can see coming and trade ahead of. Every rebalance leaks value out of the basket and into someone else's pocket.

So for small caps the classic index ends up in the worst possible spot. It's one of the biggest holders of these tokens, it needs liquidity every time it rebalances, and it contributes none.

We didn't think the answer was a better rebalancing schedule. We thought the index shouldn't be sitting outside its own markets in the first place.

[INDX @INDXdepth]

Two live reads from the INDX stack on Robinhood Chain. No mockups. Both are pulled straight from mainnet while they run.

The first one is the Engine. Each of our nine markets has a target weight and a Band around it, set by the index methodology. The Engine reads the Reserve, works out where every
constituent actually sits against its Band, and turns that into two numbers per market: a buy fee and a sell fee. In band, both sit at the base. When a token drifts overweight, selling it into our pool gets cheaper and buying it gets more expensive, and underweight flips that around. The fee moves in bounded, rate-limited steps between 0.05% and 2%,
so it steers without whipsawing. The history at the bottom isn't a log file we wrote. Every line is an on-chain transaction: fees set across all nine markets, Depth deployed into the pools.

The second one is where that decision actually lands: the pools and our hook. In Uniswap v4, a hook's permissions are encoded in the bits of its contract address, and the PoolManager reads them from there. Ours has exactly two switched on, beforeSwap and afterSwap, and nothing else. On every swap, beforeSwap (a read-only function) returns the fee for that trade's direction, and v4 applies it as an override for that one swap. afterSwap writes a Flow record on-chain: who traded, in which direction, at what fee, and how much moved. That's the raw material for our flow history. It returns a zero delta, so the hook can't take a cent out of any trade and can't touch liquidity. That isn't a promise; v4 enforces it from the address.

The column worth looking at in that screenshot is the gap. Every pool's price is checked against our oracle before a single unit of liquidity goes in, and if the pool has drifted more than 1% from the market, the Engine refuses and waits. Small caps move fast, and adding liquidity to a pool that's out of line with the market is how naive liquidity strategies bleed: you're offering the next trader a free arbitrage. So the guard comes first, every time.

Put the two together and you get the whole idea behind INDX. The index doesn't just hold its constituents, it runs the markets for them. It uses its own position to set the price of every trade, so the market gets paid to pull the basket back toward its targets, while the guard makes sure it only ever commits capital at fair prices.

Same Uniswap v4 primitive everyone has access to. We just pointed it at the index itself.

Everything's verified and public if you want to read the contracts: https://t.co/pIXXm8e3sO

[INDX @INDXdepth]

🌙 Day 1 of INDX: what's live, and what's next

INDX went live on Robinhood Chain today. Here's what's running under the hood.

🏦 The index
• Small Cap Utility: 10 Robinhood Chain projects in one basket
• Every share is backed first: it only mints after your assets land in the Vault
• Share price = everything in the Vault ÷ shares in existence, calculated on-chain
• Withdrawing as the underlying tokens has no pause switch in the code. Nobody can block it

⚡ One-click deposits
• USDG in → the whole basket bought in a single transaction, routed across Uniswap v2, v3 and v4
• Every trade has a floor it must fill at, or the whole thing reverts and your USDG stays put

📈 Pricing that's hard to game
• Chainlink for USDG and ETH
• 30-minute time-averaged prices from each token's own pools, so one big trade can't move the index
• For v4-only tokens, our own on-chain price recorder: a sample roughly every 4 minutes, with a cap on how far any single sample can move

🔧 The INDX Engine
• INDX-owned Uniswap v4 pools running our custom hook
• Fees steer the basket: when a token drifts off its target, the buy and sell fees shift (0.05%–2%) so trading pulls it back
• Up to 5% of the index works in these pools, and the fees go back into the index
• Liquidity only goes in when a pool agrees with the oracle within 1%. Nobody can push a pool and make INDX buy in at a bad price

⚖️ The rules
• Weights from market cap (square root), max 15% per token
• Rule changes wait 24h, Engine changes 1h

🔐 Control
• A 2-of-3 Safe owns all 27 contracts
• The emergency key can pause but can't change anything, or unpause
• Every contract verified and public

⏳ What's coming
• 🔄 Pool sync: the Engine keeps its pools in line with the market, so Depth keeps flowing
• 📊 Engine stats in the app: live fees, Depth and flow for every market
• 📈 Charts and history: price history, volume and an activity feed
• 💰 Settlement: Engine fees paid out to holders every 8 hours, weighted by how long you held, not a snapshot. No farming, no timing it
• 🌊 More Depth as the index grows
• 🏛️ Index #2: RWA + Tokenization

Day 1 done. Plenty more to come.

📚 Specs and addresses: https://t.co/pIXXm8e3sO · 🌐 https://t.co/ACuNyu75UP

[INDX @INDXdepth]

cool seeing more custom v4 infrastructure appearing on Robinhood Chain.

@prismassets , one of the constituents in our Small Cap Utility basket, is using hooks for the compliance layer: enforcing who can interact with restricted/tokenized assets at the pool level.

we took the same underlying primitive in a completely different direction with INDX.

our Engine hook sits inside each of our constituent markets, including $PRISM and responds to the state of the index itself.

every swap pays a fee the Engine sets from where that constituent sits relative to its target Band. the further inventory drifts from where the methodology says it should be, the further the Engine moves the fee, in bounded steps, and differently for buys and sells, to pull Flow back toward target. that connects the index directly to the liquidity underneath it:

Reserve → Depth → constituent markets → Engine.

So rather than the hook controlling who can trade, ours is controlling how the market behaves around index inventory.

same v4 primitive. completely different job.

really cool seeing teams starting to explore what hooks actually make possible beyond a standard AMM.

v4 on Robinhood Chain is going to get interesting

[Prism Assets @prismassets]

Prism hooks for permissioned tokenized assets.

The first-ever compliance hook is now live on Robinhood via Uniswap v4.

[INDX @INDXdepth]

🛠️ Why INDX isn’t just another index

Most onchain indexes follow the same model:

buy constituents → hold them in a vault → periodically rebalance.

That works reasonably well for liquid markets. It breaks down quickly in small caps.

Rebalancing becomes expensive, execution leaks into thin liquidity, and the index contributes nothing back to the markets it depends on.

INDX is built differently.

The index is part of the market infrastructure.

Up to 5% of the reserve can be deployed by the INDX Engine into INDX-owned Uniswap v4 pools across 9 of the 10 constituents.

That does two things:

→ adds liquidity to the markets the index tracks
→ routes trading fees back into the index

The Engine also controls the fee logic.

Each pool reads the constituent’s actual basket weight against its target.

If a token moves overweight:

→ selling it becomes cheaper
→ buying more becomes more expensive

If it moves underweight, the logic reverses.

Fees adjust gradually between 0.05% and 2%, creating an economic incentive for external flow to move the basket back toward target.

So rebalancing is not only an explicit portfolio action.

Part of it happens through the market itself, while the index earns on that flow.

Guardrails are enforced onchain:

→ liquidity is only deployed when pool price is within 1% of the reference price
→ valuation uses Chainlink + 30-minute time-weighted onchain pricing
→ Engine positions are valued from current pool holdings, not initial deposits
→ redemptions unwind the user’s proportional Engine exposure in the same transaction
→ in-kind withdrawals have no protocol pause path
→ Engine allocation is hard-capped and parameter changes sit behind a timelock

The result is a 10-asset small-cap index that does more than custody constituents.

It provides liquidity to them, prices that liquidity dynamically, and returns the resulting fees to the index.

Every contract is verified and public.

📚 https://t.co/pIXXm8e3sO
🌐 https://t.co/ACuNyu75UP

[INDX @INDXdepth]

Following the transfer of control to the INDX Safe, here is the contract stack behind Small Cap Utility and the role each component plays.

🏦 Vault
Custodies the underlying assets that make up the index.

Deposited constituents are held directly by the Vault contract and remain fully visible onchain.

https://t.co/s1ziF4g1Jo

🪙 Small Cap Utility Token
Represents ownership of the basket.

Minting creates a proportional claim on the underlying reserve. Burning returns the corresponding share of the basket.

https://t.co/qBLvZVh89M

🔁 Router
Handles the mint and redemption path between users and the Vault.

https://t.co/KXYdVmtaqX

⚡ Single-Asset Deposit Router
Allows users to enter or exit the index from USDG in a single transaction, with the required constituent conversions handled inside the route.

https://t.co/sXLAoAUxhU

⚙️ INDX Engine
Runs INDX-managed Uniswap v4 liquidity across supported constituent markets.

A custom hook adjusts pool fees dynamically, while fees generated by that liquidity are returned to the index.

Engine:
https://t.co/VoCpLkm0gx

Hook:
https://t.co/RTqqbTIgy8

📈 Price Registry
Provides the pricing layer used by the index.

It combines Chainlink data with onchain pool averages rather than relying on a single spot trade.

https://t.co/qPLeSPcB1Z

📋 Methodology
Defines the rules used to construct and maintain the basket.

Current constraints include:

→ market cap below $50M
→ maximum 15% weight per constituent

https://t.co/RUr4ZakqvE

🔐 Ownership

All 27 contracts are now controlled by the INDX 2-of-3 Safe.

The ownership transfer was completed in a single transaction:

https://t.co/aJHMDe7pER

Source code is published and verified across the deployment.

This is the contract layer behind Small Cap Utility.

🌐 https://t.co/ACuNyu75UP

[INDX @INDXdepth]

📊 Meet Small Cap Utility, the first INDX index

One token. Ten of Robinhood Chain's small-cap utility projects. Held together, weighted by the rules, live on-chain.

What's inside:
🟠 $ORBIO 13.4%
🟣 $Index 10.7%
🔵 $WALLET 9.5%
🔵 $DELTA 9.5%
🟣 $musebook 8.7%
🩷 $STANDARD 8.6%
🟢 $PRISM 8.5%
🟡 $STATICS 7.4%
🔵 $HOOKR 7.0%
🟢 $PROLOGUE 6.7%
💵 USDG 10.0%

How the basket is built:
Weights come from each project's market cap, balanced so bigger projects count for more but no single token can ever pass 15%.

What makes it different:
Part of the basket works in INDX's own trading pools for 9 of these tokens. The fees those pools earn go back into the index.

Every number on the page is read live from the chain: the value of the basket, each token's actual weight, and whether
it's in its target band.

🌐 https://t.co/ACuNyu75UP

[INDX @INDXdepth]

Another part of the plan is now onchain.

$INDX supply has been permanently burned, removing it from circulation for good, sent to NULL address.

The burn is complete and verifiable on Robinhood Chain:

https://t.co/lg05KsvxRV

[INDX @INDXdepth]

🔐 The INDX Safe is in charge

Our first index is Small Cap Utility: one token that holds a basket of 10 small-cap Robinhood Chain utility projects.

$ORBIO $Index $WALLET $DELTA $musebook $STANDARD $PRISM $STATICS $HOOKR $PROLOGUE

Someone has to be in charge of that basket. That's what the Safe is.

The Safe decides:
• which tokens are in Small Cap Utility, and when one gets added or removed
• the rules for getting in, like the market-cap limit
• how much each token weighs in the basket (no single token over 15%)
• how much can be deposited in total ($50k at launch)
• the fees on the INDX Engine pools that trade these tokens

Why it's a Safe and not one person:
Any change needs 2 of 3 keys to sign, and changes to the index rules wait 24 hours before they apply. Nobody can quietly swap a token in or out of the basket overnight.

What it can't do:
Stop you leaving. You can always withdraw your share of the basket.

✅ The Safe took control of all 27 INDX contracts in one transaction:
https://t.co/WpDQXSYUiB

🔍 Safe: https://t.co/gkXK6OmUC1

[INDX @INDXdepth]

DEX paid ✅

$INDX is now fully updated on Dexscreener as we continue rolling out the market, product and infrastructure around Index Depth.

https://t.co/Ozp4ieLvDh

https://t.co/759UCSLeZQ