Switch

Exogenous yield, settled by push.
A formula picks. Bytecode pays. You do nothing.
$SWTCH on Robinhood Chain

[Switch @Switchprotocol1]

$SWTCH
Inside the App.

This is the Switch front end. Not a mockup. The build, narrated, every screen.

The Switchboard: 17 tokenized equities scored every hour on momentum, buy pressure, volume, volatility. One winner by argmax. The whole budget goes into it.

Rounds: every hour that ever closed, with its winner, its allocation, its Merkle root.

Verify: recompute any round in your browser. Same inputs, same score table, same root. If it doesn't match, we're lying. It matches.

Swap: 3% in, split on the way through. 60 to holders, 30 to locked liquidity, 10 to ops. You see the split before you press the button.

Portfolio: paste an address, see its time-weighted share, its basket, every distribution it's been pushed. Nothing to claim.

Protocol: the constants, the contracts, the trust boundaries. What requires no trust, what's verifiable, what's the one thing you do trust. Written down.

Numbers on screen are simulated. The engine is real. The chain isn't wired yet.

It is on Monday.

Monday, 21st September, the dapp goes live on Robinhood Chain with the hook and the first round. That's the date. There won't be another one.

[Switch @Switchprotocol1]

One Line

"Can't someone just buy at :59 and farm the push?"

The attack isn't blocked. It just doesn't pay.

Allocation is time-weighted. Buy at :59 and hold six minutes of sixty, you earn a tenth of what a full-hour holder earns. No blacklist to evade. No cooldown to wait out. No heuristic to game. Just math that makes the shortcut worth less than the patience.

$SWTCH

[Switch @Switchprotocol1]

The Ledger

This is what every hour will look like.

One round, printed like a receipt. Budget in from the 3%. Eligible set scored. One winner by argmax. One acquisition. One push to holders.

Every line on it is recomputable from public inputs, the score table, the Merkle root, the execution vs. oracle. You don't take our word for a round. You check it.

Nothing to claim. Nothing to sign. Nothing to trust.

Sample round · simulated · not market data. The real ones start when the app goes live.

$SWTCH

[Switch @Switchprotocol1]

The Constants:

Four numbers. None of them have a setter.

3% — the fee on every trade, both directions.
60 · 30 · 10 — holders, locked liquidity, ops.
1.5% — max wallet, enforced by the contract.
0 — owner, proxy, pause, mint.

These aren't stored in a variable someone can edit. They're compiled into the bytecode. There is no function that changes any of them. Not for us, not for anyone who ever gets our keys.

Most protocols ask you to trust the team. Switch asks you to read the constants.
$SWTCH · @RobinhoodApp @RobinhoodCrypto

[Switch @Switchprotocol1]

The First Teaser towards live DApp.

Every hour on one screen. Every eligible equity scored. The winner, what it bought, how it executed. Every round on the record. Any address, nothing to sign in, nothing to claim.

Built. Wired to chain this week.

Full walkthrough soon...

[Switch @Switchprotocol1]

Build Log · 01. Week one, on the record.

Done: token deployed on Robinhood Chain at 3/3. Liquidity seeded and locked, no withdrawal path. Whitepaper v1.0 published, nine sections, no gate. DexScreener profile live, site, docs, socials linked from the chart.

Also done: the scoring engine. Integer-only, deterministic, the same code that will run in the worker and in your browser. Twenty tests passing.

This week: the app is built. Switchboard, round log, portfolio, protocol and being wired to chain and in test now. First look tonight.

Every Monday looks like this from now on. What shipped, what's next, nothing in between.

[Switch @Switchprotocol1]

The Lock.

30% of every fee goes somewhere most people skim past.

Protocol-owned liquidity, locked on a rolling basis with no withdrawal path.

Why it matters: deeper books mean less price impact per trade, which supports larger trades, which grows the fee base, which funds both distribution and more liquidity. It compounds on itself.

And because the protocol owns it rather than renting it, no third-party LP can pull it out from under you on a bad day. That's usually exactly when it disappears.

Distribution is the part people notice. This is the part that keeps it working

[Switch @Switchprotocol1]

$SWTCH

No Treasury.

A protocol that buys real assets has to decide which ones. The usual answer is a treasury, a mandate and a multisig and that quietly buys you three liabilities.

Key risk. Any address that can direct purchases can redirect them. A multisig lowers the odds of misuse. It does not remove the ability.

Mandate drift. Discretionary mandates get renegotiated under stress. Exactly when holders are least able to exit.

Unverifiability. You can't audit a judgement call. Only the outcome, after the fact, with nothing to compare it against.

A published function of public inputs inverts all three. No key to compromise, no mandate to renegotiate, and every past round recomputable by anyone who wants to check the work.

We can't steer it either. That's the entire point.

[Switch @Switchprotocol1]

$SWTCH

The Week Ahead.

Three days in. Here's the machine, where every part of it stands, and what turns on next, in the order it's actually happening.

Launched. The hook in testing. The front end. Then the first round runs.

In a week.

Eighty seconds. Sound on. This one's narrated.

@RobinhoodApp @RobinhoodCrypto

[Switch @Switchprotocol1]

The Claim Tax.

Gas costs the same whether you're claiming four dollars or forty thousand.

That single fact makes every claim-gated reward mechanism regressive. You claim only when the value clears gas plus the attention it takes to remember. Large holders clear it every time. Small holders often never do and the unclaimed remainder accrues to whoever was big enough to bother.

A mechanism advertised as passive income is, in practice, a tax on inattention.

Switch has no claim function. The protocol sends the asset and pays the gas out of the operations share. No threshold to clear, no expiry to miss, nothing stranded in a distributor contract.

