Resources

Node operators back onchain SLAs with staked LINK slashed for missed performance obligations — the underwriting primitive, in production.

Node operators stake ATH before contributing resources; deviating from quality standards risks slashing — DePIN-native SLA enforcement.

SLAs enforced via slashing, not lawsuits, as the settlement layer for decentralized infrastructure, with $15B+ in restaked capital securing performance promises.

Spot market with standardized contracts, Silicon Data pricing benchmarks, and DRW market-making — explicitly modeled on commodities markets.

Compute Exchange facilitated $1B+ in compute supply via spot auctions; SF Compute raised $40M building the "Airbnb of GPU capacity".

Two Compute futures contracts launching October 5, 2026 — TradFi validation of contract standardization.

Contracts from one node/one hour to thousands of nodes for years, with resale of idle capacity via API/CLI.

Founder interview on building the underlying spot market and index price for GPU financialization.

Wallet-native social platform on Monad: scans holdings, drops you into token-specific chats, supports in-app swaps and tipping.

Best blog-level survey of Monad's consumer/social app layer (Kizzy, Dusted, RBS).

Research blog for tracking where social and trading apps are heading on Monad.

Product templates and insurance license-as-a-service. The FlightDelay architecture with multi-provider Chainlink feeds is the reference design.

Multiple premium data providers and decentralized nodes so no single oracle failure breaks claims.

Staking-priced cover. ~$190M pooled, $18M+ claims paid since inception.

Embeddable parametric cover SDK.

B3i, the biggest industry consortium, went insolvent in 2022. The unsolved question regulators keep asking: who is liable when the oracle sends wrong data? Have an answer — dispute window, fallback oracle, or hybrid manual review.

Stake AID to mint a yield-bearing receipt token accruing returns from AI compute financing plus Treasury yield — closest live thing to this idea.

ERC-4626 vault token representing a share of GPU-backed lending positions; secured a $100M debt facility from Bullish.

Structured yield products engineered for tailored risk-reward, newly launched on Monad — vault architecture reference that lives on the chain.

Index methodology, basis risk, and hedging with power/datacenter/chip exposure — the risk framework any compute vault needs.

First Web3 project to tokenize GPU assets and revenue streams; sold out $100K in 10 minutes on BNB Chain.

Liquid, yield-bearing GPU infrastructure and RWA partnerships with GAIB and Plume, from the operator side.

Clean protocol summary and metrics for the AID/sAID model.

Essay on standardization, arbitrage, and why liquidity stays fragmented across current models — strategic framing for fractionalization.

Undercollateralized loans against verified real-world income streams, tokenizing income as collateral. The closest live protocol to this exact idea.

zkTLS-verified credit lending, a flagship zkTLS application. zkTLS is how you verify the salary or subscription stream without trusting the borrower.

$100M+ originated, ~$18M in defaults, governance voted to wind down in 2026. Underwriting quality matters more than token economics; legal enforceability is the fundamental challenge.

$36M default (a third of active loans), 80% loss in the M11 USDC pool; the borrower had misrepresented FTX exposure. Maple survived by pivoting to secured, overcollateralized positions.

Monad-native lending layer, with native USDC as the loan asset and aPriori/Kintsu sMON yield as a natively verifiable income stream to underwrite first.

Fully onchain CLOB DEX and smart aggregator on Monad. The canonical reference for a live-order-book interface on the chain.

Why order books become viable on Monad and how 0x aggregates CLOB liquidity alongside AMMs from day one.

Reference implementation for real-time indexing of Kuru orderbook events across Goldsky, Envio, Ponder, QuickNode, TheGraph — the plumbing for no-pending-state UIs.

400ms blocks, 800ms finality, full Ethereum RPC compatibility. The performance envelope your interface can assume.

Directory of Privy, Para, Sequence, and Portal integrations for one-click auth, in-app swaps, and smart accounts on Monad.

Walkthrough of Privy embedded wallets signing rapid transactions without popup fatigue — the pattern for embedding trades in any app.

Official starter repos combining embedded wallets with the 0x swap API — trading inside a non-trading app as a template.

Embed swaps sourced from 150+ liquidity venues directly in your app, live on Monad mainnet.

The Monad-native incumbent to differentiate against: fair-launch bonding curve, graduation at ~225K MON with ~80% of supply sold, then migration to an internal DEX pool. Open-source contracts plus TypeScript and Rust SDKs.

