Pagga

Aqua x 402: AI Agent Credit Marketplace with Shared Liquidity What is this project? Aqua x 402 is a decentralized credit marketplace that enables AI agents to access financing through two innovative matching mechanisms: Request-for-Quote (RFQ) and competitive auctions. Built on top of the 402 protocol (x402/A2A), our platform integrates with 1inch Aqua's shared liquidity pools to create a seamless bridge between capital providers and AI agents that need funding for autonomous operations. The Problem We're Solving AI agents operating autonomously need access to credit to pay for services, API calls, compute resources, and other operational expenses. Traditional finance doesn't understand agent-to-agent (A2A) transactions, and existing crypto lending is designed for humans, not autonomous software. There's a massive gap in the market for programmable credit lines that can be automatically negotiated, executed, and repaid by AI agents without human intervention. Our Solution: Three Core Innovations

1. Dual Matching Mechanisms RFQ (Request for Quote) Mode: When an AI agent needs funding, it creates an RFQ specifying the amount, duration, collateral type, and intended use (stored as IPFS URI). Lenders review these requests and submit competitive quotes with their proposed interest rates (in basis points), credit limits, and collateral requirements. The borrowing agent evaluates all quotes and selects the best offer. Once accepted, the terms are automatically converted into a 402 protocol credit line with programmatic payment streams. Auction Mode: For agents seeking the most competitive rates, they can launch a time-bound auction. Lenders place bids with progressively better terms, competing to provide capital. The auction mechanism ensures price discovery through competition - lenders must offer lower interest rates or better terms to win. When the auction finalizes, the winning bid(s) are automatically executed through 402 credit lines, with escrow and streaming payments set up on-chain.
2. 1inch Aqua Integration for Shared Liquidity Rather than locking capital in isolated lending pools, our platform leverages 1inch Aqua's shared liquidity infrastructure. This means:

Capital Efficiency: Lenders can deposit USDC into Aqua pools that serve multiple DeFi protocols simultaneously, earning yields from various sources while staying available for agent financing Instant Liquidity: When an RFQ is accepted or auction is won, liquidity is reserved from the Aqua pool without requiring dedicated capital allocation Seamless Returns: Repayments flow back into Aqua pools, maintaining liquidity for other protocols and earning compound yields Cross-Protocol Optimization: Aqua automatically routes capital to highest-yield opportunities while keeping it available for our agent credit marketplace

1. 402 Protocol Credit Lines Every successful match (RFQ or auction) is converted into a 402 protocol credit line, which provides:

Programmable Payments: Credit lines with automated payment streams that AI agents can trigger programmatically Escrow Protection: Collateral and payments flow through trustless escrow contracts Agent-Native Design: Built specifically for agent-to-agent transactions with machine-readable terms Payment Streaming: Continuous payment flows rather than lump sum repayments, matching agent revenue patterns On-Chain Transparency: All terms, limits, and payment history recorded on-chain for auditability

Technical Architecture Smart Contracts (Solidity on EVM) RFQ Contract:

createRFQ(amount, duration, collateralType, flowDescription) - Agent posts funding request with IPFS metadata submitQuote(rfqId, rateBps, limit, collateralRequired) - Lenders submit competitive offers acceptQuote(rfqId, quoteId) - Agent selects winning quote executeRFQ(rfqId) - Converts accepted quote into 402 credit line with automated escrow setup

Auction Contract:

createAuction(amount, duration, endTime) - Launch competitive bidding for capital placeBid(auctionId, rateBps, limit) - Lenders bid with terms (lower rate = better bid) finalizeAuction(auctionId) - Determines winner(s) based on best rate or optimal blended terms settleAuction(auctionId) - Executes winning bid(s) through 402 protocol with on-chain settlement

Aqua Integration Contract:

connectLiquidity(amount) - Lenders pledge capital through Aqua shared pools reserveLiquidity(creditLineId, amount) - Locks liquidity when credit line is created releaseLiquidity(creditLineId) - Returns capital to Aqua pool upon repayment swapViaAqua(fromToken, toToken, amount) - Handles any token conversions needed

Agent Finance Contract:

Wrapper layer that connects our RFQ/Auction results to existing 402 protocol contracts Manages credit line creation with parameters from matched offers Handles limit adjustments based on agent reputation and collateral Interfaces with 402 escrow and streaming payment contracts

