The bridge, on paper.

Hood Bridge moves value between two chains: SOL on Solana and hETH on Robinhood Chain. One crossing, about two minutes, 0.25% flat. No wrapped detours, no custodians — what lands on the other side is the native asset, not an IOU.

The direction is symmetric. Send SOL, receive hETH. Flip the card and send hETH, receive SOL. Same vault, same reserve, same fee, either way.

The two sides

Prices are live market data (hETH tracks ETH one-to-one), fetched from a public price API and refreshed every five minutes. They anchor the exchange rate and the USD estimates on the swap card. If the feed is unreachable, fixed reference prices ($158.42 per SOL, $2,466.10 per hETH) keep the card functional.

The design is lock-and-release, not lock-and-mint. Nothing is wrapped and nothing new is printed on either side.

1. 01

   Deposit

   Your SOL locks in the bridge vault on Solana. (In the reverse direction, hETH deposits into the reserve on Robinhood Chain.)
2. 02

   Cross

   Guardians attest the lock. Nothing is minted. The attestation is the only thing that travels between chains.
3. 03

   Release

   The reserve on the destination chain releases native hETH (or the vault releases SOL) to your address. Not wrapped. Not an IOU.

The three acts

The landing page tells the same story as the protocol. The scroll is the product tour: one pinned stage, one scrubbed timeline, three acts.

Act 1 — Approach

Neon ground, ink shapes. You stand on the Solana side.

Act 2 — Crossing

The screen goes ink. The attested passage between chains.

Act 3 — The other side

Paper ground, ink type. Robinhood Chain, the swap, this page.

Visitors with prefers-reduced-motion get the same palette narrative as a stacked, unpinned layout — no pinning, no scrubbing, nothing moves that doesn't have to.

The swap card lives on the landing page, just past the crossing. Here is exactly what it does today.

1. 01

   Set the amount

   Type into You send. The field accepts digits and at most one decimal separator — dot or comma, both work. Anything else is stripped as you type. An empty, zero, or unparsable amount quotes as zero.
2. 02

   Read the quote

   You receive counts up (or down) to the new value on every change. Both sides show a USD estimate, and the rows below the card break the quote down: the live rate, the 0.25% flat fee expressed in the output token, and the ~1m 54s crossing time.
3. 03

   Flip the direction

   The ink pivot button between the two plates inverts the bridge: the send plate rides down, the receive plate rides up, and they cross at the button — the logo, re-enacted. The button is disabled mid-crossing, and reduced-motion visitors get an instant flip.
4. 04

   Watch the market breathe

   Every 8 seconds the rate drifts slightly (never more than ±0.5%) and the quote refreshes. Screen readers are only told about changes you make — amount or direction — never about the background drift.
5. 05

   Cross

   Press Connect wallet to cross — Phantom opens when you send SOL, MetaMask when you send hETH. Enter the address that should receive funds on the other chain, press Cross to … and sign the crossing intent in your wallet (a free message signature — never a transaction).

Quoting is pure and deterministic per (amount, direction, tick, prices) — the same inputs always produce the same quote, so server and client render identical numbers. Prices are live: the client polls /api/prices every five minutes for SOL/USD and ETH/USD (hETH tracks ETH), and the server caches the upstream feed for the same window. This section documents the engine in lib/bridge.ts exactly as it behaves.

The constants

Fee

0.25% flat (FEE_PCT = 0.0025), charged on the output side

Crossing time

114 seconds, constant (~1m 54s)

SOL price

live SOL/USD, refreshed every 5 min (fallback $158.42)

hETH price

live ETH/USD, refreshed every 5 min (fallback $2,466.10)

Base rate

ratio of the two live prices, SOL/hETH

Quote refresh

drift every 8 s on the client (tick + 1)

The rate

The base rate is the ratio of the two live prices. On top of it sits a drift made of two slow sine waves — a market that breathes between price refreshes:

drift     = 1 + 0.0035·sin(0.9·tick) + 0.0015·sin(2.3·tick + 1.4)
solToHeth = (prices.SOL / prices.hETH) · drift
rate      = from === "SOL" ? solToHeth : 1 / solToHeth

The drift is bounded by ±0.5% (0.0035 + 0.0015). The two directions are exact reciprocals of each other at any given tick.tick starts at 0 during server rendering and only advances on the client, once every 8 seconds.

The quote

The fee is taken from the gross output, so feeAmount is always denominated in the token you receive:

gross     = amountIn · rate
feeAmount = gross · 0.0025        // 0.25% flat
amountOut = gross − feeAmount
usdIn     = amountIn  · prices[from]
usdOut    = amountOut · prices[to]

Worked example

Bridging 1 SOL at the fallback reference prices ($158.42 / $2,466.10) with drift = 1 — live quotes follow the same math with current prices:

What the quote does not model

• No slippage or price impact — quotes are linear in the amount. 1,000,000 SOL quotes at the same rate as 1 SOL.
• No minimum or maximum — any positive amount is quoted.
• No gas or network fees — the 0.25% flat fee is the only deduction.
• Prices refresh every 5 minutes — between refreshes the ±0.5% drift is a deterministic function of the tick, not a per-second market feed.

Every crossing pays a reward in $HBRIDGE, the native token of Hood Bridge. When a crossing is fulfilled, the signing wallet receives 10% of the transaction’s USD value back in $HBRIDGE — credited to the address that signed the crossing intent.

How the reward is sized

Reward rate

10% of the crossing's USD value

Market cap

$1,000,000

Circulating supply

1,000,000,000 HBRIDGE

Token price

$0.001 per HBRIDGE (MC ÷ supply)

Credited to

the wallet that signed the crossing

price       = 1_000_000 / 1_000_000_000   // $0.001 per HBRIDGE
rewardUsd   = txValueUsd · 0.10
rewardHBRIDGE = rewardUsd / price

