How SHADE works.

SHADE is a set of pools on Robinhood Chain that buy tokenized stocks a shade under the market price, automatically, on behalf of the people who fund them.

1. 1You deposit USDG into a pool for one asset — SPY, QQQ or NVDA.
2. 2While it waits, most of your USDG earns yield in an on-chain lending market.
3. 3The pool shows a permanent bid below the market price: about 3% during US market hours, 8% when Wall Street is closed.
4. 4Anyone who needs to sell that asset fast can sell it to the pool, in one transaction, no signup.
5. 5The shares bought are credited to depositors instantly, pro-rata, at that same discounted price.

Sellers pay the discount because it is cheaper than their alternative — slippage on a thin DEX, a liquidation that can't wait, a market that's closed. Depositors collect it. There is nothing to run and nothing to watch: the pool is passive, and every buy is public.

SHADE is currently live as a test version. Every feature of the app works end to end with your own wallet, but nothing is sent on-chain and no real funds are involved.

How it works

• The test environment runs an exact TypeScript replica of ShadeVault.sol: same constants, same accounting, same revert messages. What you see here is what the contracts do.
• Each action — faucet, deposit, withdraw, cap, mode, sale — asks your wallet for a signature instead of a transaction. Signing is free, costs no gas, works on any network, and can't move funds. The hash of your signature is the action's receipt, shown in your activity and on the Buys page.
• Balances are test USDG and test Stock Tokens from built-in faucets (10,000 USDG and 10 shares per claim). Prices follow a simulated feed around a fixed reference, with small per-minute moves.
• State lives in your browser and is shared across wallets there — connect a second wallet to act as a seller against your own deposits. Clearing site data resets it; so does the reset button.
• A test console lets you move the simulated price and fast-forward the clock, so yield, Auto-sell and the circuit breaker can be seen in minutes rather than days.
• A simulated keeper executes Auto-sell as soon as a position becomes eligible, the way a keeper network will against the live contracts.

From zero to your first discounted buy in about two minutes:

1. 1Open the app and connect any wallet.
2. 2Pick a pool and claim 10,000 test USDG from the Deposit panel.
3. 3Deposit — say 5,000 USDG. 20% stays liquid to fund buys, 80% starts earning yield.
4. 4In Sell to the pool, claim 10 test shares, then sell a small amount (use MAX to see what the pool can absorb right now).
5. 5Look at Your position: the shares are yours, at an entry price below market. The sale appears on the Buys page and in Analytics.
6. 6Use the test console: fast-forward 30 days to see yield accrue; switch to Auto-sell and move the price to watch the keeper take profit; withdraw whenever you want.

A deposit sends USDG into one pool and opens (or tops up) your position there. No signup, no lockup, no minimum. Each pool is independent: a position in SPY is separate from one in NVDA.

Positions are tracked per depositor rather than as one pooled token. That is what makes a personal cap and mode possible: two depositors in the same pool can hold different amounts of the stock.

market price = min(Chainlink price, DEX TWAP)
buy price    = market price × (1 − discount)

Two independent sources, and the lower one wins. If one feed is briefly wrong or manipulated upward, the other one caps the price — the pool never pays above either.

The discount is wider when Wall Street is closed: there is no fresh trading to confirm the price, so the pool asks for a larger margin of safety. Market hours are a simplified UTC window; they don't account for daylight saving time or exchange holidays.

A buy is a single call, sellToPool(rwaAmount), open to anyone. In that one transaction the contract:

1. 1Reads the market price and rolls the daily window if it's a new UTC day.
2. 2Checks the circuit breaker, the pool's liquid USDG and the daily cap.
3. 3Computes the buy price and the USDG owed: amount × buy price.
4. 4Allocates the shares across depositors, pro-rata to each one's remaining cap headroom.
5. 5Pulls the shares from the seller and pays them USDG.
6. 6Emits Bought(seller, rwaAmount, usdgPaid, discountBps, marketPrice) — the public record behind the Buys page.

Allocation

Each depositor's headroom is how much more of their position may become stock under their cap, limited by the USDG they have left. The purchase is split in proportion to headroom, and everyone pays the same clearing price.

If depositors' combined headroom can't cover the sale, it reverts. The pool never buys more than depositors have agreed to hold.

Cap

Your cap is the maximum share of your position's value that can be held as stock, from 0% to 100%. At 50%, a $10,000 position can hold at most $5,000 of shares; the rest always stays in USDG. At 0%, your deposit only earns yield and never buys.

Modes

