Xenmo

the whole system design of our app done in Antigravity
using Antigravity to generate our app logo alongside debugging. Multitasking at its peak.

Inspiration

We did not write this section with AI, you would be pleased to read through this

One of our team members was travelling and had a hold in Kenya, Africa. During this hold, he was hungry and wanted to eat a sandwich at the airport. The item's cost was $6 but once they used his student discover credit card to make this payment, a 3% foreign transaction fee was charged and a currency settlement fee. The final total cost ended up to be $9. $3 more than the actual cost of the sandwich.

Additionally, another team member is from India. He regularly sends and receives INR (Indian Rupee) through general forex apps like moneygram and western union. Usually these platforms have their own exchange rates and transaction fees. This genuinely discourages one to make/send payments across borders.

So why build Xenmo

Ripple mostly emphasizes on B2B solutions and there is a broad market for C2C/C2B. We are pitching Xenmo to be an additional service that ripple provides given their ownership to its massive XRP supply and instant liquidity onchain through AMMs

What it does

Xenmo lets you send money to anyone, anywhere in the world, in seconds — with no fees and no bank account required.

You create a wallet in under 30 seconds, pick your home currency (USD, INR, EUR, or NGN), and you're ready to go. You can send to someone by typing their @username, scanning their QR code, or — our favourite feature — generating a 6-digit code that you share over text or WhatsApp. The recipient just enters the code to claim the money, no wallet address needed.

We also built split payments, so if you're splitting a dinner bill with friends across different countries, each person gets their own code to claim their share in their own currency. And if nobody claims a code in time, the money automatically comes back to you — no chasing people down.

On top of that, there's a built-in AI assistant powered by Google Gemini that answers questions like "how much will my friend in India receive if I send $100?" with a live answer pulled straight from the XRPL's liquidity pools — along with a side-by-side breakdown of what Western Union or Wise would have charged* for the same transfer.

How we built it

How we built it The frontend is a Next.js 14 progressive web app — installable on mobile like a native app, no app store needed — with a custom dark UI and Three.js-powered 3D globe animations that visualize payments routing between cities in real time.

On the backend, we used the XRP Ledger for all the heavy lifting. Regular send payments use XRPL's built-in pathfinding ( path_find) to route through AMM liquidity pools and find the best exchange rate automatically. For code-based transfers, we used XRPL's conditional escrow feature — when you generate a 6-digit code, funds get locked on-chain with a cryptographic condition derived from that code. Nobody can claim it without the right code, and it auto-refunds if unclaimed.

Google Gemini 2.5 Flash powers the chatbot with live rate injection from the XRPL. All currency balances are managed through XRPL issued tokens (USD, INR, EUR, NGN stablecoins) with trust lines and AMM pools we bootstrapped ourselves.

Challenges we ran into

Oh boy this is big one!!

Honestly, the first wall we hit was just the learning curve. None of us had built on XRPL before, and the financial concepts, trust lines, AMM pools, issued tokens, pathfinding, aren't things you pick up in an afternoon. Antigravity was a huge help here, letting us move faster than we would have otherwise, and the XRPL documentation is genuinely well-written. But even with both of those, there were moments where we were staring at an error message with no clear idea of what the ledger was actually trying to tell us.

The pathfinding situation was probably the most memorable of those moments. We had payments working for same-currency transfers, but cross-currency was silently failing. We tried writing our own manual pathfinding logic, which sort of worked , until it didn't. The fallback paths were either stale, wrong, or just not found at all. We spent a long time on this going in circles.

Then we talked to Caleb from the XRPL team at the event. That conversation changed everything. He sat down with us and walked through what was actually happening, explained how trust lines work between accounts, why our AMM pools weren't being picked up by the pathfinder, and what defaultRipple does and why it matters. It clicked. We went back, rebuilt the bootstrap script from scratch with the right account settings, re-seeded the AMM pools properly, and the pathfinding started working. We cannot overstate how much that one conversation unblocked us. Sometimes you just need someone who knows the system deeply to point at the right thing.