Launchpad-as-infrastructure for EVM chains: static, multicurve, and dynamic Dutch-auction launches on Uniswap v3/v4 with a TypeScript SDK. Zora, Paragraph, and Bankr build on it - the fastest path to a custom launchpad without writing curve contracts.

The canonical new-asset-class-spawns-new-launchpad case: AI agents as financeable assets, with launch classes (Genesis, Unicorn) tuned to builder maturity and every launch paired with $VIRTUAL liquidity.

New user behavior, not a new curve: every post becomes a tradeable coin. Uniswap v4 hooks with a 99% sniper tax decaying over 10 seconds, fees locked as permanent pool depth, initial positions seeded via Doppler.

Pump.fun's revenue share collapsed to rivals, then rebounded to ~98% within weeks on the back of buybacks. The lesson: share among undifferentiated bonding-curve launchpads is mercenary - incentives rent it, mechanics don't hold it.

Live map of which asset classes just became liquid onchain: $32B+ ex-stablecoins, six categories over $1B each (private credit, commodities, Treasuries, corporate bonds, non-US government debt, institutional alt funds). Pick the wedge from this list.

The math behind fair launches: constant-product virtual reserves (pump.fun) vs sqrt-price concentrated curves (Meteora DBC), with worked price-impact examples. The reference for changing price discovery to fit a different asset class.

The pump.fun of Robinhood Chain, live since July 2026: non-custodial one-transaction launches (fixed 1B supply, Uniswap V3 pool, auto-locked LP NFT), 1% trade fee with ~80% of protocol share buying back and burning PONS. Reference docs cover mechanics, graduation, contracts, and integration endpoints.

The auction implementation itself: Uniswap v4 hook source where beforeSwap/afterSwap rebalance the bonding curve each epoch, plus multicurve initializers. Fork this if the SDK's supported-chain list (Base, Unichain, Ink, other EVM chains) doesn't cover your target.

Gold-tier Monad indexing (chain ID 143) with HyperSync backfills up to 2000x faster than RPC. The factory-contract pattern auto-registers events from every child token a launchpad deploys - and Nad.fun already runs on it. This is the launch-feed backend.

Foundry template with worked beforeSwap/afterSwap hooks - the primitive behind Zora's decaying sniper tax and Doppler's dynamic auctions. Monad check: verify a v4 PoolManager deployment before building on hooks; if absent, curve logic lives in your own pool contract.

Open-source indexer powering v4.xyz: pools, swaps, positions, and hook events behind a GraphQL API, runnable locally with pnpm envio dev. The fastest starting point for the discovery feed, token pages, and graduation tracking.

Foundational paper (Dave White, Dan Robinson, Hayden Adams) on onchain TWAP execution by splitting long-term orders into infinitely small pieces. Paradigm also led Kuru's round.

Programmatic order management, margin accounts, and WebSocket real-time execution — the substrate for grid/TWAP/limit-variant strategies on Monad.

Second CLOB protocol deployed on Monad ("Have CEX on DEX") with limit-order infrastructure — a comparison reference implementation.

Split into PT (principal) and YT (yield receivables) with a maturity; PT+YT equals the underlying. The TradFi lineage is bond stripping: PTs are zero-coupon bonds, YTs the detached coupons.

Core invariants (PT = YT, SY = PT + YT) and how rebasing, exchange-rate, and activity-driven yield types need different adapters. A build-from guide.

How PT/YT trading works in practice.

How prediction markets work. Ten short visual chapters.

The canonical argument for this idea: start from a fact you want to know, then design a market to optimally elicit it. AI-managed micro-markets make small, niche questions economically viable.

Request, bonded proposal ($750 USDC), 2h challenge window, DVM token vote if disputed. The default resolution stack for novel markets.

Only ~1.5% of UMA proposals are disputed: cheap automation in the common case, expensive human arbitration in the rare case. Relevant to resolving AI-model or virality markets cheaply.

A single holder with ~25% of voting power swung a resolution against real-world facts. The thinner the market, the cheaper it is to corrupt its oracle.

Pricing and resolution mechanisms compared across Polymarket, Kalshi, Augur, Limitless, Truemarkets.

The live Monad prediction-market venues compared. Study these to avoid rebuilding what exists: AI model performance and emerging-market indicators have no Monad venue yet.

Official Monad starter for mobile apps with embedded wallet actions built in.

Mobile social-media betting app on Monad: wager on views and follower changes. Best live example of segment-specific simplified trading.