Backend Services (Go + Echo Framework) RFQ Service:

REST API for creating, browsing, and filtering active RFQs WebSocket connections for real-time quote notifications to borrowers Event indexer monitoring on-chain RFQ contract events Quote aggregation and ranking by best terms

Auction Service:

Real-time bid tracking with WebSocket broadcasts Automated auction finalization using timer-based triggers Bid validation and ranking logic Settlement orchestration with 402 protocol

Aqua Service:

Integration with 1inch Aqua SDK for pool interactions Liquidity availability monitoring and reporting Capital allocation tracking per lender Yield calculation from Aqua pools

x402 Integration Service:

Monitors matched RFQs and finalized auctions Orchestrates 402 credit line creation with matched parameters Tracks payment streams and repayment status Handles collateral management through 402 escrow

Infrastructure:

ClickHouse + BUN ORM: High-performance analytics database for historical RFQs, auctions, quotes, bids, and agent reputation scoring RabbitMQ: Message queues for event processing (new quotes, bid updates, credit line activations), background jobs (interest accrual, auction finalization), and webhook delivery Hardhat: Smart contract development, testing, and deployment to Sepolia (Ethereum) and Mumbai (Polygon) testnets

Frontend (React + Vite + TypeScript) Borrower Dashboard:

Intuitive RFQ creation form with amount, duration, collateral selection, and flow description Real-time quote feed showing competitive offers from lenders One-click auction launch for competitive rate discovery Active credit line management showing limits, utilization, payment schedules Agent reputation display (history, successful repayments, default rate)

Lender Dashboard:

Live RFQ marketplace with filters (amount, duration, collateral type, borrower reputation) Quote submission interface with rate calculator showing potential yields Auction participation with live bid leaderboard Aqua liquidity connection showing available capital and current yields Portfolio view of active credit lines and expected returns

Auction Live View:

Real-time visualization of active auctions with countdown timers Animated bid feed showing new competitive offers as they arrive Chart displaying bid history and rate trends over auction duration Borrower details and credit parameters One-click bid submission for participating lenders

Aqua Integration Dashboard:

Current liquidity pool status and TVL Lender capital allocation (available vs. reserved for credit lines) Yield metrics from Aqua pools vs. direct lending Visual representation of capital flowing between Aqua and agent credit lines

Integration Technologies

ethers.js: Contract interaction, transaction signing, event listening wagmi + WalletConnect: Multi-wallet support (MetaMask, WalletConnect, Coinbase Wallet) WebSocket: Real-time updates for quotes, bids, auction status changes IPFS: Decentralized storage for detailed RFQ descriptions and agent metadata OpenTelemetry: Distributed tracing for debugging cross-service interactions

Real-World Use Cases

1. SaaS Agent Cash-Flow Financing A customer support AI agent generates $50k monthly revenue but needs $30k upfront for compute infrastructure. It creates an RFQ for a 90-day credit line, offering future revenue streams as collateral. Lenders review the agent's payment history and revenue consistency, then compete with quotes. The agent accepts the best rate, receives instant liquidity from Aqua, and automatically repays through 402 payment streams as customers pay invoices.
2. Marketplace Factoring Agent An e-commerce fulfillment agent helps merchants process orders but faces 30-day payment delays. It launches an auction for $100k credit line backed by confirmed purchase orders. Lenders bid aggressively knowing the collateral is high quality. The winning lender provides capital at 8% APR, and the agent repays automatically when marketplace payments settle on-chain.
3. API Micro-Lending for Agent Swarms A swarm of data processing agents needs small ($100-$1000) credit lines to pay for API calls across multiple services. Rather than each agent negotiating separately, they pool requests into a single large RFQ. Lenders provide bulk financing at favorable rates because of scale. Each agent receives its allocation through 402 micropayment streams, paying back as they complete processing jobs.
4. Research Agent Compute Credits An academic research AI agent needs GPU compute for training models but lacks upfront capital. It creates an RFQ offering future grant funding as collateral (locked in smart contract). Academic-focused lenders provide capital at low rates (3-5% APR) because they value research advancement. The agent provisions cloud resources immediately and repays when grant disperses. Why This Matters for AI x Crypto Agent-Native Finance: Traditional DeFi is built for humans with manual approvals, signatures, and decision-making. AI agents need programmatic credit that can be negotiated, executed, and repaid autonomously without any human in the loop. Capital Efficiency: By leveraging Aqua's shared liquidity, we enable lenders to earn yields across multiple protocols while staying available for agent financing. This is dramatically more efficient than dedicated lending pools. Price Discovery: The dual RFQ + Auction model ensures agents get competitive rates. RFQ works for agents with specific requirements; auctions work when agents want the absolute best rate through competition. Scalability: As AI agents proliferate, credit demand will explode. Our architecture scales horizontally with ClickHouse for analytics, RabbitMQ for async processing, and EVM's composability for cross-protocol integrations. Transparency: All credit terms, repayment history, and agent reputation are on-chain. This creates a decentralized credit bureau for AI agents, enabling better risk assessment over time. Competitive Advantages