Check your wallets. How much is sitting in one you forgot about?

[Switch @Switchprotocol1]

$SWTCH
Time Weighted Balance

The :59 Problem.

Buy at :59. Collect the whole hour. Sell at :01.

That attack works against every snapshot-based distribution ever shipped. One round trip of slippage buys an entire hour of fees.

Switch allocates on time-weighted balance, reconstructed from transfer events across the round:

B̄ = (1/T) · Σ B(k) · Δ(k)

Hold the full hour, full weight. Hold six minutes of sixty, a tenth of it. Same balance at the close, completely different allocation.

Now notice what isn't here. No snipe detection. No cooldown. No blacklist. No threshold anyone has to tune and no heuristic anyone can reverse-engineer.

The attack isn't blocked. It just doesn't pay.

That's the difference between a rule and a patch.

[Switch @Switchprotocol1]

The Fee Routing

This was the most asked question yesterday, so it gets its own post.

Where does the 3% go right now?

Nothing is splitting it yet, because the contract that does the splitting isn't deployed. Until the hook is live the fee goes to the deploy wallet and funds one thing. Shipping the machine. Infra, gas, the build, the testing.

Once the hook is live it never touches a wallet again. It splits inside the contract: 60% buys the hour's winner for holders, 30% locks as liquidity, 10% runs it. Bytecode constants. There's no function that lets me redirect a single basis point.

Today it builds the machine. After that it runs without me.

[Switch @Switchprotocol1]

The Round Boundary

Every round is a closed set.

The budget seals at the hour boundary. A fee arriving one second after the close belongs to the next round, not this one. Scoring runs on the hour that just ended. Never on a window that overlaps another.

Sounds like a small detail. It's the reason a round can be reproduced by anyone holding the same public data. Overlapping windows mean two people compute the same hour and get different answers, and then "verifiable" means nothing.

Boundaries are what make the history checkable.

[Switch @Switchprotocol1]

$SWTCH is updated on DexScreener.

Full profile live. site, docs, whitepaper and socials all linked straight from the chart. Everything we've published is one click from the ticker.

If you found us through the chart, start with the docs. That's the whole thing, written down, before you decide anything.

https://t.co/1NMsfv1ZY6

[Switch @Switchprotocol1]

The Switch Loop.

The whole thing in one Flow diagram.

Fee in → hour closes → every eligible equity scored → highest score takes the budget → assets pushed to holders → loop repeats.

Three things worth noticing:

The budget seals at the hour boundary. No overlap, no carry.

Selection is a formula, not a decision. Same inputs, same winner, every time.

Settlement is a push. Nothing to claim, nothing to sign.

Token's live. This is the machine we're shipping onto.

Watch it once. You'll understand Switch better than most people understand what they hold.

[Switch @Switchprotocol1]

$SWTCH is live now.

Switch just Turned On.

CA:
0x12e5fdfA4dacB620DBD662A177F975B4d95bA230

Site: https://t.co/m8g2OcPvPS
Docs: https://t.co/9wQrZDIaGM
TG: https://t.co/B4VjDuZX3f

[Switch @Switchprotocol1]

What we cannot do:

Most projects tell you what they can do. Here's what we can't.

✕ Mint new supply - No mint function exists
✕ Upgrade the contracts - No proxy, no implementation pointer
✕ Pause transfers - No pauser role
✕ Redirect the fee split - Destinations are bytecode constants
✕ Blacklist an address - No blacklist, no owner
✕ Pull liquidity early - Rolling lock, no withdrawal path

Now the part that belongs in the same post, because a list like that is worthless without it.

Immutability is symmetric. If a flaw is found in these contracts, it cannot be patched. No upgrade path, no pause, no recovery function. That's a deliberate trade, not an oversight. And it's why the code ships when it's right rather than when the calendar says so.

What we can do is publish all of it. The formula, the settlement rules, every round's score table. Anyone can recompute the work and check it against what the protocol actually did.

That's the only kind of trust worth asking for.

[Switch @Switchprotocol1]

Switch is launching soon.

A formula picks. Bytecode pays. You do nothing.

The token goes live first. The Switchboard follows.

CA drops on this account and nowhere else. Anyone posting one before I do is not us.

$SWTCH on Robinhood Chain

[Switch @Switchprotocol1]

Fee architecture

One fee. Three destinations.

3% of every trade, split three ways:

60% → buys the hour's winning tokenized equity
30% → protocol-owned liquidity, locked on a rolling basis
10% → operations, including the gas on every push
The 30% is the part people skim past. Protocol-owned liquidity means less price impact per trade, which supports bigger trades, which grows the fee base that funds both distribution and more liquidity. It compounds and no third-party LP can pull it out from under you.
The destinations are compiled into the hook as constants. Not mutable state, not a constructor argument, not reachable by any function that exists. Redirecting them would mean deploying a different contract and convincing the market to trade against it. Visible to everyone, permissionless to detect.

[Switch @Switchprotocol1]

Switch Push Settlement

Buy at :59. Collect the whole hour. Sell at :01.

That attack works against every snapshot-based distribution ever shipped. It costs one round trip of slippage and pays out an entire hour of fees.

Switch allocates on time-weighted balance, reconstructed from transfer events across the round:

B̄ = (1/T) · Σ B(k) · Δ(k)

Hold the full hour, you get full weight. Hold six minutes of sixty, you get a tenth of it. Same balance at the close, completely different allocation.

Now notice what isn't here. No snipe detection. No cooldown. No blacklist. No threshold anyone has to tune, and no heuristic anyone can reverse-engineer and evade.

The attack isn't blocked. It just doesn't pay.

That's the difference between a rule and a patch.