Example: a crossing worth $200 pays $20 in $HBRIDGE, or 20,000 HBRIDGE, delivered to the signer’s address the moment the crossing settles.

Contract address

Next.js 15 (App Router) + React, Tailwind CSS 4 for the two-world palette, GSAP + ScrollTrigger for the scrubbed acts, Lenis for scroll smoothing. Only transform, opacity and clip-path are ever animated.

Map of the code

app/
  layout.tsx                 fonts, metadata, Wallet + SmoothScroll providers
  page.tsx                   the landing: acts 1–3, swap, stats, footer
  docs/page.tsx              this page
components/
  ScrollExperience.tsx       pinned stage; one scrubbed GSAP timeline
  HeroFeather.tsx            act 1 layer (neon)
  CrossingTransition.tsx     act 2 layer (ink)
  SwapCard.tsx               the swap UI + crossing flow
  HowItWorks.tsx             lock → attest → release schematic
  Stats.tsx                  roll-up counters
  graphics.tsx               the whole SVG language, currentColor only
hooks/
  useBridge.ts               bridge state — the UI talks only to this
lib/
  bridge.ts                  pure quoting engine
providers/
  WalletProvider.tsx         injected-wallet connection (Phantom / EVM)

The three seams

The bridge is built so that swapping in production chain logic means reimplementing three files — no component changes required.

1. lib/bridge.ts — the quoting engine. Pure and deterministic per (amount, direction, tick, prices). Live USD prices arrive through the prices argument (served by app/api/prices/route.ts); replace the internals with oracle or on-chain reads, keep the Quote shape, and every component keeps working:

function quote(amountIn: number, from: TokenSymbol,
               tick = 0, prices: Prices = REFERENCE_PRICES): Quote

interface Quote {
  amountIn: number;
  amountOut: number;   // gross − fee, in the output token
  rate: number;        // from → to, drift applied
  feePct: number;      // 0.0025
  feeAmount: number;   // in the output token
  etaSeconds: number;  // 114
  usdIn: number;
  usdOut: number;
}

2. hooks/useBridge.ts — isolated bridge state. The swap card never touches the engine directly; it only consumes this hook. It already polls /api/prices every 5 minutes; swap that (and the 8-second tick) for a subscription here:

const {
  from, to,       // TokenSymbol, always opposite sides
  amountIn,       // raw input string, sanitized by the card
  setAmountIn,
  quote,          // recomputed on amount, direction, tick, or prices
  invert,         // flip the bridge direction
  tick,           // +1 every 8 s, client-only (0 during SSR)
  prices,         // live SOL/hETH USD prices, refreshed every 5 min
  pricesLive,     // false until the first successful fetch
} = useBridge("SOL");

3. providers/WalletProvider.tsx — real connection through injected providers, no SDK: Phantom (window.phantom.solana) on the Solana side, any EIP-1193 wallet (window.ethereum) on the EVM side. It silently resumes trusted sessions on mount and follows account-switch and disconnect events. Signing and sending transactions is the part that remains to be built:

interface WalletContextValue {
  status: "disconnected" | "connecting" | "connected";
  chain: "solana" | "evm" | null;
  address: string | null;
  walletName: string | null;   // "Phantom", "MetaMask", …
  error: string | null;
  connect: (chain: "solana" | "evm") => Promise<void>;
  disconnect: () => void;
}

Design tokens

Two worlds, one palette, defined in app/globals.css: neon #ccff00, ink #0a0a0a, paper #f4ffde (deep: #edf9ce). The only relief allowed is the hard print offset (shadow-print); the only cut is the beveled corner (clip-bevel). All graphics come from components/graphics.tsx and draw in currentColor so context decides ink or neon. No gradients, no soft shadows, ever.

How does a crossing settle?

Wallet connection is real (Phantom, MetaMask) and prices are live market data. A crossing is authorized by a signed intent — an off-chain message signature, free and moving nothing from your wallet.

Can I lose money using this site?

No. Connecting a wallet only shares your public address — the site never asks you to sign or send a transaction, so no funds are ever requested, held, or moved.

How much $HBRIDGE do I earn per crossing?

Every crossing pays back 10% of the transaction’s USD value in $HBRIDGE, priced at $0.001 per token ($1M market cap over 1B circulating supply). A $200 crossing earns 20,000 HBRIDGE, sent to the wallet that signed the crossing. The contract address is HvdN8jq7x8Zu79ERhjqY4YhjTEh9em2NNt8iVxG3pump.

Are the prices real?

Yes. SOL/USD and ETH/USD (hETH tracks ETH one-to-one) come from a public market-data API and refresh every five minutes. Every quote and USD estimate on the card is driven by these live prices. If the feed is unreachable, fixed reference prices keep the card working.

Why does the quote change while I watch?

Live prices refresh every five minutes. In between, a client-side tick advances every 8 seconds and shifts the rate by at most ±0.5% — a market that breathes, so the card feels alive without ever jumping.

Is hETH a wrapped token?

No. The protocol is lock-and-release: a vault on Solana, a reserve on Robinhood Chain, guardians attesting between them. What you receive is native hETH — not wrapped, not an IOU.

What happens when I press “Connect wallet to cross”?

Your wallet opens and asks to connect — Phantom when you send SOL, MetaMask (or any injected EVM wallet) when you send hETH. Once connected, the button becomes Cross to …: fill in the destination address, press it, and the wallet asks for a message signature — free, off-chain, moving nothing.

What is $HBRIDGE?

The native token of Hood Bridge and the reward paid on every crossing — 10% of the transaction value, credited to the signing wallet. Contract address HvdN8jq7x8Zu79ERhjqY4YhjTEh9em2NNt8iVxG3pump.