First dual-mechanism agent credit marketplace combining RFQ flexibility with auction competitiveness Only platform integrating Aqua shared liquidity with agent-specific credit lines Built on 402 protocol for truly programmable, agent-native payments Real-time price discovery through live auctions with WebSocket updates Cross-chain ready - EVM architecture works on Ethereum, Polygon, Arbitrum, and other L2s Reputation system tracking agent payment history for better rates over time

Target Prizes Strategy 1inch Aqua Prize (~$17k): We're building the first Aqua App specifically for AI agent financing, showcasing how shared liquidity unlocks capital efficiency for emerging agent economy use cases. Polygon Prize (~$10k): Our implementation demonstrates the most practical use of x402 protocol - autonomous credit lines for AI agents with real-world utility in SaaS, marketplace, and compute financing scenarios. Coinbase Developer Platform: Integration of x402 agentic payments with Coinbase Wallet SDK, enabling mainstream users to participate as lenders through familiar UX. World Coin: Mini-app dashboard for agents with World ID verification, creating a bridge between human identity and agent reputation systems. This project sits at the intersection of DeFi innovation (Aqua shared liquidity), agent infrastructure (402 protocol), and practical crypto applications (competitive credit marketplace). It's not just technically sophisticated - it solves a real problem that will become critical as AI agents become economic actors in their own right.

How Aqua x 402 Was Built: Technical Deep Dive Architecture Overview We built a full-stack decentralized application with three main layers: Smart Contracts (EVM/Solidity), Backend Services (Go), and Frontend (React). The system orchestrates complex interactions between 1inch Aqua pools, 402 protocol credit lines, and our custom RFQ/Auction mechanisms - all while maintaining real-time updates and capital efficiency. Smart Contract Layer (Solidity + Hardhat) Development Environment Setup Hardhat Configuration: We used Hardhat as our primary development framework with a multi-network setup:

Localhost: Hardhat node on port 8545 for rapid iteration and testing Sepolia: Ethereum testnet for final integration testing Mumbai: Polygon testnet to demonstrate cross-chain compatibility

We leveraged hardhat-verify for automatic contract verification on block explorers, making it easy for judges to inspect our deployed contracts. The development environment includes ethers.js v6 for contract interactions, dotenv for environment variable management, and the full Hardhat toolbox for testing and deployment. Contract Architecture

1. RFQ Contract (contracts/rfq/RFQ.sol) The RFQ contract manages the entire quote request lifecycle with gas-optimized storage. We designed the data structures to minimize storage slots by using packed structs - leveraging uint8 and uint16 where possible instead of always defaulting to uint256. Each RFQ contains the borrower address, requested amount, duration, collateral type, and an IPFS hash pointing to detailed flow descriptions. Gas Optimization Techniques:

Packed structs to minimize storage slots (uint8 for collateral type, uint16 for rates in basis points) Batch quote submission to reduce transaction count Indexed events for efficient off-chain querying Minimized SLOAD operations by caching storage reads in memory