Simple swap interface backed by order book liquidity — a model for hiding CLOB complexity from casual users.

Mobile-first PWA scaffold with push notifications on Monad.

The essential read: despite $25B+ tokenized, most RWA tokens show low volumes, long holding periods, and minimal secondary trading. Tokenization does not create liquidity; market structure does.

~$22B onchain RWA: private credit $9.5B (Centrifuge, Maple), real estate $2.5B (RealT, Lofty). ERC-4626 vaults and oracle-delivered NAV as the standard stack. Data at rwa.xyz.

Fractional US rental homes with rent streamed in stablecoins.

Speculative NFT trading lost 90%+ of volume since 2021 while property-backed tokens with real cash flow grew to ~$26B. Fractionalizing an asset with no cash flow just fractionalizes illiquidity.

Fully onchain CLOB optimized for rapid quote updates and large volumes of resting orders. Resting limit orders at near-zero cost is exactly the market structure long-tail assets need and never had.

Already lists an institutional derivatives venue pioneering RWA products. Check before building to position as complementary.

Live tokenized-asset data for Monad.

The settlement layer for real-world event outcomes verified by oracle.

YT is best understood as a yield call option with no upside cap and 100% downside. The cleanest existing template for option-like exposure on a non-price underlying.

The first perps DEX with fully onchain execution and a CLOB. The venue architecture an options protocol on Monad would copy.

Fees and volumes crashed 87%/90% before shutdown. Bonding-curve keys created ceiling effects and speculative participation that blocked real community formation.

$20K of personal tokens for 15% of income over 3 years, capped at $100K, quarterly DAI dividends. The trust gap in income reporting is what onstream settlement fixes.

One-to-many pools with continuous streaming to members.

Streams are transferable ERC-721s usable as collateral.

Escrow and release handled by the contract, executing only when predefined criteria are met.

Trigger smart contract execution. Automation not confirmed live on Monad; fallback is a self-run keeper bot (see Ride or Die).

Contract addresses for cross-chain conditional release.

Security-audited smart contract templates for the escrow boilerplate.

Fixed-duration streams with custom curves. A gift is a lockup with an oracle-gated cliff.

Lightweight alternative walkthrough of conditional payments.

Design doc for pooled commitment stakes.

Pool accounting and prize distribution to repurpose.

Monad-native yield source for the pool.

Monad liquid staking. Another yield source, alongside Morpho and Curve on Monad.

Web2 postmortem on weight-loss wagering (HealthyWage, DietBet).

$7B+ cover underwritten, $10M+ claims paid. Staking-based pricing model. Docs at docs.nexusmutual.io.

ethereum.org primer. Chainlink Data Streams on Monad are live from day one.

Permissionless ERC-4626 prize vaults with pluggable distribution and eligibility logic. Swap the random draw for goal-verified eligibility and point it at a Monad yield source.

aPriori, plus Kintsu and Morpho/Curve on Monad.

PLS research for the pitch evidence base.

Mechanics that keep savers engaged.

Cryptographic proofs of data from any website. 1M+ verifications, 40+ verified schemas. Prove "my Screen Time was under 2h" without trusting a centralized backend.

Stanford Blockchain Review compares Opacity (MPC + TEEs + slashing) vs Reclaim (proxy attestors, faster). Useful for choosing a verification stack.

Unified APIs letting developers choose between MPC and proxy models.

Free, open protocol for onchain attestations. Resolver contracts can attach payments to attestations: referee attests, stake releases. Deploys on Monad as-is.

Schema registry and attestation contract source.

QuickNode walkthrough: register a schema, attest, and use resolvers.

ethereum.org primer on getting offchain data into contracts.

One subscription receives push events for all authorized athletes. Push beats polling for auto-verification.

Standard Tier caps at 10 connected athletes and terms have changed three times in two years. Demo with 10 or fewer test athletes, or use an aggregator.

Developer guide to FamilyControls, ManagedSettings, and DeviceActivity.

Apple framework for health and fitness data.

MCP toolkit for agents to read and transact on Monad — a natural fit for the self-run keeper that verifies goals and redistributes stakes.

Monad Foundation builder program with infra credits for AI projects — the funding path for an agent-verified commitment layer.

Audited, zero-fee splitting contracts on 13+ chains with SDK, subgraph, and docs. Non-upgradeable bytecode, deploys on Monad as-is.

Contracts, SDK, and subgraph source.

