Slices: Building The Web3 Real Estate Index Fund

By Nadine Loepfe

REITs in Web3

Part 1: How Would We Build a REIT Today Using Web3 Technologies?
Part 2: How Is Tokenization Changing The Way We Invest?
Part 3: How Can We Model a Building in Web3?
Part 4: How Can We Model a Building in Web3? (Continued)
Part 5: Reimagining REIT Cashflows: Managing Revenue and Expenses in Web3
Part 6: Governance & Jurisdiction in Tokenized Real Estate
Part 7: Slices: Building The Web3 Real Estate Index Fund

REITs in Web3: Part 7

In our series so far, we’ve laid the essential groundwork for a modern, Web3-native Real Estate Investment Trust (REIT). We’ve explored how to model buildings as digital assets, how to manage their cashflows on-chain, and how to set up governance and jurisdiction in a decentralized world. In short: we’ve assembled the core building blocks of tokenized real estate.

Now, it’s time to step back from the single property and evaluate the portfolio holistically, as a manager would.

In traditional finance, an investor seeking diversification rarely buys just one stock. Rather than selecting individual stocks, investors frequently choose an index fund or ETF instead, which are pooled financial instruments that deliver diversified exposure to a wide range of companies or market sectors.

Now, the real question is: “How do we replicate — and radically improve upon — that experience within our new tokenized real estate ecosystem?

The answer lies in a powerful new construct, which we call a slice.

A Quick Refresher on Yield

Before we introduce slices, let’s revisit the yield-generating primitives we’ve already defined: vaults and auto-compounders.

• Vaults ($vTokens): Rental income from buildings (often denominated in $USDC) is deposited into a vault contract. Investors stake their building tokens into this vault and, in return, receive a vault token ($vToken) that represents their proportional share of claimable rewards.
• Auto-compounders ($aTokens): These contracts extend the vault concept further. They automatically harvest your $USDC rewards, swap them back into the building’s base token, and restake the proceeds, creating a continuous compounding effect. By staking your building token, you receive an $aToken in return, which appreciates in value as it reflects an ever-growing position.

This creates three layers of tokens for each building:

1. Base Token: Fractional ownership of the building.
2. $vToken: Staked position in the vault, earning yield.
3. $aToken: Auto-compounded position, continuously growing.

If you only invest in a single property, holding its $aToken is sufficient. But what happens when the REIT scales to hundreds of buildings?

The Problem: A Sea of Tokens

Managing exposure to numerous $aTokens can become unmanageable pretty fast. You’d need to track performance, rebalance manually, and continually reassess allocations when new properties are added to the platform.

This is exactly the kind of friction and operational overhead that decentralized finance (DeFi) was designed to eliminate.

Introducing the Slice: The Web3 Index Fund

A slice is somewhat the Web3 equivalent of an index fund or ETF.

At its core, a slice is a smart contract that holds a diversified basket of yield-bearing building tokens. When investors deposit capital, the contract mints a new “slice token” ($sToken) representing their proportional share of the portfolio. With a single token, they gain exposure to an entire segment of tokenized real estate.

The slice performs two core jobs:

1. Maintain a defined allocation across a set of assets.
2. Automatically adjust and expand the portfolio based on programmable rules.

Now, let’s break down how this works in practice.

Part 1: The Basic Slice — Mirroring an Index Fund

Imagine a slice that tracks three properties:

• 30% in Building M
• 30% in Building N
• 40% in Building O

The slice’s primary job is to maintain this allocation.

• Rebalancing: On a set schedule (for example, daily), the slice queries on-chain price oracles to determine the portfolio’s current composition. If allocations drift from target, the slice contract executes swaps via liquidity pools, therefore rebalancing the portfolio and bringing allocations automatically back in line.
• Deposits & Withdrawals: Investors can deposit $USDC or any underlying building token. The slice contract converts contributions as needed, mints $sTokens, and sends them to the investor. To withdraw, the investor returns $sTokens, which are burned, and receives back the proportional value in underlying assets or stablecoins.

This matches the function of a traditional ETF, but with full transparency, programmability, and reduced overhead.

Part 2: Yield-Bearing Slices — A Major Advantage

Where slices really shine is in their ability to hold not just the base building tokens, but also the yield-bearing $aTokens. This ensures every dollar within the slice is continuously compounding value for its holders.

Here’s how rebalancing works in a yield-bearing slice:

1. Calculate: The slice determines it needs to reduce exposure to Building O and increase exposure to Building M.
2. Withdraw: It calls the withdraw function on the Building O auto-compounder to retrieve $O tokens.
3. Swap: It trades $O for $M via a decentralized exchange liquidity pool.
4. Deposit: It stakes the new $M tokens back into Building M’s auto-compounder, receiving $aM tokens.

The portfolio remains fully yield-bearing throughout the process, which is something traditional ETFs simply cannot achieve.

Part 3: The Smart Slice — From Static Index to Dynamic Strategy

A basic slice mirrors a fixed allocation. However, because everything is programmable, slices can evolve into self-managing, rule-driven portfolios.

Instead of hard-coding three buildings, a slice can dynamically query building metadata directly from on-chain NFTs minted on the platform:

• “Include all tokenized residential properties in the UAE.”
• “Only include buildings built between 2000–2025.”
• “Cap allocation to any single property at 5%.”

Whenever a new building NFT matches these criteria, the slice automatically adds it to its portfolio. On the next rebalance, funds flow into this new property.

This transforms slices into autonomous, self-populating index funds. No committees, no brokers, no quarterly reconstitution. Just pure programmable strategy execution based on your parameters.

Why Slices Matter

Slices, as a concept, start off within familiar financial territory, but ultimately transcend the limits of traditional finance. Some key differentiators are:

• Diversification in one token: Like an ETF, but backed by yield-bearing assets.
• Automated rebalancing: No fund managers, just code.
• Continuous yield: Every asset inside a slice compounds.
• Dynamic composition: Portfolios can evolve based on real-world metadata.

With slices, investors don’t just buy into a portfolio; they buy into a strategy that manages itself.

The Bigger Picture: From ETF to Autonomous Investment Strategy

By combining the DeFi primitives we have built so far (tokens, vaults, auto-compounders, and metadata-rich NFTs), we have designed a financial instrument that starts as an ETF and evolves into a highly programmable and autonomous investment strategy.

Slices are the capstone of our Web3 REIT architecture. They move us from modeling a single building to managing an entire real estate ecosystem. This is the kind of innovation that shows how tokenization is not simply replicating traditional finance on new rails, but reimagining it entirely.

To see it side by side:

Slices: Building The Web3 Real Estate Index Fund was originally published in Hedera Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.