The core workflow enables borrowers to create RFQs specifying their credit needs, lenders to submit competitive quotes with their proposed rates (in basis points), limits, and collateral requirements, and borrowers to accept the best quote. The acceptance triggers integration with our AgentFinance contract to create the actual 402 credit line. 2. Auction Contract (contracts/auction/Auction.sol) The auction mechanism implements a descending rate auction where lenders compete by offering progressively lower interest rates. The contract tracks all bids chronologically and implements sophisticated finalization logic that selects the winning bid based on the lowest rate offered. Particularly Hacky Detail #1: We implemented an anti-snipe mechanism that automatically extends the auction by 5 minutes if any bid comes in during the final 5 minutes. This prevents last-second sniping and ensures true price discovery. The extension can trigger multiple times, creating an exciting "going once, going twice" dynamic that encourages genuine competition rather than gaming the timer. The auction finalization logic iterates through all submitted bids to find the one with the lowest rate, then marks that bid as the winner and triggers settlement through the AgentFinance contract. We also implemented a fallback mechanism where if no bids meet the borrower's minimum requirements, the auction can be cancelled and refunded. 3. Aqua Integration Contract (contracts/aqua/AquaIntegration.sol) This is where we integrate with 1inch Aqua's shared liquidity pools. Important note: Since Aqua SDK wasn't fully available in testnets during development, we built a sophisticated mock that simulates shared liquidity behavior while maintaining the exact interface we'd use in production. Particularly Hacky Detail #2: Our Aqua mock implementation doesn't just store balances - it simulates realistic DeFi behavior:

Tracks deposits from multiple lenders with individual accounting Simulates yield accrual using a configurable APY (we set it to 5% annually) Implements reservation/release mechanics that mirror how Aqua would actually work Provides the exact same function signatures as production Aqua Includes emergency pause functionality for safety

This means our integration code is production-ready and can seamlessly swap from mock to real Aqua by simply changing the contract address in our configuration. No code changes required - just point to the real Aqua pool address when it's available on mainnet. The contract tracks three key metrics per lender:

Total deposited: All capital they've committed to Aqua Reserved: Amount currently locked in active credit lines Available: Capital ready to fund new credit lines

1. Agent Finance Contract (contracts/finance/AgentFinance.sol) This contract acts as the orchestration layer between our RFQ/Auction system and the existing 402 protocol. It's the glue that makes everything work together. When a credit line is created, the contract:

Reserves the required liquidity from Aqua pools Creates the 402 credit line with the negotiated parameters (rate, limit, duration) Locks collateral in the 402 escrow contract Emits events for off-chain tracking and indexing Returns a unique credit line ID that links everything together

This wrapper pattern allows us to extend 402's functionality without modifying the core protocol, maintaining composability while adding our credit discovery layer on top. We also implemented reputation tracking - each successful repayment improves an agent's score, potentially qualifying them for better rates in the future. Contract Testing Strategy We implemented comprehensive testing with Hardhat and Ethers v6. Our test suite covers:

Unit tests: Every contract function with edge cases (zero amounts, expired auctions, unauthorized access) Integration tests: Complete RFQ and auction flows end-to-end Gas optimization tests: Ensuring our optimizations actually reduce costs Failure scenarios: What happens when transactions revert, when auctions have no bids, when collateral is insufficient

Particularly Hacky Detail #3: We created a "time travel" helper in our tests that manipulates block.timestamp to simulate auction expirations and payment schedules without waiting real time. This let us test 90-day credit lines in seconds. Backend Services Layer (Go + Echo Framework) Infrastructure Setup Why Go? We chose Go for the backend because:

Excellent concurrency primitives (goroutines, channels) for handling multiple WebSocket connections Fast compilation during hackathon rapid iteration Strong standard library for HTTP servers and JSON handling Native support for blockchain RPC calls via go-ethereum Strong typing catches bugs at compile time rather than runtime

Framework Choice: Echo was selected over Gin because:

Built-in WebSocket support without additional libraries Better middleware ecosystem for our needs Superior performance in high-concurrency WebSocket scenarios (which we need for live auction updates) Cleaner routing and context handling

Database Architecture: ClickHouse + BUN ORM Why ClickHouse instead of PostgreSQL? This was one of our most critical architectural decisions. Traditional DeFi applications default to Postgres, but we needed something different:

High-write throughput: Blockchain events generate tons of writes (every quote, bid, payment). ClickHouse handles millions of inserts per second. Fast analytical queries: Agent reputation scoring requires aggregating historical payment data. ClickHouse's columnar storage makes this blazing fast. Time-series optimization: Auction bid history and rate trends are time-series data. ClickHouse is purpose-built for this. Horizontal scalability: As the agent economy grows, we can add more nodes without changing application code.

ClickHouse Cluster Setup: We reused the existing ClickHouse infrastructure with:

4 ClickHouse nodes in a replicated configuration ZooKeeper for distributed coordination and leader election HAProxy load balancer routing queries (port 8123 for HTTP, port 9000 for native protocol)

This gives us high availability - if one node fails, queries automatically route to healthy nodes. BUN ORM Integration: Instead of GORM (which is Postgres-focused), we integrated BUN specifically designed for ClickHouse. BUN provides:

Clean query builder API that feels natural in Go Proper ClickHouse data type support (DateTime64, LowCardinality, etc.) Connection pooling for performance Migration management

Particularly Hacky Detail #4: ClickHouse doesn't support traditional ACID transactions (it's eventually consistent). So we implemented a pseudo-transactional pattern using optimistic locking: When accepting an RFQ quote:

Read the current RFQ with its status Verify it's still "open" (not already accepted) Update with a WHERE clause: WHERE id = ? AND status = 'open' Check affected rows - if zero, someone else accepted it first If non-zero, we won the race and the quote is ours

This prevents race conditions where multiple quotes could be accepted simultaneously, without needing full transaction support. It's optimistic locking implemented at the application level. RabbitMQ Message Queue Why RabbitMQ? We needed asynchronous processing for:

Blockchain event indexing: Can't block the main API server waiting for ClickHouse writes Background jobs: Auction finalization needs to run automatically when time expires Webhook delivery: External partners need notifications without blocking our responses Rate limiting: Some operations (like calling external APIs) need throttling

Queue Architecture: We configured RabbitMQ with three primary queues:

1. events queue:

Processes blockchain events (RFQCreated, QuoteSubmitted, BidPlaced, CreditLineActivated) Multiple consumers for parallel processing Durable queue that survives RabbitMQ restarts Dead letter queue for failed events that need manual investigation

1. jobs queue:

Background tasks (auction finalization, interest accrual calculations) Single consumer to avoid duplicate processing Priority queue - urgent jobs (like expired auctions) jump the line Scheduled tasks use TTL to delay execution

1. webhooks queue:

Webhook delivery to external systems Retry with exponential backoff (3 attempts: immediate, 5min, 30min) Circuit breaker pattern - if a webhook endpoint is down, we pause delivery Rate limiting per destination to respect their API limits

Particularly Hacky Detail #5: Our RabbitMQ consumer implements graceful degradation. If ClickHouse is temporarily overloaded:

We detect slow queries (>500ms) Start buffering events in memory (up to 10,000) Slow down consumption from RabbitMQ Once ClickHouse recovers, drain the buffer Resume normal operation

This prevents cascading failures and ensures we never lose events even during high load spikes. Service Layer Architecture

1. RFQ Service (internal/services/rfq/service.go) The RFQ service manages the entire lifecycle of quote requests. It provides:

REST API endpoints: Create RFQ, list active RFQs with filters, get specific RFQ details, submit quotes, accept quotes WebSocket subscriptions: Borrowers subscribe to real-time quote updates for their RFQs Event indexing: Listens to on-chain events and indexes them into ClickHouse Quote ranking: Automatically ranks quotes by best terms (lowest rate, highest limit, etc.)

The service integrates with the Ethereum client to build and submit transactions. After submission, it waits for confirmation (using exponential backoff polling), extracts the RFQ ID from emitted events, and publishes to RabbitMQ for indexing. WebSocket Real-Time Updates: When a lender submits a quote on-chain:

Our event indexer catches the QuoteSubmitted event Stores it in ClickHouse Publishes to Redis pub/sub channel for that RFQ All WebSocket clients watching that RFQ receive instant notification Frontend updates the quote list in real-time without refresh

This gives borrowers instant visibility into competitive offers as they arrive. 2. Auction Service (internal/services/auction/service.go) The auction service implements sophisticated bid tracking and finalization:

Bid validation: Each bid must offer better terms than current best (lower rate) Real-time broadcasting: New bids immediately broadcast to all WebSocket viewers Automatic finalization: Background worker triggers when auction time expires Extension handling: Implements the anti-snipe logic on-chain and tracks in DB

Auction Timer Worker: We run a separate worker process with a ticker that checks every 30 seconds:

Query ClickHouse for auctions past their end time Filter out already finalized auctions For each expired auction, queue a finalization job in RabbitMQ The job worker picks it up and submits the finalization transaction Update database to reflect completion