Auto-sell is executed by triggerAutoSell(depositor), which anyone can call once the condition holds. The caller supplies the USDG at the oracle price and receives the shares — a fair-value swap, not a dump on a DEX. A non-custodial contract can't schedule itself, so "automatic" means a keeper calls it; in the test version a simulated keeper does this immediately.

Because the pool buys below market, a position is often above its entry price right after a buy. In Auto-sell mode that means the discount can be realised quickly, turning SHADE into a yield-plus-discount strategy rather than a way to accumulate stock.

80% of each deposit is placed in a yield strategy — an on-chain lending market such as Morpho in production. The other 20% stays in the pool as the liquidity reserve, never invested, so the pool can always pay a seller on the spot.

Yield is credited to depositors in proportion to their USDG balance, using a per-share accumulator: it settles into your balance automatically the next time your position is touched, and the app shows the unsettled amount in real time. The test version uses a fixed 4% APR strategy.

Shares held don't earn lending yield — only USDG does. Buys spend USDG from the reserve; the reserve refills as new deposits arrive and as Auto-sell converts shares back to USDG.

withdraw(shares) is open at any time, for any part of your position. You receive your own USDG and your own shares, in proportion to the part withdrawn — exactly what is tracked for you, including settled yield.

Withdrawals are never paused, delayed or gated. If the reserve is short, the contract first pulls the difference out of the yield strategy. No owner switch can stop a withdrawal.

The day's opening price is recorded by the first sale of each UTC day. From then on, if the market price falls 15% below it, every further sale that day reverts with circuit breaker active. Deposits and withdrawals are never affected by any of these limits.

Selling below market only makes sense when the alternative is worse. On Robinhood Chain, it often is.

Rather than racing bots for liquidations, SHADE becomes the buyer those bots sell to. That removes the speed race, widens the flow to every seller in a hurry, and keeps the pool passive.

Selling to a pool needs three calls and no registration: read the price, approve the Stock Token, call sellToPool.

import { erc20Abi, parseUnits } from "viem";
// publicClient / walletClient: your viem clients on Robinhood Chain.

const vault = "0x…"; // the pool's ShadeVault
const rwa = "0x…";   // the Stock Token it buys

const vaultAbi = [
  { type: "function", name: "buyPrice", stateMutability: "view", inputs: [], outputs: [{ type: "uint256" }] },
  { type: "function", name: "sellToPool", stateMutability: "nonpayable",
    inputs: [{ name: "rwaAmount", type: "uint256" }], outputs: [] },
] as const;

const amount = parseUnits("2.5", 18);

// 1. Quote: buyPrice has 8 decimals, USDG has 6, Stock Tokens have 18.
const price = await publicClient.readContract({ address: vault, abi: vaultAbi, functionName: "buyPrice" });
const usdgOut = (amount * price) / 10n ** 20n;

// 2. Approve the vault to pull the Stock Token.
await walletClient.writeContract({ address: rwa, abi: erc20Abi, functionName: "approve", args: [vault, amount] });

// 3. Sell. USDG arrives in the same transaction.
await walletClient.writeContract({ address: vault, abi: vaultAbi, functionName: "sellToPool", args: [amount] });

ShadeVault

One vault per asset. Written in Solidity 0.8.26 with OpenZeppelin, tested with Foundry.

Events: Deposit, Withdraw, Bought, AutoSold, CapUpdated, ModeUpdated, ParamsUpdated. The USDG token, the Stock Token, both price feeds and the yield strategy are immutable — set at deployment, never changeable.

Each vault has an owner, limited to tuning bounded parameters. The owner has no path to user funds.

• Buying into declines. The pool typically buys while an asset is falling, and it can keep falling. Depositors carry that price risk; SHADE doesn't hedge it. Index pools, your cap, Auto-sell and the circuit breaker reduce it — they don't remove it.
• Oracle risk. Both price sources can deviate from the true market, briefly or persistently, especially in thin liquidity or after an outage.
• Smart-contract risk. The contracts are experimental and unaudited. A bug could lead to partial or total loss.
• Yield-venue risk. USDG in the strategy is exposed to the lending market it's placed in.
• Stock Token risk. Tokenized stocks carry issuer, custody, redemption and regulatory risks distinct from the underlying shares.
• Keeper dependence. Auto-sell needs someone to call it. Without a keeper, an eligible position simply keeps its shares.

Nothing on this site is investment advice or an offer of securities. Read the disclosures.

$SHADE is the protocol token. It is not launched yet and will launch soon on Robinhood Chain. The launch venue will be announced before launch.