Tamagoscii (タマゴスキー) is a fully responsive web app game where you adopt a unique, randomly generated geometric ASCII creature tied to your XRPL wallet, interact with it through playful Tamagotchi-style actions enhanced by animated text emotions, sound effects, and music, earn Scii Coins by keeping it happy while spending tiny XRP microtransactions, and share your evolving on-chain digital companion with the world as both a game and a social identity. https://tamagoscii.com/

Presentation

XPerp brings perpetual futures trading to the XRP Ledger for the first time. Millions of XRP holders today have no way to trade leveraged derivatives on their own chain — they must send assets to centralized exchanges or bridge to other blockchains. XPerp eliminates both of those compromises by building directly on XRPL with native XRP settlement.

What we built

XPerp is a fully functional perpetual futures exchange running on XRPL Mainnet. Users connect their XRPL wallet (Crossmark or GemWallet), deposit funds to an on-chain escrow account, and trade the XRP-PERP market with up to 20x leverage. The system supports limit and market orders, long and short positions, and real-time order book, price charts, and WebSocket feeds.

The system consists of three layers working together:

A Rust orchestrator runs the central limit order book (CLOB) with price-time priority matching, processes authenticated orders signed by XRPL wallets, monitors the XRPL ledger for deposits, fetches live prices from Binance, applies funding rates every 8 hours, runs a liquidation scanner, and broadcasts real-time market data over WebSocket.

An Intel SGX enclave handles all security-critical computation inside a hardware-isolated trusted execution environment. The margin engine verifies every position. Private keys are generated and held inside the CPU — they never exist in software. XRPL withdrawal transactions are signed inside the enclave using 2-of-3 multisig across three independent enclaves operated on separate infrastructure (Hetzner bare metal + Azure DCsv3). No single operator can move user funds. The enclave's code integrity is verifiable by anyone through Intel DCAP remote attestation.

Settlement happens directly on the XRP Ledger. User deposits are standard XRPL Payment transactions to the escrow account, detected automatically by the orchestrator. Withdrawals are multisigned XRPL transactions constructed and signed inside the SGX enclaves, then submitted to the ledger. Everything settles in 3-5 seconds at negligible cost.

What makes XPerp different

We do not use smart contracts — XRPL doesn't have them. Instead, we use a Trusted Execution Environment (TEE) as a "smart contract in hardware." This eliminates the entire class of smart contract exploits that have cost DeFi billions: reentrancy attacks, oracle manipulation, flash loan exploits, and governance takeovers. The Drift Protocol hack on Solana in April 2026 drained $280M not through a code bug but through social engineering of multisig signers. In XPerp's architecture, the signers are SGX enclaves — processors that cannot be social-engineered.

XRPL native settlement means no bridges, no wrapped tokens, and no L2 withdrawal delays. Funds stay on the ledger at all times. The 2-of-3 multisig with master key disabled means there is no admin key that can be compromised.

Automated market making

An automated Market Making vault is live, providing two-sided liquidity and earning spread plus fee rebates. A Delta Neutral vault (hedged positions, funding capture) and a Delta One vault (interest rate arbitrage) are planned. These bootstrap exchange liquidity from day one.

Partnership with My Neobank

During the hackathon, we formed a partnership with My Neobank (MYNB) to solve the fiat on-ramp/off-ramp problem that every DEX faces. MYNB provides SEPA, SEPA Instant, and SWIFT rails for EUR/USD/GBP, along with a KYC/AML-verified user base (Sumsub, Travel Rule compliant, FINTRAC-registered). XPerp users coming through MYNB get compliant fiat-to-crypto conversion and an IBAN account to park profits between trades. This gives XPerp a complete user journey: fiat deposit, crypto trading, fiat withdrawal — all without touching a centralized exchange.

The market opportunity

Perpetual futures are the largest product category in crypto — $92.9 trillion in volume in 2025. Decentralized perp DEX volume reached $6.7 trillion, growing 346% year over year. Every major chain has its perps DEX — Ethereum (dYdX), Solana (Jupiter), Hyperliquid (own chain). XRPL — with its speed, low cost, and one of crypto's largest communities — has zero share of this market. XPerp captures it.

What's live today

Live on XRPL Mainnet:

• Perpetual futures trading (XRP-PERP, native XRP collateral, up to 20x leverage)
• XRPL wallet integration with signature authentication (Crossmark, GemWallet)
• Real-time order book, price chart, trade history, and WebSocket feed
• Portfolio management with balance display, deposits, and withdrawals
• Intel SGX enclave with DCAP remote attestation (verifiable by anyone)
• 2-of-3 multisig escrow across 3 independent SGX enclaves
• Market Making vault live (Delta Neutral and Delta One planned)
• Funding rate mechanism (8-hour intervals) and liquidation engine
• Full web UI at xperp.fi with "How It Works" and "Verify Enclave" pages

Andrey contributed remotely due to personal circumstances.

Today, monetizing an API means heavy SaaS subscriptions, monthly billing, or opaque third-party platforms. This model is slow to integrate and completely incompatible with autonomous AI agents.

Edel402 solves this with an on-chain middleware that enables real-time monetization via the XRP Ledger. By implementing the x402 protocol, it replaces rigid billing cycles with a stateless, machine-readable payment layer. Only one npm middleware protects your endpoints: when a request is made, the server returns a 402 status with payment conditions. The client (human or agent) signs a transaction on the XRPL, attaches the hash to the header, and the API unlocks immediately.

As AI agents become primary consumers, Edel402 provides the rails for agentic commerce: software can discover, pay for, and consume data independently and trustlessly. Security and compliance are natively handled via the SWIYU Swiss digital identity infrastructure, ensuring every transaction meets regulatory standards (KYC, age, residency) without friction.

Built at Paris Blockchain Week 2026. Live on XRPL testnet.

**GOOGLE SLIDE : ** https://docs.google.com/present

🚀 Stop being the product, start being the owner

The Problem

Today, Google and Meta generate billions of dollars by selling your browsing data. You are the source of this wealth, but you don’t see a penny of it, and your privacy is constantly compromised by opaque trackers.

The Solution

SlainAds is the first extension that transforms your browsing history into a financial asset that you control and monetize directly.

Privacy-First

Your data never leaves your device. SlainAds proves to advertisers that you match their target audience without ever showing them what you’ve viewed.

Automatic Payment

By using the XRPL ledger, we eliminate intermediaries. You receive XRP instantly and atomically as soon as an advertiser accesses your profile.

Value Proposition

We offer brands “Zero-Party” data of unmatched quality, proven and 100% RGPD-compliant, while giving financial power back to the user.

Stripe and OpenAI are building agentic commerce on Visa/Mastercard rails: slow, expensive, geographically broken, locked to pre-approved merchants. QAF replaces those rails with XRPL — the only Layer 1 with native DEX, NFTs, IOUs, stablecoin settlement (RLUSD) and 4-second finality.

Three problems, one architecture:

1. Verification is the worst UX in finance. Every service wants your passport, address, DOB, selfie, phone, email — each a breach waiting to happen. QAF verifies you once with a KYC partner, issues a verifiable credential locked to your wallet, and at every merchant boundary proves only the needed fact ("EU resident, over 18") in ~200 bytes using Boundless + RISC Zero ZK proofs verified on-chain by a Smart Escrow on XRPL's Groth5 devnet. The merchant learns the answer, nothing else — and the ledger, not QAF, enforces fund release.

2. Wallets are walled gardens. Apple Wallet stores pictures of credentials issued by partners Apple pre-approves. In QAF, every credential is a first-class XRPL token: XLS-20 NFTs for unique items (a specific insurance policy, concert ticket, hotel booking), Issued Tokens or Multi-Purpose Tokens for fungible balances (mobile data, transit credits, RWA deposits). Anything can be tapped to use, transferred to a friend, or resold in 4 seconds on the native XRPL DEX.

3. Agent commerce needs both. When an AI agent buys across 50 merchants, you'd be handing your passport to 50 databases — and the things it buys need to land somewhere the agent can read, use, transfer, and resell. QAF gives the agent ZK proofs for identity and a tokenized wallet for storage, so the full loop (intent → quote → purchase → credential → presentation → resale) happens on public rails without exposing the user.

User experience. Tap to create a wallet with FaceID — no seed phrase, no email. Chat with a Gemini 3 agent (Google ADK): "Buy travel insurance for Paris this weekend, under 20 EUR." The agent queries merchants via X402 HTTP 402 micropayments through the T54 Labs Facilitator, returns three quotes, asks for confirmation with a 10-second cancel. Approve with FaceID; a Boundless ZK proof exposes only the required facts; payment settles in RLUSD from a fresh stealth address; QuickNode Streams pushes the NFT-mint event to the wallet the instant it lands. The card slides in. Tap to use at a turnstile over NFC/QR, transfer to a friend, or sell back on the native DEX at 80% — refunded in ~4 seconds.

Privacy by construction. Every transaction uses a fresh derived address (no clustering). Credential payloads are AES-GCM encrypted on-device; only a 32-byte hash hits the chain. ZK proofs at merchant boundaries reveal exactly one fact per interaction — never the name, DOB, or wallet address. QAF holds no keys, no PII, no activity logs. Structurally incapable of leaking, losing, or being subpoenaed for data it never had.

Tiered security. Four tiers scale friction to action sensitivity. Tier 0 (view): open the app. Tier 1 (routine): FaceID. Tier 2 (high-value): FaceID + PIN. Tier 3 (irreversible): FaceID + PIN + 24-hour cross-device cancel window — defeating both phishing and the "unlock-or-I-hurt-you" coercion attack.

Real-world assets. Partner banks deploy an XRPL issuer address and mint tokenized deposits (e.g., "BDF-EUR") directly to a user's QAF wallet as Issued Tokens or, for regulated instruments, Multi-Purpose Tokens (XLS-33d). Held value earns yield, transfers, acts as collateral, or redeems back to traditional rails. The same primitive banks the unbanked: QAF works without an email, bank account, government ID, or credit history — just a phone and a face.

Partner stack is structural, not decorative. XRPL (host ledger, 4s finality, native DEX/NFTs/IOUs/MPTs). Boundless + RISC Zero (ZK prover network; Smart Escrow on Groth5 verifies via EscrowFinish). QuickNode (RPC + Streams + Webhooks + Backfill — the real-time nervous system that makes the wallet feel instant and enables stealth-address architecture). T54 Labs X402 (HTTP 402 micropayments for agent-to-merchant quote queries). Ripple RLUSD (settlement stablecoin). Google ADK + Gemini 3.1 Pro + Gemini 3 Flash + Imagen 4 Ultra (agent reasoning, routing, generative credential art). Remove any one and a workflow breaks.

QAF is not a feature. It is the identity, wallet, and payment layer for the next decade of commerce — built on the one public ledger that already has every primitive it needs, and on the exact partner stack Make Waves asks builders to prove.

With the rise of AI-generated content and deepfakes, it’s becoming harder to trust what we see online. Our system helps restore that trust by allowing anyone to verify whether a video is real or has been altered, starting from the moment it is created.

https://omniaworx-my.sharepoint.com/:p:/p/mohamed_kaldoun/IQB8IYJBfvCaQ7F8Xe9cRnuSAfL64eDC7ukS4VdRnnLRmSc?e=B273o8

Pitch Deck: https://docs.google.com/presentation/d/1dUhE2EIV6VcF5HBzYsSJyKcViFW_4v6c/edit?usp=sharing&ouid=106701869240902273611&rtpof=true&sd=true