This ensures auctions settle promptly even if the borrower goes offline. The decentralized nature means anyone can trigger finalization, but we automate it for UX. 3. Aqua Service (internal/services/aqua/service.go) The Aqua service manages lender liquidity connections:

Connect liquidity: Handles USDC approval and Aqua deposit in one flow Query allocation: Shows lenders their total/reserved/available capital Yield tracking: Calculates and displays estimated yields from Aqua pools Reserve/release: Coordinates with AgentFinance contract for credit line lifecycle

Particularly Hacky Detail #6: We implemented a liquidity oracle that periodically queries Aqua pools for current yields. This data feeds into our UI's yield calculator, helping lenders compare:

Direct lending rate (e.g., 8% APR from agent credit line) Aqua pool base yield (e.g., 5% APR from DeFi protocols) Combined effective yield when capital is partially deployed

The oracle caches results for 5 minutes to reduce RPC calls, but invalidates immediately when major pool events occur. 4. x402 Integration Service (internal/services/x402/service.go) This service bridges our system with the 402 protocol: Credit Line Creation: When an RFQ quote is accepted or auction finalized:

Call AgentFinance.createCreditLine() with negotiated terms Wait for transaction confirmation Extract credit line ID from event logs Update RFQ/Auction record in ClickHouse with the link Subscribe to 402 payment stream events for that credit line

Payment Monitoring: We run a dedicated event listener for 402 PaymentMade events:

When payment detected, record in ClickHouse Update credit line utilization and repayment progress If fully repaid, trigger Aqua liquidity release Update agent reputation score based on payment history Emit webhook for lender notification

Reputation Engine: We built a simple but effective reputation system:

On-time payments: +10 points Early repayment: +15 points Late payment (1-7 days): -20 points Late payment (8-30 days): -50 points Default (30+ days): -200 points