Embedded in-app wallets and sponsored network fees. The key to payments that feel like messages.

Tips and gifts as open streams.

Community walkthrough of the 0xSplits architecture.

Set a flow rate, balances update every second, all flows netted in real time, no locked capital.

Open-ended recurring payments on 24+ EVM chains plus Solana.

Streaming architecture comparison.

Sablier overview, including Superfluid's liquidator network monitoring sender solvency.

aPriori sMON, plus Kintsu and Curvance.

The fiat analogue, as a design reference.

The category-defining essay. Bluesky approaches feeds from a marketplace perspective: let a developer community bring algorithms to users, because the algorithm directs attention.

A service hosting one or more algorithms, each identified by an at-uri, serving getFeedSkeleton requests. Chain-agnostic: the marketplace and payment layer is what you build on Monad.

The vast majority of Bluesky feeds are built by third-party developers — proof of demand. The missing piece is the economic layer: feeds earn nothing.

Practical build with lessons learned.

Anyone can define and apply label sets that users subscribe to for filtering. Swap "labeler" for "community-trained ranker" and this is the idea.

Lens vs CyberConnect vs Farcaster overview.

7M POAPs, 50M Galxe credentials, protocol/middleware/app stack breakdown.

The official standard: separates owner and user roles with automatic expiry, eliminating collateral and the second reclaim transaction. Standard Solidity, deployable on Monad.

Sponsors lent Axies to scholars earning $300-400/week, spawning guilds like Avocado DAO (10,000+ players, $18M Series A).

How YGG functioned as a market maker for rentable NFTs.

Kickstart tutorial for onchain generative art with verifiable randomness.

Oracle-fed dynamic art walkthrough.

Master + Layer tokens, collector-controlled state changes. Minting programmable art means deploying instructions for how media renders.

Produced iconic works but the platform outlived its market; it had to pledge a simplified viewer just to keep works visible after closure. Render fully onchain or from immutable IPFS logic, never from a company server.

Free-claimed text NFTs with contract-readable parameters meant to be the foundation of an ecosystem of games, like a deck of cards underlying thousands of games.

Required reading. No parallel economies emerged: insufficient base-asset distribution, no ongoing incentive emissions, failure as a Schelling point, immature onchain gaming infra. The infra excuse no longer holds on Monad.

Legends of Elysium (fantasy card/board hybrid coming to Monad) as a partner or target; Fantasy Top as the governance-less baseline to differentiate against.

The definitive material (see Player-Governed TCGs). The failure reasons are a design checklist.

The provable-history primitive: turns NFTs into smart accounts. A card that owns its tournament records, past skins, and provenance as onchain state it carries between games. Standard EVM — works on Monad.

Liquidity on new chains is thin, making price discovery volatile.

Live directory of collectibles apps on Monad. Check before building.

The canonical primitive: 7.2M+ tokens minted by 41,000+ issuers, with brand case studies from Adidas and Warner Music. POAP proved proof but never built reward — badges don't pay. The financial half is the unbuilt part.

"What if you could prove you were at one of Apple's earliest off-sites before the company blew up?"

Timestamped attestations with payment-capable resolvers: the registry mechanism. Standard EVM contracts, deployable on Monad.

Auction mechanism built to reward early participation; every bid is a timestamped onchain record of being early. Caveat: not yet officially deployed on Monad — the factory is permissionlessly deployable.

Auction contracts with pluggable bid-validation hooks: gate participation by fan status or prior holdings — the registry half of the idea.

The mechanism design for why early participation gets rewarded rather than sniped.

CyberConnect (users own their identity and network, composable social data layer) and Lens (graph-as-NFTs) compared.

Monad mainnet wallet and marketplace activity (Magic Eden, OpenSea planning support) generates exactly the co-holding and co-trading signals a Monad-native social layer would surface. No one has built the indexer yet.

The purpose-built stack: IP Assets as NFTs with a Programmable IP License defining remix rights, royalty splits, and commercial permissions enforced by smart contracts.

The hybrid onchain/offchain PIL links contract terms to real-world legal enforceability under the Berne Convention.

The audited splitter for the revenue leg. Verify Monad in their chain list; contracts are non-upgradeable and deployable regardless.

The direct precedent plus kickstart code: gas-efficient NFT AMM with customizable bonding curves, single- or dual-sided pools, ERC-721 and ERC-1155 support. Open-source EVM contracts — fork-and-deploy on Monad.