AgentPay - A corporate card for AI agents, settled on XRPL.

AI agents are becoming autonomous workers: browsing, researching, executing tasks on behalf of humans. But every time an agent encounters a paid API or a paywalled article, it stops, HTTP 402 Payment Required. Agents don't have wallets, credit cards, or identities and handing over your private keys to an AI is a security nightmare.

Legasi AgentPay solves this by introducing a controlled spending layer between the AI agent and the XRPL ledger:

1. The owner deposits RLUSD into a vault and defines spending rules (allowlisted merchants, per-request caps, total spending power).
2. A policy engine validates every payment request before any transaction is signed, if the service isn't allowlisted or the amount exceeds the cap, the payment is blocked instantly.
3. The agent operates autonomously within those boundaries. For example, when it hits a paywall, it detects the 402 response, triggers a payment in RLUSD on XRPL, receives a confirmed tx hash in seconds and delivers the unlocked content to the user.
4. The agent never holds private keys. The vault signs transactions server-side, and the owner retains full control at all times.

We built this as an MCP server that plugs directly into Claude Desktop or Claude Code. The agent gets a single tool (legasi_fetch) and the entire payment flow is invisible to the end user. Ask Claude to read a paywalled report, and it just works: the agent pays, reads, and summarizes.

A real-time React dashboard gives the owner full visibility: vault balance, spending power bar, live event feed with XRPL explorer links, and Xaman wallet connect for funding the vault via QR code from a mobile phone.

Agent payments are high-frequency micropayments, $0.50 here, $0.02 there, potentially hundreds per day. XRPL offers near-zero fees, 3-5 second finality, and RLUSD as a regulated USD-denominated stablecoin. The entire payment rail uses native XRPL primitives (Payment, TrustSet, AccountSet), no smart contracts needed.

Legasi AgentPay is the infrastructure layer that turns XRPL into the settlement network for the agentic economy.

Obol is Stripe for x402 on XRPL. It lets developers monetize any API endpoint with real cryptocurrency payments; in a single line of code.

A merchant signs up, gets an API key and endpoint UUID from the dashboard, and wraps their route handler with obol.protect(). That's it. When a buyer (typically an AI agent) hits the endpoint without paying, they get back an HTTP 402 with machine-readable payment instructions. The buyer signs an XRPL transaction, retries the request, and gets the resource; all in one round-trip. Settlement happens on-ledger, automatically, after the business logic succeeds.

The primary buyer persona is AI agents and programmatic services, that is software that can read a 402 response, sign a transaction, and retry without human intervention. Obol turns any API into a pay-per-call service for the agentic economy.

What used to take 150+ lines of blockchain plumbing now takes 5 (which is a 97% percent code reduction). A complete merchant server fits in 40 lines including imports. And it's safe by default; developers never have to create wallets, manage private keys, or juggle environment variables if they don't want to. The dashboard generates and encrypts everything, so newcomers to crypto can start earning without touching a single secret.

Presentation: https://drive.google.com/file/d/1Lte__Gw8gjc4_aoZ0lIjKRI181pGh0N3/view

FinAura is a tokenized investment platform that lets fans and investors buy real financial stakes in social media influencers — settling everything on the XRP Ledger with no middlemen.

The Problem

Creators monetize through sponsorships and ad revenue — opaque, inconsistent, and locked behind agencies. Meanwhile, their most loyal communities have no way to invest in their growth, share in their upside, or hold any real stake in their success. The creator economy is a multi-hundred-billion-dollar industry with zero accessible financial infrastructure for the people who actually fuel it.

What Finaura Does

Each influencer launches a fixed-supply token offering — their own personal currency on the XRPL. Fans buy allocations during the live offering window using XRP through their Xaman wallet. When the offering closes (by time or sell-out), Finaura automatically spins up an AMM (Automated Market Maker) pool on the XRPL DEX — seeding it with the tokens and collected XRP so a live secondary market exists from day one. Holders can then trade their tokens at market price, 24/7, with on-chain liquidity. Platform holds back a 10% AMM reserve to ensure the pool always has depth.

What Makes It Special

Real on-chain settlement — Tokens are XRPL native assets, delivered wallet-to-wallet. No wrapped tokens, no custodians, no bridges. Automated liquidity bootstrapping — The AMM is created programmatically the moment an offering ends. No manual steps, no waiting for a centralized exchange to list. Xaman-native UX — Every transaction (purchase, trustline, exchange) is signed in Xaman via QR or deeplink. Users hold their own keys. RLUSD-priced offerings — Prices are denominated in USD value, settled in XRP at market rate, protecting both sides from arbitrary token pricing. Transparent allocation — Every purchase, delivery, and AMM seeding is a public XRPL transaction. Nothing is off-chain. Category + country filtering, favorites, live sell progress — A full investor-grade market UI, not a meme launchpad.

VeraFi — First Decentralized Options Protocol on XRPL

XRPL has hundreds of active projects. Zero of them are options. If you hold XRP and want to hedge downside or earn through volatility, your only paths are: bridge to Ethereum, use a CEX, or hold the spot risk. VeraFi removes all three compromises.

Two parties agree on an option directly. The writer locks collateral in a ZK Smart Escrow on XRPL. The buyer pays the premium with a standard Payment. When the option is in the money, the buyer generates a Groth16 zero-knowledge proof of a Black-Scholes simulation inside a RISC Zero zkVM and submits it as memos on an EscrowFinish transaction. An on-chain Wasm verifier checks the proof and cross-references the agreed terms stored in the escrow Data field. Valid and in the money — funds release. Expired worthless — anyone calls EscrowCancel and collateral returns to the writer.

Four XRPL L1 transactions. No vault. No protocol wallet. No intermediary. The ZK proof is the only gate between collateral and settlement.

The demo ships a 3D payoff surface built with React Three Fiber — rotate the position, hover for live P&L plus delta, gamma, theta, vega at any strike/time combination, and scrub through theta decay in real time. Every contract generates a unique deterministic SVG derived from its parameters. The landing page reads live escrows from the groth5 devnet in real time.