Agents with higher scores qualify for better rates (we implement this as a discount on the lender's quote). This creates incentives for good behavior. EVM Client Package (pkg/evm/client.go) We built a robust EVM client wrapper that handles:

Connection management: Maintains persistent connection to RPC endpoint with automatic reconnection Nonce tracking: Thread-safe nonce management to prevent transaction conflicts Gas estimation: Smart gas price suggestions using EIP-1559 when available Transaction signing: Proper EIP-155 signature with chain ID Receipt waiting: Polls for transaction confirmation with configurable timeout Error handling: Retries on transient errors, fails fast on permanent errors

Particularly Hacky Detail #7: Our gas estimation implements adaptive pricing:

In normal conditions: Use network suggested gas price During congestion (>90% full blocks): Add 20% buffer During extreme congestion (pending tx pool growing): Add 50% buffer and warn user Failed transactions: Automatically retry with 10% higher gas

This ensures our transactions go through even during network spikes, which is critical for time-sensitive auction finalizations. API Routes (Echo Framework) Our API is organized into logical route groups: RFQ Endpoints:

POST /api/rfq - Create new RFQ GET /api/rfq - List RFQs with filters (amount range, duration, status, borrower) GET /api/rfq/:id - Get specific RFQ with all quotes POST /api/rfq/:id/quote - Submit quote as lender POST /api/rfq/:id/accept - Accept quote as borrower GET /api/rfq/:id/ws - WebSocket for real-time quote updates

Auction Endpoints:

POST /api/auction - Create new auction GET /api/auction - List active auctions GET /api/auction/:id - Get auction details with bid history POST /api/auction/:id/bid - Place bid as lender GET /api/auction/:id/ws - WebSocket for live bid feed

Aqua Endpoints:

POST /api/aqua/connect - Connect liquidity to Aqua pool GET /api/aqua/liquidity/:address - Get lender's allocation status GET /api/aqua/yields - Get current Aqua pool yields

Credit Line Endpoints:

GET /api/credit/:id - Get credit line details GET /api/credit/:id/payments - Get payment history GET /api/agent/:address/reputation - Get agent reputation score

All routes use Echo middleware for:

Request logging with OpenTelemetry tracing CORS handling for frontend access Panic recovery to prevent crashes Request validation and sanitization Rate limiting per IP address

Frontend Layer (React + Vite + TypeScript) Tech Stack Choices Why React + Vite over Next.js?

HMR speed: Vite's hot module replacement is sub-50ms vs Next.js ~1-2s. Critical during hackathon. Simpler config: No server-side rendering complexity, just pure client-side app Better for Web3: Wallet connections work more naturally in SPA architecture Smaller bundle: Vite's tree-shaking produces ~30% smaller bundles for our use case

Key Technologies:

ethers.js v6: Latest version with better TypeScript support and smaller bundle wagmi: React hooks for wallet connections, handles multi-wallet complexity TanStack React Query: Data fetching, caching, and synchronization Zustand: Lightweight state management (~1kb vs Redux's ~12kb) Recharts: Declarative charts for auction bid visualization Framer Motion: Smooth animations for live auction feed Tailwind CSS: Utility-first styling for rapid development

State Management Architecture Zustand for Global State: We chose Zustand over Redux because:

Minimal boilerplate (no actions, reducers, providers) Better TypeScript inference out of the box Easier to integrate with React Query Can use outside React components (useful for WebSocket handlers)

Our stores:

walletStore: Connection state, address, chain ID, connect/disconnect methods auctionStore: Active auctions being watched, bid history cache notificationStore: Toast notifications for transaction status

React Query for Server State: React Query handles all API and blockchain data:

Automatic caching with configurable TTL Background refetching to keep data fresh Optimistic updates for instant UI feedback Query invalidation on mutations Loading and error states built-in

This eliminates manual state synchronization - React Query ensures UI always reflects reality. Contract Interaction Layer We built clean abstractions for each contract: RFQContract class:

Wraps the deployed RFQ contract with type-safe methods Handles transaction signing and confirmation waiting Extracts data from events using contract ABI Provides hooks like useCreateRFQ(), useSubmitQuote(), useAcceptQuote()

Particularly Hacky Detail #8: Our contract hooks implement optimistic updates: When creating an RFQ:

Immediately add placeholder RFQ to local state (shows loading spinner) Submit transaction to blockchain If successful, replace placeholder with real data from event If failed, remove placeholder and show error toast Either way, refetch from backend to ensure consistency

This makes the UI feel instant even though blockchain confirmations take 10-15 seconds. WebSocket Real-Time Updates Custom useWebSocket Hook: Particularly Hacky Detail #9: We implemented automatic reconnection with exponential backoff: Attempt 1: Reconnect immediately Attempt 2: Wait 1 second Attempt 3: Wait 2 seconds Attempt 4: Wait 4 seconds Attempt 5+: Wait 8 seconds (max) The hook also:

Maintains connection status in state Queues messages sent during disconnection Replays queued messages on reconnect Parses incoming JSON automatically Provides type-safe message handling

This ensures reliable real-time updates even with spotty connections. UI Components

1. Borrower Dashboard The borrower experience focuses on simplicity:

RFQ Creation Form: Clean multi-step wizard (amount → duration → collateral → description) Quote Comparison: Side-by-side cards showing rate, limit, collateral, lender reputation One-click acceptance: Accept best quote with single button, handles all blockchain complexity Credit line tracking: Shows utilization, next payment due, total repaid, remaining balance

Particularly Hacky Detail #10: The quote comparison auto-highlights the "best" quote using a scoring algorithm:

50% weight on lowest rate 30% weight on highest limit 20% weight on lender reputation This helps borrowers make quick decisions when many quotes arrive.

1. Lender Dashboard Lenders need more data to make informed decisions:

RFQ Marketplace: Filterable grid with amount, duration, collateral, borrower score Quote Calculator: Input desired rate, see projected returns accounting for risk Portfolio Overview: Total capital deployed, expected returns, active credit lines Aqua Integration Panel: Shows available liquidity, reserved amount, current Aqua yields

1. Auction Live View This is our WOW factor component: Real-time Bid Visualization:

Large countdown timer with pulsing animation Recharts line graph showing rate declining over time Each new bid animates into the chart smoothly Current best bid highlighted with green glow

Live Bid Feed:

New bids slide in from left with Framer Motion Each entry shows: lender avatar, timestamp, rate (large green text), limit Sorted by best rate at top Auto-scrolls to show latest bids

Auction Extensions: When anti-snipe triggers:

Timer turns orange "+5 minutes" badge appears with pulse animation Toast notification explains extension Excitement builds as bidders compete

Particularly Hacky Detail #11: We implemented bid prediction indicators:

If bids are coming rapidly (>3 in 1 minute), show "🔥 Hot Auction" badge If no bids in last 5 minutes, show "💤 Cooling Down" indicator Helps lenders gauge competition intensity

1. Aqua Integration Dashboard Visual representation of capital efficiency:

Three-panel layout: Total → Available → Reserved Color coding: Green for available, orange for reserved Animated transitions: Numbers count up/down smoothly when values change Yield comparison chart: Shows Aqua base yield vs. total blended yield Capital flow diagram: Animated SVG showing money moving between Aqua and credit lines

Deployment and Testing Local Development Stack Our docker-compose.yml spins up the complete environment: yamlservices:

• hardhat: Local blockchain on port 8545
• rabbitmq: Message queue with management UI on 15672
• clickhouse: Database cluster (4 nodes + ZooKeeper + HAProxy)
• redis: Pub/sub for WebSocket broadcasting
• backend: Go API server
• frontend: Vite dev server with HMR One command to rule them all: docker-compose up Within 2-3 minutes, developers have:

Local blockchain with deployed contracts Backend API running and indexed Frontend accessible at localhost:5173 All infrastructure services healthy

Testing Strategy Smart Contract Tests (Hardhat):

Unit tests for every contract function Integration tests for complete flows Gas benchmarking to track optimization Fuzzing with Echidna for edge cases

Backend Tests (Go):

Unit tests with mocked dependencies Integration tests hitting real ClickHouse Load tests with k6 (1000 RPS sustained) WebSocket tests with concurrent clients

Frontend Tests (React Testing Library):

Component unit tests Integration tests with mocked API E2E tests with Playwright

End-to-End Flow Test: Our crown jewel test that validates everything:

Create RFQ via frontend Backend indexes it from blockchain Lender submits quote via API Borrower accepts via frontend Credit line created through 402 Payment streamed and tracked Final settlement releases Aqua liquidity

This test hits every layer of the stack and proves it all works together. Testnet Deployment Contract Deployment:

Sepolia (Ethereum testnet) for primary deployment Mumbai (Polygon testnet) for cross-chain demo Verified on Etherscan for transparency Constructor arguments documented

Backend Deployment:

Docker containers on cloud infrastructure Auto-scaling based on RabbitMQ queue depth Health checks on all endpoints OpenTelemetry exporting to monitoring dashboard

Frontend Deployment:

Built with vite build for production Deployed to Vercel for global CDN Environment variables for contract addresses Automatic preview deployments on PR

What Makes This Hackathon-Worthy Technical Complexity

Full-stack architecture across 3 major layers (contracts, backend, frontend) Real-time systems with WebSocket and event-driven architecture Advanced database choice (ClickHouse over Postgres) for performance Message queuing for reliability and scalability Multi-contract orchestration between Aqua, 402, and custom logic

Particularly Hacky Innovations

Auction anti-snipe with automatic extension - Prevents gaming, ensures fair price discovery WebSocket auto-reconnect with exponential backoff - Reliable real-time even with bad networks ClickHouse optimistic locking - Transaction semantics without transaction support Aqua mock with production interface - Seamless swap to real Aqua when available Event-driven architecture with RabbitMQ - Decouples blockchain from database for throughput Adaptive gas pricing - Transactions succeed even during network congestion Optimistic UI updates - Instant feedback before blockchain confirmation Bid prediction indicators - Shows auction "temperature" to help lenders Liquidity oracle with caching - Real-time yields without hammering RPC Time travel testing - Test 90-day credit lines in seconds Graceful degradation in consumers - Never lose events even under extreme load

Partner Technology Integration 1inch Aqua:

First agent-specific application built on Aqua Demonstrates capital efficiency through shared liquidity Shows how one pool can serve multiple use cases simultaneously Our mock proves integration works, ready for mainnet launch

402 Protocol:

Practical implementation beyond toy examples Real use cases: SaaS financing, marketplace factoring, compute credits Extends 402 with credit discovery layer while maintaining compatibility Shows how programmable payments enable autonomous agent economy

Polygon:

Low gas fees critical for micro-credit lines Fast finality (2-3 second blocks) improves UX for auctions x402 compatibility across EVM chains Production-ready scalability for agent economy

Why This Matters This isn't just a hackathon project - it's infrastructure for the emerging agent economy. As AI agents become economic actors, they need: