How Yolk works, all of it.

Overview

$YOLK is a memecoin on Robinhood Chain, launched on Pons. Its creator fees are handed to an AI agent that lives inside an Intel TDX confidential computer. The agent made its own wallet key inside the chip. No seed phrase exists and no person has ever seen the key, including the team.

After the handoff (below), that sealed wallet is the only receiver of Pons's creator fees, paid in ETH. The agent splits those fees by fixed rules, buys back and burns $YOLK, and runs a weekly prediction game called Crack Day that pays winners in ETH.

The simple version

If you've seen the walkthrough on the home page, this is the same story in eight lines.

Launch and handoff

$YOLK went live in two phases. Each one is a public, on-chain fact you can check.

Pons only lets the current fee recipient move the fees. After the handoff that's the sealed wallet, and its key never leaves the chip, so the team has no way to take the fees back.

The agent waits for the handoff. It won't claim, split, buy back or run Crack Day until Pons shows the sealed wallet as the fee recipient. Fees the team's wallet already claimed during Phase 1 stay with the team and are disclosed separately. Fees still sitting on the curve at the handoff move to the sealed wallet with it.

Architecture

Yolk has two parts: the public website, which holds no secrets, and yolk-agent, a Node.js service running inside the enclave.

Wallets and keys

The agent derives three keys from the dstack key management service: two Ethereum-style wallets and one encryption key. Each key is tied to this app's identity and a fixed path. They exist only in enclave memory: never written to disk, never logged, never returned by the API.

The builders and hosting wallets are ordinary public addresses written into config.ts. The agent can send to them but can't change them without a new build.

Where the money goes

Creator fees

Every Pons trade pays a 1% fee, and $YOLK adds a 1% creator tax on every buy and sell, set on-chain at launch. Both are paid in ETH to Yolk's sealed wallet. Every 10 minutes the agent moves its fees from the curve into Pons's fee escrow and claims the escrow into the main wallet. It keeps 0.002 ETH there for gas. Once at least 0.01 ETH above that reserve has built up, it splits the whole amount:

Golden cartons

Golden carton payments (0.002 ETH each) go straight into the pot wallet. At each crack, 10% of that season's Golden revenue goes to builders and the other 90% stays in the pot.

Other revenue

Some revenue goes straight to the public builders wallet, because it pays for services the team runs: Candling Pro reports (0.0005 ETH each), Hatchery deposits (0.02 ETH to reserve a slot, credited against the setup fee) and Hatchery setup fees. There is no hidden allocation and no team wallet the agent pays outside the rules above.

Crack Day rules

Each season is 7 days. Season 1 starts automatically once $YOLK has launched, and each new season starts right after the previous crack.

Free and Golden cartons

Each wallet gets free cartons every season based on its Nest tier (see below). Beyond that, anyone can lay unlimited Golden cartons at 0.002 ETH each. Golden and free cartons score exactly the same way.

How a carton is sealed

1. Your browser fetches the enclave's public seal key from /api/season.
2. It encrypts your 12 answers plus a random salt with a one-time key (NaCl box, x25519 + XSalsa20-Poly1305). Only the enclave's secret key can open it.
3. It computes the commitment: sha256(ephemeralPublicKey ‖ nonce ‖ ciphertext).
4. Your wallet signs a free, off-chain message (a standard "Sign message" request) proving the carton is yours:

   YOLK carton
   season: 3
   commitment: 9f1c…e2a0

5. For Golden cartons, your wallet first sends 0.002 ETH to the pot and the agent checks that transaction on-chain.
6. The agent stores the sealed carton and publishes the commitment in the season's public list. You get a receipt with the carton ID and position.

The agent doesn't open any carton until the crack. Its code has no path that decrypts earlier, and that code is what the attestation measures.

The 12 questions

Each question has four answers. The correct one is read at the crack from the source listed.

A value exactly on a cutoff goes in the higher bucket. Holder counts include contracts like the Pons curve or pool, because the agent can't reliably tell them apart from people.

Scoring

• One point per correct answer. Question 12 gives everyone a point.
• If a data source can't be read at the crack, that question gives nobody a point.
• A carton that can't be decrypted or doesn't hold 12 valid answers scores zero.

Payouts

1. The agent leaves 0.001 ETH in the pot wallet for gas.
2. It pays builders 10% of the season's Golden carton revenue.
3. Cartons with the highest score share 70% of what's left, equally per carton.
4. Cartons with the second-highest score share 20%.
5. Everything else, including the remaining 10%, rolls into next season's pot.

Winnings are added up per wallet and sent in one transfer. Amounts under 0.0001 ETH aren't sent and roll over. If there's no second-highest score, that 20% rolls over too.

The Nest

At the start of each season the agent takes a snapshot of $YOLK balances. Your balance in that snapshot sets your tier for the whole season, so buying right before laying closes doesn't change it.

Check your tier with GET /api/nest/<wallet>. Other Nest perks on the home page, like voting and Hatchery discounts, are run by the team off-chain and aren't enforced by the agent yet.

Verify it yourself

Every "Peck a word" request returns a fresh Intel TDX quote. Its 64-byte report_data field is filled like this:

report_data = sha256(word)                      // bytes 0–31: proves the quote is fresh
            ‖ sha256(mainAddress ‖ potAddress)  // bytes 32–63: proves these wallets live in this enclave

Step by step

1. Send POST /api/peck with a word nobody could guess.
2. Check the first 32 bytes of reportData equal sha256(word).
3. Take both wallet addresses as raw bytes (20 bytes each, from the 0x hex), join them, hash them, and check that equals the last 32 bytes.
4. Paste the quote into a TDX quote verifier, such as Phala's attestation explorer or Intel's DCAP tools. Confirm the signature chains to Intel and that it reports the same report_data.
5. Compare the measurements and the composeHash from /api/info with the published build: the source repo, the Docker image digest, and docker-compose.yml.

The website runs steps 2 and 3 in your browser automatically. Steps 4 and 5 are the ones that prove it's real hardware running the published code.

// Step 2 and 3 in a browser console
const r = await (await fetch(API + "/api/peck", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ word: "my-secret-word" }) })).json();
const hex = async b => [...new Uint8Array(await crypto.subtle.digest("SHA-256", b))].map(x => x.toString(16).padStart(2, "0")).join("");
console.log((await hex(new TextEncoder().encode("my-secret-word"))) === r.reportData.slice(0, 64));

Candling

Candling grades any wallet on Robinhood Chain by how it actually trades. Inside the enclave, the agent reads the wallet's 300 most recent token transfers from the chain's Blockscout explorer, keeps only those where ETH moved in the same transaction (a trade, not a plain transfer), and measures the patterns below.

What it measures

Grade rules

The rules are checked in this order. The first one that matches is the grade.

Free grade and full report

Anyone can get a wallet's grade, the reason, and its trade and token counts for free. The full report adds win rate, realized profit, hold time, never-sold share, median fee, rapid-fire share, most active hours and the five most-traded tokens. It costs 0.0005 ETH, or it's free if you sign with a wallet that's Hen tier or higher in the current season's snapshot.

Each full report is hashed, and that hash goes into a fresh TDX quote the same way a pecked word does. So anyone can prove the enclave produced that exact report and it wasn't edited afterwards.

The Hatchery

The Hatchery sets up the same sealed-wallet system for other Pons projects on Robinhood Chain: an enclave-held creator wallet, a published fee split, and a proof widget for their site.

Projects apply on the home page by paying a 0.02 ETH deposit to the builders wallet. The agent checks the payment on-chain and stores the application on its encrypted volume. Only the team can list applications, with a private admin token.

API reference

All responses are JSON. The base URL is published on the official site once the agent is deployed.

// POST /api/carton body
{
  "wallet": "0x address",
  "type": "free" | "golden",
  "ephPub": "base64, 32 bytes",
  "nonce": "base64, 24 bytes",
  "ciphertext": "base64",
  "signature": "0x EIP-191 personal_sign signature of the carton message",
  "paymentTx": "0x transaction hash of the ETH payment, Golden only"
}

Security model

What you're trusting

• Intel TDX hardware. That it isolates the VM and signs honest quotes. TEEs have had vulnerabilities in the past and may again.
• The published code. The attestation proves which code runs, not that the code is correct. Read it, or wait for the audit.
• Phala's key management. Keys are derived by the dstack KMS for this app's identity.
• Outside data. DexScreener and the chain's Blockscout explorer answer Crack Day questions 1–6, and Blockscout supplies the trade history for candling. The enclave fetches them over HTTPS but can't prove they're accurate.

What's protected

• Nobody, the team included, can withdraw from the main or pot wallets by hand.
• The wallets can only call four contracts: the Pons V2 factory, $YOLK's own curve, the $YOLK token, and Pons's fee escrow. Any other contract call is refused inside the enclave before it is signed. No wallet delegation (EIP-7702) is ever signed.
• Pons is called directly, with no third-party API in between, so no outside service can slip a different transaction in front of the key.
• The fee split, prices, payout rules and wallets can't change without a new build that changes the public measurements.
• Sealed cartons can't be read by the team, the host or other players before the crack.
• Cartons can't be dropped quietly, because every commitment is in the public season list.

Known limits

• Market-based answers can be pushed by large trades near the crack. Spreading reads over time instead of a single snapshot is planned.
• The RPC provider could hide or delay data. That can't move funds, but it could make a step like a buyback fail or retry.
• If the hosting provider shuts down the machine, the agent stops until it's redeployed under the same app identity.
• Once $YOLK graduates from the Pons curve to its Uniswap v4 pool, the agent stops buying back (the curve is closed) and sends that 20% share to the Crack Day pot instead. A pool buyback may be added later in a new, published build.
• The Pons contract interfaces come from Pons's official source repository. Before launch, the rehearsal confirms them against the live contracts: every launch is simulated first, so a mismatch fails before any ETH is spent.

Risks and disclaimers

$YOLK is a memecoin. It has no intrinsic value, its price can go to zero, and nothing here is financial advice. Only put in what you can afford to lose.

Golden cartons are paid entries in a game with ETH prizes. Depending on where you live, that may count as gambling or a lottery and may be restricted or illegal. Free cartons are always available, and it's your responsibility to follow your local laws.

Glossary

TEE

Trusted execution environment. Hardware that runs code in isolation, so even the machine's owner can't see inside.

Intel TDX

Intel's TEE for whole virtual machines. Yolk runs in one.

Quote

A signed statement from the hardware saying what code is running, with 64 bytes of data the app chose (report_data).

Attestation

Checking a quote to confirm real hardware is running the expected code.

Compose hash

A fingerprint of the deployment config, including the exact image digest. Any change produces a different hash.

dstack

Phala's framework for running Docker apps in TDX, including key derivation and quotes.

Creator fees

A share of every Pons trade, paid in ETH to the wallet that launched the coin.

Commitment

A hash of your sealed carton. It proves your carton was counted without revealing it.

Wei

The smallest unit of ETH. 1 ETH = 10¹⁸ wei.

Pons

The main memecoin launchpad on Robinhood Chain. Coins trade on a bonding curve, then graduate to a Uniswap v4 pool.