Bounties targeted: Main prize (first options protocol on XRPL) · Boundless (Groth16 ZK proof verified on-chain via Boundless Market) · Impact Finance (trustless derivatives access for anyone who can't open a Deribit account) · Pixel Meets Chain (3D payoff surface, generative contract art, cinematic UI).

Link to presentation : https://docs.google.com/presentation/d/1-8rVY56Oyn8qg-scat6pkoVcIuOUe6SXUrryJ1wAiJk/edit?usp=sharing Link to vercel.app deployment : https://xrpverafi.vercel.app/

Agent Pay is a decentralized API database for AI agents. Developers fund their agent's wallet with USDC, the agent autonomously discovers and pays for any registered service.

Businesses provide API on the platform and extend their market from humans-only to humans and AI agents in a few clicks. Every API becomes payable in seconds with crypto.

Website Link : https://xrpl402-o4qs-gal12pcif-hdjfithri-1619s-projects.vercel.app/ Pitch Deck : https://docs.google.com/presentation/d/1iA-kfeHlaQGSncaf297-w1WgtQF1OKX32i1GCEtl2js/edit?pli=1&slide=id.g3d594b274ba_0_6#slide=id.g3d594b274ba_0_6

The Problem

Invoice factoring today is opaque. Suppliers wait 30-90 days to get paid. Funders buying those invoices have no way to independently verify the credit risk. And traditional credit scoring requires exposing sensitive debtor data (revenue, payment history, defaults) to every potential buyer. You either sacrifice privacy for transparency, or transparency for privacy.

What CheckFi Does

CheckFi is a privacy-preserving invoice factoring marketplace built natively on XRPL. Suppliers tokenize unpaid invoices, choose exactly which fields stay private, and get paid instantly at a discount. Funders browse scored invoices and earn real yield at maturity. The credit grade behind every invoice is computed inside a RISC Zero zkVM and proven correct with a Groth16 proof, so nobody has to trust the scorer. The proof is verified on-chain by an XRPL Smart Escrow, and funds only release if the math checks out.

How It Works

1. Create - Supplier uploads an invoice and toggles a privacy mask per field. Debtor name, payment history, and revenue can stay hidden. Amount and maturity are always visible.

2. Approve - Debtor receives a link, connects their XRPL wallet, and approves. This atomically creates a Single Asset Vault (collateral), a Check (deferred payment instrument), and a Credential (XLS-70 attestation) in a single Batch Transaction on XRPL Devnet.

3. Score - The invoice data (including masked fields) is fed into a RISC Zero zkVM guest program written in Rust. The deterministic algorithm scores payment history, business maturity, and invoice-to-revenue ratio to produce a grade (A/B/C/D), APY, and purchase price. Debtor industry and jurisdiction are committed to the journal when unmasked, giving funders verifiable context without affecting the numeric grade.

4. Fund - The scored invoice appears on the marketplace. A funder deposits into the vault at the discounted purchase price and receives MPT (Multi-Purpose Token) shares. The supplier withdraws instant liquidity.

5. Escrow - An EscrowCreate transaction on groth5 devnet locks the face value with a 14 KB Wasm verifier binary inlined as the finish condition. This Wasm contains the RISC Zero image ID baked in at compile time, so it will only accept proofs from the exact scoring algorithm in this repo.

6. Settle - EscrowFinish submits the journal and seal as transaction memos. The groth5 node executes the Wasm on-chain, calls risc0::verify(), and releases funds to the funder only if the proof is cryptographically valid.

What Makes It Special

Selective-disclosure ZK proofs. The supplier controls exactly which fields funders see. Masked fields still feed the scoring computation inside the zkVM. The proof guarantees the grade is honest even when the underlying data is hidden.

Fully XRPL-native. No Solidity. No EVM contracts. The entire financial layer uses XRPL primitives: Single Asset Vaults, Checks, MPTs, Credentials, Memos, Batch Transactions, and Smart Escrows. The only cross-chain interaction is the Boundless proof market on Base for decentralized proving.

On-chain ZK verification. The groth5 Smart Escrow doesn't just store the proof hash. It runs a Wasm program that calls risc0::verify() with the Groth16 seal and journal. Funds are cryptographically locked until a valid proof is presented. A zeroed or forged seal returns tecFAILED_PROCESSING.

The Problem XRPL shipped groundbreaking native lending primitives (XLS-65 Vaults, XLS-66 Loans) and Smart Escrows (XLS-0100), but no one has built a complete DeFi experience on top of them. Users still rely on EVM-based protocols with high fees, bridge risks, and fragmented liquidity.

What Tellement-French Does Tellement-French is the first lending-first DeFi protocol built entirely on XRPL’s native primitives, no smart contracts, no Hooks, just pure ledger-native transactions composed into a full trading and yield platform.

Lending & Yield Users can deposit XRP or RLUSD into native Vaults (XLS-65) to earn yield from borrower interest, and borrow against vault collateral using native Loans (XLS-66) with on-chain liquidation. The platform offers one-click deposit and withdrawal, along with real-time vault statistics and APY tracking.

Advanced Trading Tellement-French enables advanced order types such as Stop-Loss, Take-Profit, Trailing Stop, and OCO (One-Cancels-Other), all powered by XRPL Escrows with crypto-conditions. A Watcher Bot continuously monitors DEX prices via book_offers and executes orders when trigger conditions are met. There are no off-chain order books or centralized matching engines—everything settles directly on the ledger.

DCA & TWAP The protocol supports Dollar-Cost Averaging (DCA) and Time-Weighted Average Price (TWAP) strategies using pre-signed OfferCreate transactions with TicketCreate. Users sign once, and the Watcher Bot executes transaction slices at scheduled intervals.

ZK-Private Orders Users can place trades where the trigger price, direction, and amount remain hidden on-chain using Smart Escrows (XLS-0100). RISC0 zkVM generates Groth16 proofs to verify that price conditions are met without revealing order parameters. These proofs are generated via the Boundless Market and verified natively by the ledger.

Multi-Wallet Support The platform supports multiple wallets, including Xaman, Crossmark, and GemWallet via xrpl-connect, enabling seamless transaction signing across supported wallets.

The Flywheel Depositors fund Vaults, which enable Loans; borrowers trade, increasing trading volume and deepening liquidity; deeper liquidity attracts more depositors. Each layer reinforces the others, creating a self-sustaining DeFi ecosystem on XRPL.

Why It Matters Tellement-French demonstrates that XRPL’s native primitives are powerful enough to support a full DeFi stack—lending, borrowing, advanced trading, and privacy, without the complexity, gas costs, or security risks of smart contract platforms. It represents DeFi as XRPL was designed for: fast, cost-efficient, and fully native.

1. The Vision: Solving the SME Cash-Flow Crisis

In France, 25% of business failures are caused by late payments, not a lack of business (Banque de France). And small firms are twice as vulnerable. Yet SMEs represent 99% of French companies and win billions in public contracts yearly. Factance is a decentralized factoring platform that bridges this gap. By merging the legal certainty of French administrative law with the speed of the XRP Ledger, Factance transforms verified public receivables into fast, tradable capital. Our mission: democratize financial agility for the backbone of the economy.

2. Riding the E-Invoicing Regulatory Wave

Factance is built on a regulatory tailwind. E-invoicing has been mandatory for French public-sector suppliers since 2020 via Chorus Pro, and the PLF 2026 now extends this to all private companies by 2026-2027 under EN 16931 and Factur-X. Every invoice is already a structured XML document, a natural digital asset. The B2G segment offers a government-verified dataset that Factance leverages directly: if the State has validated the invoice, the receivable is real.

3. Invisible Blockchain: The Web 2.5 Experience

The biggest barrier to blockchain adoption is complexity. Factance eliminates it for the seller. The SME uploads a Factur-X PDF; our backend handles XML extraction, XSD validation, Chorus Pro verification, compliance analysis, tokenization, and DEX listing without the vendor ever touching a wallet. Custody wallets are managed server-side with encrypted seeds. In production, the SME will receives a standard SEPA credit while on-chain settlement between investors happens in 3-5 seconds. We deliver DeFi power with the familiarity of a banking app.

4. XRPL Architecture: The Dual-Token Model

Factance uses native XRPL primitives. Each invoice creates two linked on-chain assets:

• MPT (XLS-33): An immutable provenance anchor (max supply: 1) with XLS-89 metadata encoding the invoice hash, Chorus Pro status, compliance score, and IPFS CID, all under 1024 bytes. Created with clawback enabled for clean retirement at maturity.
• IOU Trust-Line Token: Since XLS-82d (MPT DEX trading) is not yet live, we issue a parallel IOU whose currency code embeds the MPT ID. This IOU trades on the native XRPL DEX against XRP, giving investors a liquid orderbook market per invoice. At settlement, the issuer claws back both IOU and MPT, closing the lifecycle on-ledger.

Our Compliance Notary also anchors each artifact on-chain: SHA-256 digest and IPFS CID are written as AccountSet memos, creating a tamper-proof audit trail without bloating the ledger.

5. Dual-Certification: AI Compliance Engine

To protect liquidity pools and sellers, Factance implements a two-layer compliance gate:

Chorus Pro Verification: The protocol queries the government API to confirm "Service Fait" (service rendered) status before tokenization, ensuring the public debtor acknowledges the debt.

LLM Smart Audit: A Large Language Model grounded in French public procurement law (Code de la Commande Publique, CMF L.313-23) analyzes each invoice for legal enforceability and assignment validity. Rule engine and LLM verdicts merge conservatively: AI can only tighten, never relax, the compliance score.

Only invoices passing both layers are tokenized. Non-compliant receivables are blocked from the marketplace, maintaining network integrity.

6. Investor Value: Near-Zero Default by Design

Factance offers investors a unique RWA class: Sovereign Receivables. In B2G, the debtor is the French State. Under administrative law, these are mandatory expenditures that cannot be defaulted on. France's investment-grade sovereign rating (AA-/Aa3) makes structural non-payment risk negligible. Investors are not betting on a company; they are buying a guaranteed sovereign obligation already validated in Chorus Pro. Factance provides real-economy yield as a DeFi safe haven.

7. What We Built and Why XRPL

Our working prototype on XRPL Testnet covers the full lifecycle: Factur-X PDF ingestion with XSD validation, Chorus Pro verification with Ed25519 signatures, LLM compliance with IPFS notarization and on-chain anchoring, MPT minting, IOU issuance, DEX listing and purchase, XRP settlement with dual clawback, legal assignment workflow, pooled investment fund with NAV tracking, and a React marketplace with live orderbook queries. The entire cycle runs end-to-end on testnet.

We chose XRPL because no other chain offers this natively: a built-in DEX with orderbooks, MPT tokens for provenance, trust-line clawback for settlement, 3-5 second finality, and sub-cent fees. Factance needs no smart contracts, no oracles, no bridges. The protocol itself is the infrastructure.

CORLens is the first public corridor health catalogue for XRPL cross-border payments, paired with an autonomous AI agent that routes capital through it safely.

The problem: Institutions cannot audit the XRPL payment infrastructure before committing capital. Ripple's Liquidity Hub is partner-only. Chainalysis covers sanctions, not corridor health. XRPScan shows trust lines but doesn't know what a corridor is.

Corridor Atlas — 2,436 live fiat corridors across 48 currencies

All on-chain data is fetched in real time via QuickNode XRPL WebSocket endpoints. Every corridor is classified by how it settles on XRPL:

• XRPL-native (42 corridors) — live IOU orderbooks on the DEX via GateHub and Bitstamp. We run path_find against the live ledger every hour via QuickNode.
• Hybrid — on-chain IOUs exist but are dead. Real flow runs through off-chain partners and RLUSD.
• Off-chain bridge (2,322 corridors) — settlement flows through real-world partners (CEXes, ODL partners, banks) holding RLUSD or XRP on XRPL.

Each corridor page shows AI commentary, 30-day status sparkline, actor registry with ODL/RLUSD badges, live measured orderbook depth from Bitso, and a partner flow graph.

Safe Path AI Agent — 7 custom tools

Pick two currencies and an amount. The agent uses 7 tools we built specifically for it: corridor resolution, deep entity analysis (BFS crawl + RAG indexing), web research, partner depth fetching, on-chain path analysis via QuickNode's path_find, split routing computation, and compliance report generation. It crawls every hop account for risk flags (clawback, global freeze, deep freeze), proposes split routing for large amounts, and generates a downloadable compliance report. The entire run streams live via SSE — tool calls, reasoning steps, path acceptances and rejections visible in real time.

Entity Audit

Paste any XRPL address. The same BFS crawler the Safe Path Agent uses runs standalone and produces an interactive knowledge graph: 18 node types, 19 edge types, 21 risk flags. All account data crawled live from XRPL mainnet via QuickNode.

Public REST API + MCP Server

6 REST endpoints exposing every corridor, status, and actor as JSON. A downloadable MCP server with 7 tools for Claude Desktop and Claude Code — AI agents can query CORLens programmatically.

What makes it special:

• No competitor exists — no public tool maps XRPL fiat corridors as a classified, actor-annotated, live-status catalogue
• Three-type corridor classification covers the 95% of corridors that ledger-only tools miss (the off-chain RLUSD bridge layer)
• Live measured orderbook depth from Bitso — 350k XRP bid, 6bps spread, refreshed every 60 seconds

here are the slide but we intend to use our website has demo - Slide : https://docs.google.com/presentation/d/1SGE2QhuQLQ12GqszPw615uW81fUfgL3j35qbIEEg_Uc/edit?usp=sharing

Latch is the collateral layer for XRPL - overcollateralized lending built entirely from native XRP Ledger primitives.

DeFi lending protocols hold over $40B in TVL across chains. On XRPL, that number is zero. With XLS-65 Single Asset Vaults in validator vote, XRPL is about to get native yield-bearing vault positions with on-chain LP tokens. But there's no infrastructure to borrow against them. A depositor who needs short-term liquidity has one option: withdraw everything, break the position, lose the yield.

Latch solves this in three steps:

1. Lock. LP tokens are locked in native XLS-85 Smart Escrow as collateral
2. Borrow. XLS-47 Oracle prices the collateral on-chain, RLUSD is disbursed atomically via XLS-56 Batch Transactions
3. Settle. Repayment triggers autonomous escrow release. Default triggers automatic liquidation. No button clicked, no server involved.

What makes Latch different from lending on EVM chains is what it doesn't use: no smart contracts, no Solidity, no EVM. The entire protocol is composed of six XRPL native primitives that are all live today: Escrow (XLS-85), Oracle (XLS-47), Batch Transactions (XLS-56), Credentials (XLS-70), Payments, and DIDs.

On April 10th, Ripple published XLS-100 Smart Escrow with conditional logic. This is a single primitive that validates our architecture. Latch already delivers a complete lending protocol using six primitives. When XLS-100 activates, it becomes our seventh replacing our monitoring layer with fully native on-chain settlement logic.

XRPL finalizes transactions in 3-4 seconds; extraordinary for a blockchain, but an eternity for a market maker. Today, sophisticated liquidity providers can't use XRPL's native DEX for serious trading operations. Consensus latency makes it impossible to react to price movements fast enough, manage risk in real time, or run competitive quoting strategies. So they go to centralized exchanges; and XRPL loses the volume and the liquidity depth it deserves.

AeroMatch solves this with one architectural decision: match off-chain at hardware speed, settle on-chain with XRPL finality.

The matching layer operates at the metal; a custom C++ L2 engine built for HFT, processing millions of orders per second with sub-microsecond latency. No garbage collector. No dynamic allocation on the hot path. Pure deterministic execution.

The settlement layer lives on XRPL. The engine continuously tracks a netting ledger; who owes what to whom across all fills. Every 10,000 fills, it crystallizes net positions into real XRPL Payment transactions. The result: thousands of trades settled in a single on-chain transaction, finalized in seconds, verifiable by anyone.

AeroMatch also introduces an ESG scoring layer, built directly into the matching engine. Every trader carries an ESG score reflecting their environmental and social footprint. The better the score, the lower the trading fee, calculated on every fill, encoded at the protocol level, settled on-chain. This is not a label or a certificate. It is a direct, measurable financial advantage for sustainable behavior, provable on a public ledger.

The business opportunity is the liquidity XRPL's DEX is missing. Deep markets need market makers. Market makers need speed. AeroMatch gives them the execution environment they need while keeping every settlement transparent and on-ledger. The ESG layer opens a second market: institutional capital with sustainability mandates now has infrastructure that proves responsible trading at the transaction level; by design, not by declaration.

Blockchain and high-frequency trading have always been seen as opposites. One slow, transparent, public. The other fast, opaque, private. AeroMatch proves they are complements. Fast where speed matters. Final where trust matters. Greener where it matters too.

The Problem

AI datasets are one of the most valuable digital assets today — yet they have no liquidity. Data owners face a binary choice: keep their datasets private, or sell them outright with no control over future usage. There is no middle ground.

Meanwhile, the AI industry is plagued by unauthorized data scraping. In August 2025, leaked internal documents revealed that Meta had scraped millions of websites without consent. Meta, Microsoft, and Nvidia extracted over 15.8 million YouTube videos from 2 million+ channels — with zero permission. The New York Times is suing OpenAI, Reddit sued Anthropic for 100,000+ automated bot sessions. Billions of dollars in lawsuits are accumulating across the industry.

The root cause is clear: there is no protocol for controlled, temporary, and compensated data sharing.

The Solution

Sirius (DataLend Protocol) applies DeFi lending mechanics to AI datasets on XRPL.

For Data Providers:

• Upload a dataset → it gets encrypted (AES-256-GCM) and stored on IPFS via Pinata
• A Multi-Purpose Token (MPT, XLS-33) is minted on XRPL to represent the dataset on-chain
• The MPT is deposited into a Vault (XLS-65) — the provider starts earning yield when borrowers access the data

For Data Borrowers:

• Complete KYB verification via on-chain Credentials (XLS-70)
• Post collateral and request a loan through the Lending Protocol (XLS-66)
• Receive temporary, encrypted access to the dataset — controlled by Permissioned Domains (XLS-80)
• Upon loan repayment, access is automatically revoked

Key properties:

• Only the authorized borrower can decrypt the data
• The provider retains full ownership at all times
• Every access, loan, and repayment is traceable on-chain
• Access is automatically revoked when the loan ends

How It Works — The Flow

1. Provider uploads dataset → encrypted (AES-256) → stored on IPFS
2. MPT minted on XRPL representing the dataset
3. MPT deposited into a Vault (pool)
4. Borrower submits KYB Credential on-chain
5. Borrower posts collateral → loan issued via Lending Protocol
6. Access granted through Permissioned Domain
7. Borrower decrypts and uses the dataset
8. Loan repaid → access revoked → MPT returned to provider
9. Provider earns yield from the lending fees

Why XRPL?

We leverage 5 native XRPL primitives — no custom smart contracts needed:

• XLS-33 (MPT): tokenizes datasets as on-chain assets
• XLS-65 (Vault): pools MPTs from multiple providers
• XLS-66 (Lending Protocol): manages loans, collateral, and repayment
• XLS-70 (Credentials): handles borrower KYB and provider certification
• XLS-80 (Permissioned Domains): controls vault access permissions

What Makes Sirius Different

Sirius transforms datasets from a dead asset into a productive, yield-generating asset — with full consent, traceability, and compensation. No scraping. No lawsuits. Just a protocol.

ADDITIONAL LINKS: slides: https://www.figma.com/deck/GYLKCbvMV1foLxShiHjzPh dapp: https://emayan.vercel.app/ Telegram bot: https://t.me/PettyLedgerBot

We all have petty grievances. Now, we have somewhere to put them.

Petty Ledger is a public grievance registry built on the XRPL Ledger. File a complaint against anyone, immortalize it permanently on-chain, and—if you want—notify them that a donation to a cause they hate is pending their correction. Each petty grievance generates sharable assets to start a playful conversation on social.

How it works:

1. File your grievance in your own words
2. Choose a cause they'd hate—Real Madrid Foundation, the Flat Earth Society, Nickelback
3. Set a deadline, or donate immediately with no warning

Every grievance generates a Certificate of Grievance: formally designed, delivered to the accused via a Telegram bot and socially shareable.

Each public grievance then is recorded on the blockchain and feeds into a live ledger—a real-time visualization of human pettiness, where each entry is a real XRPL transaction landing on the chain as you watch.

Why it works beyond the joke: the smallest possible financial stake, combined with public accountability, turns out to be a surprisingly effective behavior change mechanism.

Why it works for XRPL: the petty grievances add up to a lot of transactions on chain. The sharable humor aspect create a social conversation. And the live ledger keeps people coming back for entertainment.

Petty people never forget. Neither does the blockchain.

HerVoice is a cross-border funding and settlement prototype designed to support access to abortion care in Europe while protecting patient privacy.

Across Europe, abortion access remains highly unequal. Many women are forced to travel across borders to reach safe and legal care, particularly when their home country imposes strong legal or practical restrictions. In those situations, funding is often the weakest link: support organizations make informal promises, clinics face uncertainty about whether payment will arrive, and patients navigate fragmented systems at their most vulnerable moment. HerVoice addresses that financial and operational gap.

The project connects three actors in one calm digital flow: the patient, the clinic, and the funder.

The patient browses trusted clinics, selects an available appointment slot, and submits only the minimum identity information needed for later verification.

The clinic manages availability and confirms that the person presenting for care matches the protected reservation.

The funder reviews pending cases and commits funds transparently turning a funding promise into a real, verifiable on-chain commitment via XRPL escrow.

Privacy is the core design principle. No patient identity or medical record is ever written to the blockchain. Sensitive fields such as name, date of birth, and insurance number remain entirely off-chain. The backend converts identity input into a cryptographic patient hash. Only that hash travels with the funding flow, allowing the system to match a patient to a funded reservation at verification time without exposing any personally identifiable information. The MVP flow works as follows: A clinic creates available slots. A patient selects a clinic and slot, and the backend generates a pseudonymous case linked to a patient hash. A funder reviews open reservations and locks support funds via XRPL escrow. When the patient arrives, clinic staff re-enter the patient's identifying information. The backend recomputes the hash, compares it against active funded cases, and if a match is found triggers escrow release directly to the clinic wallet. The result is verifiable, auditable, and privacy-preserving: sensitive data stays off-chain, while transparent commitment and settlement happen on-chain.

HerVoice is inspired by cross-border reproductive healthcare support initiatives such as My Voice, My Choice. Its purpose is not to place care itself on-chain, but to use blockchain where it is genuinely useful reducing trust friction between parties who may not know each other directly.

The current alternatives are fragile. Clinics carry financial risk. Support organizations manage complex manual records. Patients often don't know whether promised support is truly secured. HerVoice replaces that uncertainty with a transparent, automated funding and release mechanism that reduces friction for everyone in the flow.

Beyond this use case, the same architecture applies to other trust-sensitive support flows: transport and accommodation funding, NGO reimbursement, mental health access, and other cross-border care scenarios. A future production version could integrate DID and Verifiable Credentials to restrict participation to approved clinics and accredited organizations strengthening trust and compliance without compromising patient privacy.

HerVoice is both a practical MVP and a credible foundation for privacy-first support infrastructure built on XRPL. It demonstrates that blockchain technology can serve real, human-centered coordination at a moment when reliable, discreet support matters most. Please find our pitch slides here: https://docs.google.com/presentation/d/1DbOgfx4fapBnZnW_Om2uAFAEVEbhvbvp/edit?usp=sharing&ouid=103618046287443968894&rtpof=true&sd=true

Swap.org is a comprehensive cryptocurrency on-ramp and off-ramp aggregator designed specifically for the XRPL ecosystem. We solve the fragmentation problem in the crypto-fiat gateway market by bringing together over 15 leading global providers (including MoonPay, Transak, Ramp, and Coinbase Pay) into a single, seamless interface.

Our platform empowers users to find the most cost-effective way to enter or exit the crypto market. By aggregating real-time quotes, Swap.org ensures users always get the "Best Offer" without having to manually check multiple platforms. For the XRPL "Make Waves" track, we have prioritized a premium, native-feeling mobile experience that makes XRP accessible to anyone, anywhere, with just a few taps.

Key Features:

Multi-Provider Aggregation: Unified access to 15+ global on/off-ramp partners. Smart Quote Engine: Real-time comparison with a "Best Offer" highlight to save users fees. Premium Mobile UI: Built with Ionic/Capacitor for a high-performance native experience on iOS and Android. XRPL Focused: Deep integration and default support for XRP, the heartbeat of the ecosystem. Secure & Fast: Direct redirection to providers ensures secure transactions without unnecessary intermediaries.

International commodity trade relies on bank letters of credit - a $3+ trillion market where every deal takes 4-6 weeks and costs 1-2% in bank fees. Banks act as trusted intermediaries: they hold funds, verify documents, and guarantee payment.

DeSerT replaces this with XRPL Smart Escrows. Funds lock on-chain. Independent validators - logistics operators, inspectors - confirm each stage of delivery by recording credentials on the ledger. When all conditions are met, funds release automatically. No bank, no intermediary, no manual document review.

What makes it special:

• First real-world implementation of XLS-100 Smart Escrows, released 2 days ago
• Multi-stage credential verification - WASM code checks validator confirmations directly on-ledger
• Configurable escrow stages - platform determines required validators based on deal type
• Same trust model as banking, zero intermediary cost - escrow guarantees payment just like a letter of credit, but in seconds, not weeks

We raise capital from liquidity providers through our platform and use it to construct real-world battery energy storage systems (BESS).

These assets generate revenue by filling inefficiencies in electricity markets through energy price arbitrage and grid balancing services. The yield produced is then returned to liquidity providers onchain in stablecoins.

How it works:

1. Phase - Capital Liquidity providers deposit stablecoins into the platform, creating a pool of deployable capital.

2. Phase - Infrastructure Deployment This capital is used to finance and construct battery energy storage systems in Southeastern Europe.

Phase3

A. Energy Arbitrage The batteries are charged during periods of low electricity demand (typically overnight when prices are low) and discharged during peak demand periods when prices are higher.

B . Phase Grid Balancing Services A portion of the battery capacity is allocated to grid stabilization. Due to grid overcapacity in parts of Southeastern Europe, electricity frequency imbalances are common. Our systems help stabilize the grid by providing balancing services, generating additional revenue while supporting local energy infrastructure. Onchain Yield Distribution

4. Phase Revenue generated from these activities is converted into stablecoins and distributed back to liquidity providers onchain.

Our mission is simple: capture wasted energy, reduce emissions, and make energy grids more stable.

PayTheTalent is a smart invoice and escrow platform for the creative industry. Film, TV, events, and production work depend on contractors who are often paid through agencies after long invoice cycles. The problem is clear. Less than half of surveyed creative workers are paid on time, more than a third wait over six weeks, and some never get paid because a production company becomes insolvent before payroll clears. At the same time, studios already have the budget. The real issue is the payment pipeline, where agency trust accounts, manual commission splits, daily rate work, and batch bank transfers turn a finished day of work into weeks of waiting. PayTheTalent replaces that pipeline with a three role workflow for studios, agents, and contractors. Agents build a smart invoice that links a studio, a contractor, the contractor payout, the agent commission, and the completion conditions. The studio reviews it and, when approved, funds two XRPL escrows from its wallet, one for the contractor and one for the agent. The contractor and studio both mark the work as done. Then the agent validates completion, which releases both escrows and pays the contractor and agent from the same verified flow. What makes it special is that it keeps the existing industry relationships intact while removing the slowest and riskiest part of the process. Studios still approve work. Agents still manage contracts and commissions. Contractors still work through their representatives. The difference is that funds are locked upfront, the split is calculated before work starts, every state change is visible, and the final payout happens through XRPL instead of a delayed bank run. The demo app also makes this practical for a hackathon setting, with role based accounts, contact requests, contract creation, wallet provisioning, live balances, contract status tracking, notifications, and XRPL testnet transaction hashes shown in the interface.

You can get our presentation slides here : https://docs.google.com/presentation/d/1gErMfvfse3y0D9chMJYfJHcHhB7-M-1DsqKBScBJ9WM/edit?usp=sharing Or you can grab the link directly from the README at the root of our github repository.

FOXHOUND — Parametric Climate Insurance on XRPL 1.5 billion smallholder farmers feed 70% of the world's population. Less than 5% have access to any crop insurance. One drought can erase an entire year's income. POWERPOINT : https://github.com/R4iid3n/FoxHound/blob/main/FOXHOUND_Pitch_v2.pptx Traditional insurance requires credit history, a bank account, formal identity, and physical agents on the ground. Most African smallholder farmers have none of these. When drought hits, they have nothing.

FOXHOUND changes that.

What it does A farmer registers their farm with GPS coordinates and crop type. FOXHOUND mints an NFT insurance policy on XRPL, locks coverage XRP in an on-chain escrow, and monitors for drought in real time via QuickNode Streams.

When a drought is detected, FOXHOUND queries 5 independent weather oracles (two satellites, three atmospheric models). The aggregation runs inside a RISC Zero zkVM — producing a cryptographic proof that the drought determination was honest. The proof is committed to Ethereum Sepolia via the Boundless prover network, and the Sepolia TX hash is embedded in the XRPL escrow release memo.

The escrow releases automatically to the farmer's wallet. No human in the loop. No claims adjuster. No paperwork. Pure math.

What makes it special Trustless payouts — the farmer trusts math, not FOXHOUND. The ZK proof is the trigger. Permissionless access — any XRPL wallet can register. No KYC, no bank account, no credit score. Transparent pool — every premium, deposit, and payout is public and auditable on XRPL in real time. DeFi-native — investors earn AMM yield in calm seasons; capital covers payouts in drought seasons. Classic catastrophe bond model, now open to anyone. Impact NFTs — NGOs and climate funds deposit capital and receive immutable on-chain proof of contribution for ESG reporting. Who participates Role What they do 🌾 Farmer Registers farm, pays micro-premium, receives automatic payout if drought 🌍 Sponsor Pays 2 XRP to cover a stranger's farm — recorded on XRPL forever 📈 DeFi Investor Deposits capital, earns AMM yield + premium share 🏛 NGO / ESG Fund Deposits capital, receives Impact NFT as verifiable proof Scale potential 500 million smallholder farms exist globally. At 2 XRP per farm per season: 1 billion XRP in escrow transactions annually. Each farm generates 4–6 XRPL transactions per year (registration, premium, escrow create/finish). At 10 million farms: 40–60 million transactions per year on XRPL — from a demographic that has never touched financial infrastructure before.

Financial institutions spend significant time and resources manually re-performing monthly model backtests during independent validation and internal audit reviews. This process is slow, operationally risky, and difficult to make tamper-proof, especially when third-party model providers or multiple teams are involved.

ZK Audit Trail introduces a cryptographic audit workflow for model governance. Each month, the model development team runs a local audit script on the calibration data folder used for backtesting. The script executes inside the RISC Zero zkVM, where it verifies that the correct dataset version and reference date are being used, computes a SHA-256 hash of the exact files, and records the control outcome (PASS/FAIL).

The key innovation is that the control logic itself is executed inside the zkVM. This generates a zero-knowledge proof certifying that the checks were run correctly on the precise file bytes used during the process. The proof is then submitted to XRPL Groth5 Devnet and verified on-chain via a Wasm verifier. The resulting transaction hash serves as an immutable Audit ID.

Instead of re-running historical backtests, auditors only need to retrieve the Audit ID and verify the on-chain proof and associated metadata. This drastically reduces manual audit effort while preserving full integrity, traceability, and non-repudiation.

The solution creates a zero-trust model governance framework where trust shifts from manual processes to mathematical proof. It is designed as a scalable prototype for ALM, risk model validation, ICAAP, and broader regulatory audit workflows.

Les slides de la présentation se trouve sur le lien "https://docs.google.com/presentation/d/1Hp_7BVJnh4C5XVcbSURID_kf-8_vEKjV/edit?usp=sharing&ouid=110852868168771398771&rtpof=true&sd=true"

SolveX is a protocol for funding and coordinating multi-agent problem solving.

A company comes to the platform with a real problem and locks a maximum budget upfront using XRPL escrow. The platform agent then helps formalize the problem by asking the right questions, clarifying goals, constraints, and success criteria, and turning that into a structured mission.

Once the mission is open, autonomous AI agents can explore it and contribute solutions. Instead of forcing a single winner, SolveX follows one rule: solve the problem in the best possible way. This means identifying not only the best final solution, but also every meaningful, singular block that contributes to solving the problem.

We introduce Proof of Contribution, a new economic primitive inspired by Proof of Work. Instead of rewarding raw computation, SolveX rewards only useful contributions to a real outcome. Agents can submit full solutions, partial improvements, critiques, or subcomponents. Contributions that do not add value receive nothing, while useful ones are rewarded proportionally.

To support autonomous coordination, x402 is used as the native payment interface. Agents can pay small inference fees to query the platform agent for clarification, structured context, or better understanding of the mission. Submission remains free or near-free, ensuring the system does not restrict useful intelligence from participating.

After submissions are collected, the platform agent evaluates how well each contribution aligns with the original problem and how much value it adds. Instead of selecting a single winner, SolveX constructs the best final solution by combining multiple useful contributions. Rewards are then split proportionally among contributors, while the platform takes a fee for coordination and settlement.

Over time, agents learn what types of contributions are rewarded, creating a feedback loop that continuously improves the efficiency and quality of problem solving. This introduces a market-driven selection mechanism for AI systems, optimizing them for real-world usefulness rather than benchmarks.

SolveX can become the foundation for a global market where problems attract compute and only useful intelligence gets paid.

White paper

main app demo app

TuffBet is a decentralized prediction market platform that makes on-chain betting accessible to everyone. Where existing platforms suffer from complex interfaces and high onboarding friction, TuffBet reduces the entire experience to a single gesture — swipe right to bet YES, swipe left to bet NO on questions about crypto, sports, and current events. The platform supports three authentication modes — Xaman wallet, email signup with an auto-generated wallet, and a no-setup guest mode — so any user can place their first bet in under 10 seconds, regardless of their crypto background. A live leaderboard and badge system add a social and competitive layer that keeps users engaged beyond the first session.

• Link to Slides (short pitch)
• Link to Slides (long pitch)

Gaming in web 3.0 is a "too small blanket"-problem. Indeed, relying on the chain costs too much, not relying enough introduces unfairness and, most importantly, these hard-to-balance issues negate capability to scale and build a transparent tournaments where multiple players compete to win a prize. Transparency is key: players want to be sure the prize exists, teams and spectators want matches to not be rigged and organizers would like spectators to participate and get a gain for the logistic!

We are a team of mathematicians so we went all-in to solve the following question:

Can a transparent game be built on XRPL? How would such a solution look like?

ZKolusseum is our hackathon solution that combines technological API masterpiece from XRPL ledger/smart-contracts, Boundless ZK framework, good-old theoretical research to allow our transparent scaling of gaming 3.0. For the occasion, we invented a never-seen-before game, designed only for Hack the Block 2026 and that metaphorically encapsulates the complex interaction for getting the solution!

To begin with, one needs a small premise on ZK proof and their capabilities. Out of all the properties of zero-knowledge, we cherry-picked three that have an impact on our solution:

1. ZK proofs, especially via SNARK/STARK, are succinct meaning that long transcripts can be compressed into short proofs. What are the implications? Well, less stuff must be sent to XRPL implies smaller fees and costs (even smaller that the already small XRPL's fees)!
2. ZK proofs (may) allow to hide information, meaning that if the game has secrets, the proof will not reveal anything. Implications? The game strategy is hidden thus removing any chance of "studying" your adversaries and increasing the challenge value for the spectators!
3. The most important property, ZK proofs are efficiently verifiable, way more computationally cheaper to evaluate! Implications? Complex games with complicate mechanisms to be proved can outsource all the computational costs into the ZK proving phase which is off-chain. This means that on-chain there is only cheap and quick-to-compute verifications!

The key observation is that games can generate a transcript, basically a list of inputs that when precisely played will always result in the same game finishing state.

*What about randomness?* - Asked someone from the public.

Well, much randomness is pseudo-random, meaning that it's deterministically computed to look random but it effectively is not.

So... how to combine all of this? Let us go by steps and see how ZKolosseum creates a tournament:

1. XRPL hosts a smart-contract that mainly describes the tournaments structure: it creates a prize poll, defines the matches and players and provides a hook for spectators to interact and to show the organizers costs (and gains) transparently. All these actions do not require complex code, they are all conditional checks, where providing the correct signatures or correct ZK proofs would allow to advance the correct team to the next phase, until the prize is won!

2. When a match starts, XRPL can provide a pseudo-random seed employed by the game to initialize its internal randomness. This guarantees fairness that the seed is properly generated!

3. During the game execution, the game-transcript is recorded. Additionally, the game can provide spectators with interactive gigs such as allowing chat to decide how to mess up with the game rules, creating more fun and a more interactive experience! These interactions can be properly handled via XRPL in form of micro-transactions that are added to the prize-poll.

4. When a player wins, the transcript is used as input for an ad-hoc WASM circuit designed for Boundless, describing how the game works. The goal of this proof is to verify that the game transcript is valid and that a winner has been correctly selected.

5. The ZK proof is then pushed to XRPL allowing to move the tournament to the next phase. At the end, the prize poll is fairly distributed to the winner(s) and a logistic-fee is transparently kept by the organizers.

As Rome was not built in a day during an ancient hackathon, our ZKolosseum is, sadly, not yet complete. However, we have seen that every step of our solution is feasible and can therefore be brought to life!

This work points to a potential limitation in a system’s behavior, suggesting it may not always meet certain expected properties under specific conditions.

The Problem : XRPL's native lending protocol (XLS-66d) lets anyone borrow and lend on-chain but the broker's First-Loss Capital only absorbs a small fraction of any default (typically ~5% of a full-vault loss). Depositors have no way to hedge the residual credit exposure they still bear.

What CoverFlow Does : CoverFlow is the first peer-to-peer proportional credit protection marketplace built natively on XRPL. It lets depositors (buyers) purchase protection on their vault exposure, and speculators (sellers) earn yield by underwriting that risk all settled directly on the ledger, with no bridge, no custodian, and no off-chain intermediary. Unlike a naive single-escrow implementation on XRPL, which would pay the full notional on any credit event regardless of actual loss, CoverFlow pays the buyer exactly their share of the realised loss, capped at the coverage notional. The seller forfeits only the slices that match the loss. Everyone is treated fairly. Buyers pay a market-driven premium (priced from vault metrics: debt ratio, cover rates, loan health) and receive exactly their proportional share of any realised depositor loss — never overpaid, never underpaid. Sellers lock collateral in 100 cascading escrows and keep the premium plus every slice that wasn't triggered. The oracle reads the vault's realised loss directly from the XRPL ledger state, triggers exactly the right escrows, and burns the registry NFT. Fully automated, fully on-chain.

What Makes It Special : Proportional Settlement via Cascading Escrows A naive credit protection contract uses one big escrow: if the notional is 10,000 RLUSD and the realised loss is only 3%, finishing the escrow pays out 10,000 massively overpaying the buyer. CoverFlow solves this by splitting the seller's collateral into 100 equal escrow slices at contract creation. The oracle computes the buyer's actual share of the loss and triggers exactly that many slices (rounded up). The rest are cancelled back to the seller. Honest settlement, by design.

Stateless NFT-Registry Oracle Active contracts live exclusively as NFTokens minted on the oracle wallet. The NFT's URI field encodes a compact JSON payload carrying everything needed to settle: vault ID, all 100 escrow sequences, buyer's vault share at creation, per-escrow unit amount, expiry, and both addresses. At every sweep the oracle calls account_nfts, rebuilds the full contract registry from scratch, and processes any mature or defaulted contracts. No database, no replay log a crash or redeploy loses nothing because the ledger holds the state.

Fully Native to XRPL No EVM, no bridge, no external oracle network. Every primitive escrows, NFTs, issued currencies, DEX offers is a native XRPL feature. The trigger is a native LoanManage tfLoanDefault transaction on the XLS-66d lending protocol. our website : https://coverflow-phi.vercel.app/ our presentation : https://www.figma.com/design/GUa7Q6L7w3c3bqIyHtVYdC/CoverFlow-%E2%80%94-Presentation?node-id=0-1&t=lww15KjBQKJPkjyN-1

TrustMeBro"Credit without identity. Trust verified on-chain. 1. Project Overview & VisionTrustMeBro is a wallet-native credit scoring platform built on the XRP Ledger (XRPL), designed for the 1.4 billion "credit-invisible" adults globally. This massive demographic includes high-earning expats, freelancers, and cross-border workers who possess real financial lives but zero credit score in the eyes of traditional bureaus. Our mission is to decouple creditworthiness from physical identity. By transforming real-world financial behavior (via Plaid/Stripe) into a portable, verifiable, and private on-chain reputation, TrustMeBro enables individuals to leverage their global income to access financial services anywhere. We bridge the gap between institutional banking data and Web3 privacy, bringing true financial inclusion to the digital nomad generation. 2. The Problem: A Bordered Financial SystemTraditional credit scoring models (FICO, Experian) are fundamentally broken for the modern, mobile workforce:The Expat Paradox: Financial history is geographically locked. A software engineer moving from India to France starts at "credit zero" because their history does not cross borders.The Freelance Penalty: Banks penalize irregular income patterns. A freelance designer earning $8,000/month is often seen as "risky" compared to a lower-earning salaried employee due to "unstable" cash flow. The Privacy Risk: Proving solvency today requires sharing months of raw bank statements with landlords or lenders, exposing every private transaction of your life.DeFi Stagnation: Without a reliable on-chain reputation layer, DeFi lending remains trapped in 95%+ overcollateralization, preventing it from scaling to real-world mass adoption. 3. The Solution: Deterministic TrustTrustMeBro replaces "black-box" identity-based trust with deterministic behavior-based trust anchored on the XRPL.How it Works (Technical Workflow):Identity (XLS-70d): Users connect an XRPL wallet (Xumm/Crossmark). Their wallet address becomes their Decentralized Identifier (DID)—no passport, name, or physical address required.Data Ingestion: Users link their bank accounts via Plaid and professional income via Stripe. This data is processed in an ephemeral, secure environment. The Scoring Engine: A proprietary algorithm calculates a score (300-850) based on:Cash Flow Stability: Ratio of inflows to outflows. Debt Behavior: Historical repayment reliability. Savings Discipline: Balance trajectory and liquidity buffers. On-Chain Activity: Wallet age and transaction health. Soulbound Credentialing (XLS-65/66): Once computed, the score is issued as a non-transferable Soulbound Token. This badge is anchored to the wallet DID on the XRPL.Private Verification: A shareable link allows any third party—landlords, lenders, or DAOs—to verify the score instantly on-chain without ever seeing the user's sensitive banking history. 4. Competitive Advantages & InnovationIncome Pattern Normalizer: Our core technical differentiator. Our engine recognizes and rewards the consistency of freelance payment cycles rather than penalizing their irregularity. Privacy-First (Zero-PII): We do not store transaction data or personally identifiable information (PII). Plaid/Stripe sessions are discarded immediately after computation; only the cryptographic hash of the score persists on-chain.Institutional Bridge: We bring high-fidelity TradFi data (Plaid) into the XRPL ecosystem through a privacy-preserving layer, enabling a credible path from prototype to production. 5. Track Alignment: "Make Waves"TrustMeBro is built to drive measurable ecosystem growth on the XRP Ledger:Sustainable TVL: By providing a trusted credit signal, we enable the under-collateralized lending primitives needed to unlock massive DeFi liquidity.Real-World Assets (RWA): We facilitate real flows of value by allowing credit-invisible users to prove financial reliability for housing, loans and business services globally. Efficiency: Leveraging XRPL’s 4-second settlement and low fees, we provide a reputation system that is updated and verified for a fraction of a cent. 🏁 Final Summary for Judges:"TrustMeBro turns 'Trust me' into 'Verify me. " We are building the portable financial identity for the borderless economy, leveraging the speed and security of the XRP Ledger."

The goal of this project is to provide microcredit solutions to underserved urban and rural populations in Nigeria, enabling them to finance productive assets and small-scale business activities.

Borrowers can request a loan by sending a message through USSD. This approach is a key strength of the project: the user experience is adapted to local constraints, where access to web platforms and traditional banking services remains limited.

Users are identified through their NIN (National Identification Number). By law, their NIN is paired to their sim card This allows us to reduce fraud, track borrower history, and reward responsible behavior. To strengthen our credit assessment, we integrate the third-party verification tool Dojah, which aggregates data on identity, financial activity, and risk indicators.

The project is inspired by the vision of Muhammad Yunus and aims primarily at financial inclusion and poverty reduction. There is a well-documented paradox whereby the poorest populations often face the highest borrowing costs. Our objective is to offer fairer access to credit. While profitability is not the primary goal, we expect the model to become profitable by Year 3.

We target an interest rate of approximately 10% per year, which is relatively low compared to typical microfinance rates. Loans are short-term, with an average repayment period of around 6 weeks, allowing for rapid capital rotation and tighter risk control. Based on our modeling, we assume a default rate of approximately 3%, supported by careful borrower selection, short loan cycles, and active monitoring.

Once a borrower is approved, the backend system creates a dedicated wallet on XRP. This wallet receives funds from a global capital pool (“vault”). The vault is financed by international institutions and companies seeking both ESG impact and strategic exposure to emerging markets. In the short term, these actors aim to improve their ESG positioning; in the medium to long term, they gain access to valuable market insights and potential commercial opportunities.

Within this architecture, XRPL provides several advantages:

Lower transaction costs, particularly for cross-border capital flows Transparency and auditability, enabling investors to track how funds are allocated and measure real impact Improved trust, reducing reliance on complex and costly financial intermediaries

The final stage of the process is repayment. We implement a cash-flow-aligned repayment mechanism, where repayments are linked to the borrower’s actual income rather than fixed rigid schedules. As borrowers receive funds (for example through business activity or transfers), a portion of them are automatically redirected toward loan repayment through simple, user-driven payments or integrated payment flows with local partners. This approach reduces repayment pressure, and better reflects the irregular income patterns of the targeted population.

From a financial perspective, Monte Carlo simulations suggest that the project can reach operational profitability within three years, assuming controlled default rates and progressive scaling. Significant capital will be required during the early scaling phase (around Year 3), as adoption accelerates and the loan portfolio expands.

In a second phase, we plan to enhance the model with:

Additional repayment options, including fixed weekly or monthly schedules Value-chain-based repayment, with deductions at source via cooperatives or buyers Impact tokens, enabling investors to track performance through key KPIs (repayment rates, number of borrowers financed, economic impact)

BlockBounty is a decentralized bug bounty platform built on the XRP Ledger. It solves the two core trust problems in bug bounties: hunters risk submitting findings and never getting paid, and organizations risk paying for worthless reports

Key features

• Two-step reveal: encrypt first, escrow second, reveal third
• XRPL native escrow with crypto-conditions (RFC 5280 compliant)
• Reputation scores computed from submission history
• Severity-based payout grid with auto-depleting budget pools
• 24h auto-release timeout protecting hunters from unresponsive orgs
• Stateless auth via XRPL keypair signature verification

umière is a prediction market platform built on XRPL. Users create markets, connect their wallet, and trade outcome shares with XRP. Instead of static odds, prices are generated by an automated market maker (AMM), so market probabilities update in real time based on buy and sell activity.

What makes Lumière special is the agent layer: autonomous AI agents can be configured to analyze market context and execute trades automatically. Each action is transparent and can be linked to proof artifacts, so decisions are auditable.

The platform combines:

• On-chain transactions for market actions and settlement
• Wallet-native signing (no private keys on the server)
• Real-time activity streams for live monitoring
• Admin resolution flow for final payout distribution

In short, Lumière turns prediction markets into a programmable, agent-driven economic system on XRPL.

VestiaX is building the capital markets layer for renewable energy.

Energy producers sit on long-term PPAs and contracted revenues that are predictable, valuable and illiquid. Traditional financing is slow, rigid and built mainly for larger players.

We turn energy contracted cashflows into institutional financing instruments issued on XRPL using MPT token infrastructure. Investors subscribe in RLUSD, settlement happens digitally and capital reaches the energy producer faster.

The result is a path from contracted renewable energy revenue to institutional liquidity. VestiaX helps energy producers unlock capital, structure repeatable funding programs and gives institutional investors access to transparent, digitally serviced renewable energy-backed exposure.

Learn how blockchain works by watching it live. This interactive 3D globe visualizes real XRP Ledger transactions as laser arcs, builds explorable blocks, and lets you send your own testnet payments — all in your browser. No prior knowledge needed.

The Problem

AI inference today is a black box controlled by centralized providers. You send a prompt, you get a response, and you trust that the right model ran, that your data wasn't logged, and that the price was fair. There is no way to verify any of it. There is no open market. There is no competition on price or quality. And there is no role for a decentralized ledger — because until now, there was no way to cryptographically prove what happened inside a GPU.

XRPmodels changes that.

What XRPmodels Is

XRPmodels is a decentralized marketplace where miners sell LLM inference and clients buy it — with every payment settled natively on the XRP Ledger and every computation backed by a zero-knowledge proof.

• A miner downloads a VM image, launches it on TEE-capable hardware, and starts earning OMC. The VM handles everything: key generation, on-chain registration, inference serving, and payment settlement.
• A client picks a model from the live on-chain registry, locks funds in an XRPL escrow, and starts prompting. When the session ends, the escrow settles on-chain — the client pays only for tokens consumed, unused funds refunded automatically.

No platform fee. No API key. No account. Just a wallet.

Why This Matters

XRPL becomes the settlement layer for AI compute. Every LLM session generates real, metered XRPL transactions — escrow creation, escrow finish, refund payments, miner payouts. This is not a token launch hoping for speculation. It is a utility that produces on-chain volume proportional to real-world AI usage. As AI demand grows, XRPL transaction volume grows with it.

First real use of XRPL escrows for metered service payments. XRPL escrows have existed since 2017 but are almost exclusively used for time-locked holds. XRPmodels repurposes them as a trustless prepayment mechanism — the escrow settled with a ZK proof attached as a memo. A new pattern any XRPL project could adopt for metered services: bandwidth, storage, compute, API calls.

ZK proof verification via Groth5 precompiles. Every escrow settlement includes a proof that the VM ran the exact model the client requested, inside genuine TEE hardware, with encrypted GPU memory. This is the first application using Groth5 precompiles to enforce computational integrity directly on the XRP Ledger.

Permissionless supply side. Anyone with TEE-capable hardware can become a miner. No approval process, no staking requirement, no geographic restriction. The ZK proof replaces trust — if the proof verifies, the miner is legitimate.

How It Works — Zero Ambiguity

1. Miner boots VM → wallet generated inside TEE → ZK proof (Groth16 via RISC Zero) binds model hash, TEE platform, wallet address → NFT minted on XRPL registry.
2. Client queries registry → picks model → handshake with VM → receives wallet, price per token, ZK proof → verifies.
3. Client creates EscrowCreate locking OMC to VM wallet with DestinationTag binding to the session.
4. VM detects escrow on-chain → serves inference via OpenAI-compatible API → meters token usage.
5. Session ends → VM submits EscrowFinish with ZK proof in memos → Groth5 precompile verifies → escrow releases → refund to client + payout to miner. All on-chain. All auditable.

https://ismael-f00607c9.mintlify.app/ https://docs.google.com/presentation/d/1LyrVTtLyf9eR0YjQhiQUPbPytXJOvVk7haUNRuzhCr0/edit?usp=sharing

SRWA Rail is a lifecycle infrastructure platform for institutional real-world assets on XRPL.

The problem we are solving is not token creation alone. Today, tokenization is increasingly common, but the operational workflow around the asset is still fragmented. Issuers often need separate systems for onboarding, participant approvals, compliance checks, controlled distribution, settlement, and lifecycle monitoring. That fragmentation makes institutional tokenization difficult to operate in practice.

SRWA solves this by providing one unified workflow for the full lifecycle of a tokenized asset. Through our platform, an issuer can onboard, create an asset, configure access rules, approve participants, distribute the asset, settle in RLUSD, and monitor the lifecycle through a single operational control plane.

The product is structured around three surfaces:

• an Issuer Workspace for onboarding and asset creation,
• an Ops Console for approvals, credentials, activations, and exception handling,
• and a Participant Portal for credential acceptance, subscription, market interaction, and settlement visibility.

What makes SRWA special is that it is not just a tokenization interface. It is an infrastructure layer built to make tokenized assets actually usable. We combine issuance, access control, settlement, and auditability into one system.

Our current demo shows a complete institutional flow on XRPL:

1. the issuer submits the entity,
2. SRWA Ops approves the issuer,
3. the issuer creates the asset,
4. access is configured through credentials and permissioned controls,
5. the participant accepts the credential,
6. the participant subscribes,
7. settlement goes live.

The same infrastructure can support multiple RWA templates. In the current product vision, this includes both a tokenized treasury / MMF-style flow and a trade finance use case such as soy export settlement with milestone-based releases and dispute handling.

SRWA is designed as infrastructure first: a workflow engine, service layer, and integration layer that can later be consumed through APIs, webhooks, SDKs, and reusable workflow modules.

Carro transforms how creators share and own their content. Unlike traditional platforms where content lives on rented servers and disappears when the platform shuts down, Carro stores photo stories permanently on Arweave and mints them as NFTs on Arbitrum Sepolia.

Users sign in with just their email—no wallet setup, no seed phrases, no crypto knowledge required. Behind the scenes, Dynamic's WaaS creates an embedded wallet. When users create a photo story, images are compressed client-side, uploaded to Irys (Arweave), and minted as a Content NFT. All gas fees are covered by our sponsor wallet using signature-based intent verification.

The platform features:

• One-tap onboarding: Email OTP via Dynamic → auto-mint Identity NFT
• Gasless creation: Upload 3+ photos → permanent Arweave storage → Content NFT mint, all free
• On-chain engagement: Likes and views tracked on-chain via Interaction contract
• Partner portal: Advertisers can sign up, mint Partner NFTs, and prepare ad campaigns
• Desktop QR landing: Scan to open on mobile, Partners link for advertisers

Every piece of content is cryptographically owned, portable, and survives platform shutdowns. Creators can prove authorship, engagement is transparent and verifiable, and ads can be integrated without compromising the integrity of the feed.

https://carro.claws.page/pitch

XRPL just shipped native credit: vaults (XLS-65) and lending brokers (XLS-66). You deposit into a vault, a broker originates loans, you earn interest. Simple enough — except you're locked until maturity. No exit, no price discovery, no way to compare one broker against another. We built the missing piece. Wift takes a single vault share and splits it into two tradable tokens. A Principal Token (PT) that pays you back your deposit at maturity, and a Yield Token (YT) that gives you whatever yield the vault earned above par. Both trade on the native XRPL order book against XRP. The PT price is literally the market's implied fixed rate — buy PT at 0.95, hold to maturity, get 1.00 back. Done. The YT is the other side: cheap, leveraged, worth something only if the broker actually performs.The core rule is dead simple: for every share locked in our wrapper, exactly one PT and one YT exist. shares_locked = PT_supply = YT_supply, always. This is enforced by a 3-of-5 multisig of independent signers that refuse to sign anything that would break the count. No inflation, no partial backing. Where it gets interesting is the credit curve. We seed three brokers — safe, medium, risky — each with different cover requirements. The market animator walks PT prices down at different rates per broker. When you plot implied YTM against maturity for each broker, you get three distinct curves stacked by risk premium. That's a real-time, on-chain credit term structure. It doesn't exist on XRPL today. Banks pay Bloomberg terminals for this. We built it from native primitives in a weekend.

The whole thing runs on a local standalone rippled with amendments force-enabled. Every transaction is real — VaultCreate, LoanBrokerSet, VaultDeposit, the multisig split, OfferCreate on the DEX. No mocks, no stubs, every tx hash is verifiable. The dashboard polls the ledger every 2 seconds and reconstructs the full protocol state in Postgres.

We split the frontend into a marketing landing page and a protocol app. The landing explains PT/YT with
scroll animations and has full Learn + Docs sections. The app has live markets with expandable series detail, a mint flow that submits real multisig transactions, a trade interface with Pendle-style price charts (time range tabs, dual-axis YTM overlay, volume histograms), redemption with three-path math (full, PT-only, YT-only), portfolio tracking, and an on-chain explorer.

Wallet connection supports GemWallet and Crossmark browser extensions, plus a one-click "create fresh wallet" that generates a seed client-side and funds it from genesis. The demo runs end-to-end in under 3 minutes. When XLS-101d smart contracts land on XRPL, the wrapper migrates from multisig to a ContractCall. Trust assumption drops to zero, existing PT/YT holders are unaffected. The architecture was designed for this from day one.

Imagine this: you join a new company. You’re handed Salesforce, Airtable, Figma—ten tools you’ve never used before. You waste hours figuring out where to click, interrupt your colleagues, and sit through 45-minute YouTube tutorials for something that takes 3 seconds.

Promptly solves this problem. It’s an AI assistant that lives on your screen, right next to your cursor. You ask a question—by voice or text—and an intelligent cursor shows you exactly where to click, in real time, on any application.

But Claudie goes beyond a simple copilot. It’s a bidirectional economic protocol built on XRPL.

On the user side: you pay a few cents per question through instant micropayments. No subscription, no commitment—you only pay for what you use.

On the contributor side: experts who know a tool can teach the AI how to use it. In return, they earn crypto and build a verifiable on-chain reputation. The more they contribute, the more they earn.

Money doesn’t pass through—it circulates within the ecosystem. Users fund contributors, contributors improve the AI, the AI attracts new users. A virtuous cycle where knowledge has real economic value.

Mise en Block is a wine futures marketplace built on the XRP Ledger. Small wine growers tokenize and sell unreleased vintages as case-level futures. Buyers purchase at a 20% discount to retail, with funds held in trustless XRPL escrow until the wine is produced, quality-verified through zero-knowledge proofs, and released. The blockchain is invisible to the buyer — they pay in USD, track their wine through a mobile app, and never touch a wallet.

The Problem Small wine growers spend 2-4 years producing each vintage before generating revenue. Traditional financing is difficult to secure against unproduced inventory, leaving small producers undercapitalized. Large estates solve this through allocation lists and wine club pre-sales, but these require decades of brand equity that small growers don't have.

The Solution For the winery: Confirmed forward revenue to borrow against today. A buyer's escrowed RLUSD is cryptographically guaranteed demand — not a verbal commitment. This provides cash flow visibility, borrowing power, and a 0.5% royalty on every secondary market resale.

For the buyer: A 20% discount at today's prices, ZK-verified provenance transparency, and exposure to price appreciation. Futures are tradeable throughout the production cycle — buyers can sell their position anytime before release.

For the market: Illiquid wine inventory becomes a tradeable asset class with provenance-backed price discovery, giving small producers the same financial tools large estates take for granted.

How It Works Purchase: Buyer taps "Buy" in the app, pays with credit card or Apple Pay. Behind the scenes, the backend creates a custodial XRPL wallet, converts USD to RLUSD, locks funds in escrow with a time lock (release date) and crypto-condition (attestation gate), and mints an XLS-20 NFT as the claim token.

Escrow: Two conditions must clear before the winery gets paid. The time lock prevents early settlement. The attestation gate requires cryptographic proof that the wine was produced and meets quality standards. If the wine is never produced, the CancelAfter date triggers automatic refund — no disputes, no admin.

Production: Over 2-3 years, the winery advances nine milestones: bud break, bloom, véraison, harvest, fermentation, barrel aging, bottling, bottle aging, release. At each milestone, a zero-knowledge proof verifies production claims against private sensor/lab data without exposing it, and is permanently anchored on XRPL as an immutable memo transaction tagged to the buyer's NFT.

Attestation: At release, six conditions must pass: wine bottled, case count meets futures sold, tasting panel approval, cellar conditions verified, compliance cleared, shipping ready. All six pass → escrow settles → RLUSD releases to winery → NFT becomes redeemable.

Delivery: Buyer taps "Claim Wine" in the app, confirms shipping address, wine ships. Alternatively, buyers can opt for bonded warehouse storage until optimal maturity.

Zero-Knowledge Provenance ZK proofs let the winery prove claims — "cellar temperature stayed within 55-65°F for 18 months" — without revealing actual readings. The winery's proprietary data never leaves their servers. Only boolean results are public: in-range, threshold-met, conditions-verified.

The proof chain is append-only and tamper-proof. Gaps are visible — a wine with 9/9 verified milestones commands higher trust and secondary market value than one with gaps.

The Wine Three 2026 vintage futures from 4 Winds Winery (12-bottle cases):

| Wine | Retail/Bottle | Futures/Bottle | Futures/Case | |------|--------------|----------------|-------------| | Estate Cabernet Sauvignon | $195 | $156 | $1,872 | | Tiercel Cabernet Sauvignon (Napa Valley) | $145 | $116 | $1,392 | | Chardonnay (Sonoma Coast) | $95 | $76 | $912 |

The App Buyer mobile app (iOS + Android): Shop tab for browsing and purchasing. My Cellar portfolio tracker with production phases and release countdowns. Push notifications at milestones. Provenance viewer. In-app redemption and shipping.

Winery dashboard (web): Lot management, milestone advancement, attestation gate, escrow monitoring, buyer management.

Impact Finance Mise en Block addresses structural inequality in agricultural economics. Wine allocation lists at major estates function as informal futures markets, but require decades of brand equity. A first-generation winemaker with exceptional fruit but no mailing list has no access to this capital.

Trustless escrow removes the need for brand-based trust. ZK provenance substitutes for reputation. Secondary markets create organic price discovery. The confirmed order book provides bankable collateral. This model

1. Real-World Problem & Importance Current age verification methods are a privacy nightmare. Users are forced to upload high-resolution photos of government IDs to centralized databases, creating massive targets for identity theft and data breaches.

The Problem: Merchants need to comply with regulations (alcohol, gaming, adult content), but holding sensitive user data is a liability.

The Importance: ApprovID eliminates this trade-off. We solve the "Identity Paradox" by providing 100% regulatory compliance for merchants while ensuring zero data disclosure for users.

2. Scalability & Broader Adoption ApprovID is designed for horizontal scaling beyond the hackathon:

Plug-and-Play SDK: Our architecture allows any e-commerce platform or physical kiosk to integrate age-gating with just a few lines of code.

Beyond Age: The underlying ZK-logic can scale to verify nationality (for KYC), residency, or professional certifications without revealing the identity of the holder.

Global Reach: Since it relies on international e-passport standards (NFC), the solution is instantly compatible with billions of users worldwide.

3. XRPL Features & Leverage ApprovID transforms the XRPL into a high-speed, automated identity and settlement layer. Our project utilizes the following core capabilities:

Native DID Implementation: We leverage the DIDSet transaction type to anchor W3C-compliant Decentralized Identifiers. This allows for permissionless, on-chain resolution of age credentials without centralized servers.

Monetized Verification via RLUSD/XRP: Every age check is a programmable event. Merchants pay for verifications in RLUSD (or XRP), utilizing the ledger’s high-speed settlement to ensure the verification is "paid and proved" in a single workflow.

On-Chain Accountability: By using the ledger as a registry, we provide an immutable audit trail. Merchants can prove regulatory compliance to authorities via the transaction hash without ever having stored a byte of the user’s personal data.

4. Estimated Potential Transaction Volume By moving from a "free tool" to a pay-per-verification API model, ApprovID is positioned to generate consistent, high-velocity volume on the XRPL:

Transaction Frequency: Every unique user verification triggers a DIDSet anchor, and every merchant verification call involves a settlement transaction.

Short-Term Projection: In a pilot phase with 5-10 medium-scale merchants (e.g., niche e-commerce or restricted digital content), we estimate 50,000 to 100,000 transactions within the first six months. Deck link : https://pitch.com/v/approvid-8c34yi Final product found in the branch "final-product" https://github.com/SinclairPhil/XRPL_Hackathon_2026/tree/final-product

Long-Term Scalability: As the "Identity Layer for XRPL," broader adoption by gaming platforms or age-restricted retail could push volumes into the millions of transactions per year. Because each check requires an on-chain fee and payment, ApprovID serves as a significant driver of liquidity and ledger activity for the XRPL ecosystem.

High costs of restoration, over-tourism, decreasing residency, high artistic value of this private patrimonies. Petra borns to create a money flow that co-finance this restorations, enabling private owners to actually preserve this human patrimonies.

BlockChord turns the XRPL blockchain into a musical instrument. Instead of sending payments, you send melodies. Instead of reading balances, you listen to the ledger. Every interaction is a real XRPL transaction carrying musical data in its memos.

• BlockChord Piano
• BlockBox, A loop station with 40 samples
• Composer, Write a song as a sequence of notes, broadcast it to the ledger, and hear it play back

Problem

In many developing countries, patients delay or skip treatment because of one simple barrier: upfront payment.

Healthcare costs are often too high to pay in a single transaction. Families may have income, but not enough immediate liquidity. Hospitals still need full settlement before delivering care. Traditional credit access is slow, expensive, or unavailable. Solution

MediFi bridges that gap with a decentralized payment flow on XRPL:

Patients repay medical expenses in installments without interest. Hospitals receive instant full payment. Liquidity providers cover the upfront cost. Borrowing eligibility is protected with Zero Knowledge Proofs. Identity is verified through the project’s IUD verification layer.

CYS-BOTOT is an AI-powered compliance assistant that helps industrial manufacturers including factories, energy plants, and robotics makers assess whether their machines comply with IEC 62443 and EU Regulation 2023/1230, the new EU Machinery Regulation that mandates cybersecurity for all machines sold in Europe by 2027.

THE PROBLEM OT cybersecurity compliance today is slow (4 to 8 weeks), expensive (500 euros per hour consultants), unverifiable (PDF reports can be faked), and poorly understood. Yet EU 2023/1230 makes it legally mandatory. No compliance means no EU market access for over 500000 manufacturers.

THE SOLUTION CYS-BOTOT solves this with a complete AI-powered workflow.

PAY WITH XRPL: User pays 10 XRP on XRPL Testnet to unlock a session. Real on-chain transaction with SourceTag for team attribution.

AI ASSESSMENT: The bot asks 85 structured questions across 14 sections covering IEC 62443 FR1 through FR7 including Identification, Access Control, Integrity, Confidentiality, Data Flow, Event Detection, and Availability. Also covers Functional Safety SIL levels and EU Regulation 2023/1230 specific requirements.

INSTANT SCORE: After answering, the user receives an immediate compliance score from 0 to 100 percent, a Security Level estimate from SL0 through SL4, a full breakdown by FR1 through FR7, and a styled downloadable PDF report.

RAG POWERED Q AND A: At any point users can ask free-form questions like what does Article 10 of EU 2023/1230 require. The AI answers using Retrieval-Augmented Generation over actual regulatory documents with zero hallucination and citations included.

DOCUMENT ANALYSIS: Users upload their own security policies or technical manuals. The AI compares them against the regulatory backbone and identifies gaps against IEC 62443 and EU 2023/1230.

MINT NFT CERTIFICATE: After assessment, the compliance score is minted as an NFTokenMint transaction on XRPL Testnet. The NFT URI encodes the score, Security Level, and timestamp permanently and immutably on the blockchain. Regulators and insurers can verify it on-chain without trusting any third party.

WHY XRPL IS ESSENTIAL AND NOT A BOLT ON Stripe gives a receipt. XRPL gives immutable proof. The NFT certificate is the core value proposition, a verifiable compliance record that cannot be faked, tampered with, or lost. Every user generates 2 XRPL transactions (payment and NFT mint), recurring annually per machine.

IMPACT Over 500000 EU manufacturers must comply by 2027 and the demand is legal not optional. CYS-BOTOT replaces 500 euro per hour auditors with a less than 1 hour AI assessment. It protects critical infrastructure including energy grids, water systems, and factories. It creates a blockchain-verified compliance ecosystem for regulators and insurers. Each annual re-assessment generates recurring trackable on-chain transaction volume.

The Problem

Every year, billions in humanitarian aid are lost to fraud, mismanagement, and opaque fund flows. NGOs, field offices, suppliers, and auditors operate in silos with no shared source of truth. Donors and regulators cannot verify that funds actually reach beneficiaries.

What AidRail Does

AidRail is a multi-role aid disbursement platform built on the XRP Ledger that brings full transparency and accountability to humanitarian funding.

How It Works

1. NGO Headquarters creates aid programs with budgets and authorized field offices
2. Field Offices submit payment requests to local suppliers for goods and services
3. Smart routing automatically processes small payments (inferior $500) on-chain, while larger amounts require HQ approval — enforcing segregation of duties
4. Auditors get a real-time split-screen view with on-chain verification, document hashes, and trust scores
5. Every transaction is settled on the XRPL Testnet, creating an immutable, publicly verifiable record

Key Features

• Xaman Wallet Authentication — No passwords. Users sign in with their XRPL wallet via QR code
• On-Chain Settlement — Payments are executed as native XRP transactions on the ledger
• Trust Engine — A scoring system that evaluates supplier reliability, document completeness, and transaction history
• Document Verification — Uploaded invoices are hashed (SHA-256) and stored for tamper-proof audit
• Multi-Role Access — Dedicated interfaces for NGOs, Field Offices, Suppliers, and Auditors
• Real-Time Audit Trail — Auditors can cross-reference database records with on-chain transactions instantly

Why XRPL?

The XRP Ledger offers 3-5 second settlement, near-zero fees, and built-in DEX capabilities — ideal for cross-border humanitarian payments where speed and cost matter. AidRail leverages native XRP payments with the potential to expand to issued currencies and Checks for deferred settlement.

Impact

AidRail transforms aid from a trust-based system into a verify-based system. Every stakeholder — from the donor to the auditor — can independently verify that funds were spent as intended, on-chain, in real time.

#Auctoritas

• Authority of knowledge

The global landscape for investigative journalism is increasingly hostile. Whistleblowers face judicial harassment, mass surveillance, and institutional pressure. Existing platforms offer policy-based protections — we offer architectural ones.

Auctoritas is a decentralised publishing platform built for sources and journalists operating in high-risk environments. It allows anyone to upload sensitive documents with a permanent, tamper-proof proof of existence anchored on the XRP Ledger — making censorship not just difficult, but structurally impossible.

The platform operates on a zero-knowledge, zero-retention architecture. No personally identifiable information is ever stored. Subpoenas are rendered ineffective not by legal resistance, but by the simple fact that there is nothing to hand over.

Three types of users interact with the platform. Viewers access published content freely, with no account and no trace. Anonymous sources create an account and upload documents under guaranteed anonymity — this is a first-class role, not a fallback. Certified journalists go through an additional verification step, submitting a CPI press credential reviewed manually by a platform administrator. Once verified, their publications are cryptographically signed as certified sources. Critically, the credential itself is deleted from the database immediately after review — the system verifies identity once, and does not store it.

What makes Auctoritas different is the separation between platform-layer visibility and blockchain-layer permanence. If a document is subject to legal pressure, the platform can dereference it from its own interface — a formal act of compliance. But the document remains permanently accessible via its IPFS content address, anchored immutably on the XRPL ledger. No single actor, jurisdiction, or court order can erase it.

The platform is a directory, not a host.

A protocol for compliant exchange of medical datasets between clinics and research institutions. Providers keep their raw data; consumers get cryptographically-verifiable query results. Payment is trustless via XRPL escrow.

The Problem: Healthcare institutions sit on enormous datasets that could drive life-saving research — but GDPR, HIPAA, and institutional data-sharing agreements make direct exchange legally and technically intractable. Data brokerage through third parties creates new privacy surfaces. The result: petabytes of idle, siloed medical data.

The Solution: Hera introduces a sealed computation model:

The provider seals their dataset locally (hash + secret seed). Raw data never leaves their machine.
Metadata (description, available query types, price) is published on-chain.
A consumer discovers the dataset on-chain, opens an escrow, and sends a named compute request — a query from a pre-approved list with specific parameters.
The provider runs the query locally and returns only the aggregated result (e.g. COUNT: 142), along with a cryptographic proof that the result corresponds to the sealed dataset.
The escrow resolves and payment is released atomically.

No raw data is transmitted. No new privacy surface is introduced beyond what the provider already manages internally. Every request and response is permanently anchored on the XRPL ledger.

READ ME !!!!

Pitch html: https://hera-commons.github.io/

Akoola is a B2B cross-border payment infrastructure built on XRP Ledger, targeting the $31.7 trillion global B2B payments market where banks still charge 8.78% average fees to Africa and take up to 5 days to settle.

Two products: Akoola Send, instant transfers in 4 seconds at 2% flat. Akoola Wallet conditional escrow, funds locked on-chain until delivery is confirmed, auto-released or fully refunded.

Three segments: SMEs with international suppliers, NGOs transferring humanitarian funds, and public institutions disbursing milestone-based grants. Distribution via the GPF network — 1 million francophone businesses, zero acquisition cost.

With stablecoin B2B payments growing +733% in 2025 and 54% of companies planning adoption within 12 months (EY 2025), Akoola is building the guaranteed payment rail the francophone world needs — on the only blockchain with native escrow, regulated stablecoin, and built-in DEX.