The problem Gravity solves

Gravity

For judges, here is a pitch deck to refer to:

• Pitch Deck: https://gamma.app/docs/Gravity-QR-Protocol-isrc1st7k10n378

Inspiration

Cryptocurrency payments are still unnecessarily hard. Assets are fragmented across chains, tokens, and ecosystems. A user may hold USDC on Base or ETH on Optimism, while a creator wants to receive MNEE on Ethereum or USDC on Lisk. The need to manually bridge, swap, and estimate gas introduces friction that kills everyday payments.

Gravity aims to remove this complexity. The goal is to build a WeChat Pay–like experience for Web3 where a creator generates a QR code for a specific amount and settlement preference (such as USDC on Lisk or MNEE on Ethereum), and the payer can complete the transaction using any asset they own on any supported chain—with automatic fallback routing if the primary path fails.

What it does

Gravity is a multichain payment gateway that abstracts cross-chain execution while respecting explicit settlement preferences.

Creators generate payment intents priced in USDC equivalent and configure their desired settlement asset and chain. Supported settlement options include MNEE on Ethereum and USDC on Ethereum, Arbitrum, Polygon, or Lisk. Each intent can define a fallback settlement token that is used automatically if routing to the primary choice fails, for example settling to USDC on Arbitrum if MNEE routing is unavailable.

Payers can fulfill these intents using any token across more than 30 supported networks. Gravity computes the optimal route through LiFi’s aggregated liquidity, spanning over 40 bridges and DEXs. Swaps and bridges are executed automatically, with seamless fallback handling if the primary route fails. Both parties receive instant confirmation and a verifiable on-chain receipt via clean, scannable QR codes, enabled by database-backed short links that reduce URL length by 90 percent.

Links & Resources

• Pitch Deck: https://gamma.app/docs/Gravity-QR-Protocol-isrc1st7k10n378
• Whitepaper: https://gravity-mnee.vercel.app/whitepaper
• Website: https://gravity-mnee.vercel.app/
• Live Demo / Payment Link: https://tinyurl.com/53pt4td7
• YouTube Demo Video:
• Github Repo: https://github.com/Tanwyhang/Gravity-LiFi-MNEE
• Architecture: https://viewer.diagrams.net/index.html?tags=%7B%7D&lightbox=1&highlight=0000ff&edit=_blank&layers=1&nav=1&title=Gravity%20Architecture.drawio&dark=0#Uhttps%3A%2F%2Fdrive.google.com%2Fuc%3Fid%3D1aw6U78bjvv3WuEOoKdBiguRADMF8gpln%26export%3Ddownload#%7B%22pageId%22%3A%224rMyojdzuHRuzDzvUUBV%22%7D

How I built it

Gravity is chain-agnostic by design, with reliability and user experience as first-class concerns.

The application is built with Next.js 16 and React 19, using React Server Components for fast initial loads and client-side modules for wallet and transaction logic. Tailwind CSS 4 and Framer Motion provide a polished, fintech-grade interface with smooth animations and responsive layouts.

Cross-chain routing is powered by LiFi SDK v3.13.5, aggregating liquidity across 40+ bridges, DEXs, and solvers on 30+ EVM chains. Wallet interactions and transaction execution are handled via Wagmi v3 and Viem v2 through the LiFi Diamond contract. This architecture supports settlement on Ethereum, Arbitrum, Polygon, and Lisk without fragmenting liquidity.

Payment intent metadata and link configuration are managed using Prisma v7 and Supabase. Moving from URL-encoded parameters to database-backed lookups reduced QR code complexity by 90 percent, significantly improving scan reliability. Wallet connectivity is handled through RainbowKit v2.2.9, supporting hardware wallets, WalletConnect, and major browser wallets.

An automatic fallback settlement system ensures high payment success rates by transparently retrying with an alternative settlement token when primary routing fails.

Accomplishments

Gravity enables end-to-end multichain payments in under 30 seconds, even when payer and recipient are on different networks. Lisk is supported as a first-class settlement option within a broader multichain system that also includes Ethereum mainnet, Arbitrum, and Polygon.

Key results include:

• 90 percent reduction in payment URL length through database-backed QR links
• Automatic fallback routing that significantly improves transaction success rates
• Multi-chain settlement across four networks and five settlement assets
• Production-quality UX with branded payment pages, real-time status tracking, and cryptographic receipts.
• Clean, scannable QR codes suitable for real-world usage

The result is a production-ready payment system that makes cross-chain transactions feel as simple and predictable as scanning a QR code at a coffee shop.

Challenges I ran into

Challenges

Building Gravity was less about connecting APIs and more about solving complexity at the boundaries between frontend systems and multichain execution.

Bleeding-edge frontend constraints
Using Next.js 16 and React 19 put Gravity ahead of most Web3 tooling. Many wallet and state libraries still assume older React lifecycles and synchronous rendering. This caused hydration mismatches, provider ordering issues, and race conditions between server-rendered components and client-side wallet state. I solved this by strictly isolating all wallet, routing, and transaction logic behind explicit client boundaries, enforcing deterministic provider initialization, and restructuring state so no Web3 assumptions leaked into server components.

Abstraction versus user trust
The core UX tension was simplifying payments without removing confidence. A one-click Pay flow is ideal, but hiding fees, routing, and settlement details reduces trust.
I resolved this using progressive disclosure. The default interface remains minimal and focused on the payment action, while expandable modules reveal routing steps, estimated fees, slippage, and the final settlement chain when users want to inspect the transaction before signing.

Real-time multichain pricing and routing
Cross-chain quotes are unstable due to price volatility, gas fluctuations, and bridge latency. Quotes that are valid at render time can become invalid seconds later. I addressed this by implementing a real-time quote refresh and invalidation system using controlled polling and cache lifetimes, ensuring users always sign against fresh routes without causing constant UI shifts or failed transactions.

Asynchronous finality and user feedback
Different chains and bridges finalize at different speeds, making it difficult to present a consistent payment state. I solved this by modeling the payment lifecycle as a unified state machine that maps asynchronous on-chain events into clear UI states such as pending, confirming, and completed, so users always understand progress without being exposed to protocol-level details.

Multichain support without lowest-common-denominator design
Supporting multiple chains, including Lisk, without degrading the experience required avoiding hardcoded chain logic. I designed Gravity around chain-agnostic interfaces where the target chain is treated as data rather than configuration, allowing Lisk and other networks to be integrated as first-class options without architectural changes.