The escrow token balance problem was another one. XRPL escrows lock XRP natively, not tokens , which was a problem because we'd built the entire UI around token balances and hidden XRP from users entirely. When someone claimed an escrow, nothing on the dashboard changed. We went through two failed approaches (self-payments that errored out, DEX orders that failed due to thin testnet liquidity) before landing on a burn-and-mint model using our issuer wallets. Not our first idea, but it ended up being cleaner than what we'd originally planned.

The last one caught us off guard right near the end — our QR code scanner worked perfectly locally but broke entirely on deployment. Turned out Vercel's deployment environment has restrictions around camera API access that don't show up in local development. We had to dig through policies, reconfigure how the component was loaded, and test a few different approaches before it finally worked in production. Not the most glamorous problem, but it was a real scramble at the wrong time.

Accomplishments that we're proud of

36 hours. Technically 35 because daylight saving decided to show up that weekend. That's the window we had to go from an idea to a working cross-border payment app built on a sector of blockchain neither of us had touched before. Getting across that finish line, as a team, is something we'll remember for a while.

The coordination alone was a win. At any given point someone was debugging escrow logic, someone was rebuilding the AMM bootstrap script, someone was wrestling with the UI, and someone was reading XRPL documentation at 3am trying to understand why pathfinding wasn't picking up our liquidity pools. We had to trust each other a lot, divide work that was deeply interconnected, and keep moving even when one piece was broken and everything else depended on it.

What we're most proud of technically is that we actually got AMM-powered cross-currency payments working end to end. Understanding how liquidity pools function, how XRPL's pathfinder traverses them, how trust lines connect issuers to users, and how all of that comes together in a single atomic payment transaction, that's a steep learning curve compressed into a very short amount of time. It didn't come easy. But watching a USD payment arrive as INR in under five seconds, routed automatically through a pool we provisioned ourselves, felt genuinely earned.

We're also proud of how complete the product feels for a hackathon. Escrow codes, split payments, QR scanning, an AI assistant with live rate data, a 3D globe that actually animates the payment routes, a PWA you can install on your phone. These weren't checkbox features, we built them because the experience felt incomplete without them.

But more than any single feature, what we're proud of is what this project is about. Global remittances are a $39 billion industry built largely on outdated rails that extract fees from people who can't afford to lose them ( https://www.xflowpay.com/blog/receive-money-from-abroad ) . XRPL has exactly the infrastructure to fix that, AMMs, instant settlement, issued tokens, conditional escrows, and yet there's no consumer product making real use of it for this. We've both been on the losing end of a foreign transaction fee for something as basic as a sandwich or sending money back home. Building something that directly addresses that, with tools that actually work, on a weekend, is what made this one matter to us.

What we learned

We learned a lot about what XRPL can and can't do out of the box. The DEX and AMM infrastructure is genuinely powerful, but testnet liquidity is thin and unreliable — which is why we ended up building our own issuer wallets and liquidity pools from scratch using a bootstrap script standing alongside our own AMM and DEX infrastructure.

We also learned that user experience on a blockchain app lives and dies by abstraction. Every time we exposed a technical detail, a wallet address, an XRP amount, a transaction hash as the primary UI, it felt wrong. Pulling those details into the background and leading with the human outcome ("₹9,194 received") was the right call every time.

What's next for Xenmo

The most natural next step is replacing our testnet stablecoins with RLUSD — Ripple's actual USD stablecoin — so the same infrastructure runs on mainnet with real money.

Beyond that, we want to add fiat on/off ramps so people can top up directly from a bank or mobile money account (M-Pesa, UPI, GCash). That bridges the last gap between a traditional user and the XRPL.

Longer term, we think Xenmo could power savings circles — rotating credit groups that are common in West African and South Asian communities — where groups of friends pool and distribute money on a schedule. XRPL's conditional escrow makes that kind of trustless coordination genuinely possible.