The structural flaw: floor-pool AMMs price every NFT in a collection the same. Fatal for TCGs, where a chase card is not a bulk common. The unsolved, hackathon-worthy problem is trait-aware pricing.

Hooks for custom curves, dynamic fees, and bespoke liquidity logic for illiquid assets. Live on Monad day one.

Create, test, and deploy your first hook with Foundry — the practical starting point for a custom collectibles AMM.

Public registry of v4 hook deployments, including Monad. Study prior curve and fee experiments before designing your own.

Hybrid ERC-20/721 with native fractionalization — gives every card AMM liquidity, the most direct answer to "no reliable price or exit". Experimental standard: audit before production.

Perpetual attention markets live on Monad: long or short the Attention Index of a topic, aggregated from X, Reddit, and YouTube, with zkTLS-attested data (Primus) and the index computed verifiably in Brevis's zkVM.

Every profile gets a tradable creator coin (1B supply, half vested to the creator), extended in 2026 to attention markets on narrative trends. Caveat: early trading was thin and volatile.

Kaito, Polymarket, Cookie, Galxe compared. Core design warning: attention-scoring algorithms push contributors toward quantity over quality and engagement farming.

Crypto's most ambitious attention-to-earn experiment was killed by a single X API policy change; the token fell 17% in hours. Platform dependency is the #1 risk: mitigate with multi-platform oracles or zkTLS proofs of engagement data.

Price-discovery auctions for launching creator and content tokens. Live on Monad — the launch primitive for tokens worth staking attention on.

Reference implementation of the Doppler Uniswap v4 hook, for building the market mechanics yourself.

TypeScript SDK for launching tokens programmatically — the integration path for an attention-market app.

Monad-native launchpad pairing token launches with leveraged price prediction — the closest live analogue to this idea.

The biggest live experiment in paying for AI contributions, with Dojo specifically incentivizing data annotation.

Academic analysis of the incentive design.

On Bittensor, whale validators earn ~$40K/day while the best-performing miner ranks 66th at ~$940/day. Token-incentive networks tend to pay capital, not contributors.

The direct precedent: distributed annotation where miners tag data and validators score accuracy using semantic embeddings. Steal the validator-scoring design — quality control is the whole game in labeling.

The industry standard and build target: a cryptographically bound manifest recording origin, modifications, and AI use. Chain-agnostic and explicitly blockchain-compatible — anchoring manifests on Monad is spec-sanctioned.

Backed by 6,000+ members including Google, Meta, OpenAI, Sony, Nikon. OpenAI already embeds C2PA metadata in DALL·E 3 images.

Cautionary case: a C2PA-verified process certified a video that had been misleadingly edited. Provenance ≠ truth; credentials verify the data is untampered, not that it's true.

Research direction: a decentralized opt-in/out registry combining C2PA with blockchain for AI-training consent.

The Buterin/Weyl/Ohlhaver paper that formalized SBTs and the theoretical frame for the whole idea.

Schemas + attestations + resolvers. Standard EVM contracts, deployable on Monad. More flexible than SBTs — the right kickstart.

Fewer than 50 institutions issue onchain credentials; no major DeFi protocol uses SBT credit scoring in production. The tech was never the bottleneck — issuer buy-in is.

The closest existing system: user-controlled data portability with protocol-level access, encryption, and payment. Data stays on-device, moving only encrypted against a user-granted permission. Vana is its own L1 — architecture reference, not deployment target.

The original "query my data without taking my data" pattern: privacy-preserving monetization where data owners keep full control.

The closest live architecture: user-hosted, grant-gated, encrypted context. The r/datadao model shows the pooled variant.

Each app's read/write access to your memory is a revocable onchain grant. Deployable on Monad.

The field-defining essay, mapping the three paradigms (social-graph, general-hardware, specialized-hardware) and the risks: privacy leaks, erosion of anonymity, coercion. Worldcoin's Orb centralization is the anti-example this idea critiques.

Drops P-256 verification from ~300,000 gas to ~3,450 — the ~100x reduction that makes passkey wallets practical. Monad check: RIP-7212 is an L2 proposal, not part of Cancun — assume NOT available and verify.

The getclave/Daimo verifier contract, deployable on any chain. On Monad, even the expensive Solidity-path verification is cheap in dollar terms — that's the pitch line.

Smart accounts verifying WebAuthn signatures onchain, with session keys and sponsored transactions. Pair with Circle Wallets' gas sponsorship on Monad for the true one-tap flow.