feat: wire real facilitator + payout service + deposit refund

Replace stubbed x402 facilitator with real HTTPFacilitatorClient.
Wire PayoutService through app deps to sell and treasury routes.
Implement deposit callback with USDC payout and SOL refund on failure.

Author: rz1989s

src/app.test.ts

@@ -3,6 +3,7 @@ import { createApp } from './app.js';
 import { PricingService } from './services/pricing.js';
 import { TransactionDB } from './db/sqlite.js';
 import { X402Service } from './services/x402.js';
+import type { PayoutService } from './services/payout.js';
 
 function makeDeps() {
   const db = new TransactionDB(':memory:');
@@ -30,6 +31,15 @@ function makeX402() {
   });
 }
 
+function makePayoutStub(): PayoutService {
+  return {
+    walletAddress: 'PayoutWa11et1111111111111111111111111111111',
+    getUsdcBalance: async () => 500,
+    canAffordPayout: async () => true,
+    sendUsdc: async () => 'fakePayoutSig123',
+  } as unknown as PayoutService;
+}
+
 describe('DevSOL App', () => {
   it('GET /health returns ok', async () => {
     const { db, pricing } = makeDeps();
@@ -162,4 +172,37 @@ describe('DevSOL App', () => {
 
     db.close();
   });
+
+  it('accepts payout as optional dep and wires to routes', async () => {
+    const { db, pricing } = makeDeps();
+    const treasury = makeTreasuryStub();
+    const x402 = makeX402();
+    const payout = makePayoutStub();
+    const { app } = createApp({
+      pricing,
+      db,
+      treasury: treasury as any,
+      x402,
+      payout,
+    });
+
+    // Sell should work with payout wired
+    const sellRes = await app.request('/sell', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ wallet: 'TestWa11et111XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX', amount_sol: 1 }),
+    });
+    expect(sellRes.status).toBe(200);
+    const sellBody = await sellRes.json();
+    expect(sellBody.status).toBe('pending');
+
+    // Health detail should include payout info
+    const healthRes = await app.request('/health/detail');
+    expect(healthRes.status).toBe(200);
+    const healthBody = await healthRes.json();
+    expect(healthBody.payout_usdc).toBe(500);
+    expect(healthBody.payout_wallet).toBe('PayoutWa11et1111111111111111111111111111111');
+
+    db.close();
+  });
 });

src/app.ts

@@ -9,6 +9,7 @@ import { sellRoutes } from './routes/sell.js';
 import { PricingService } from './services/pricing.js';
 import type { TreasuryService } from './services/treasury.js';
 import type { X402Service } from './services/x402.js';
+import type { PayoutService } from './services/payout.js';
 import { TransactionDB } from './db/sqlite.js';
 import { config } from './config.js';
 
@@ -21,6 +22,7 @@ interface AppDeps {
   treasury?: TreasuryService;
   db?: TransactionDB;
   x402?: X402Service;
+  payout?: PayoutService;
 }
 
 export function createApp(deps?: AppDeps) {
@@ -62,9 +64,9 @@ export function createApp(deps?: AppDeps) {
   app.route('/', txRoutes(db));
 
   if (deps?.treasury && deps?.x402) {
-    app.route('/', treasuryRoutes(deps.treasury));
+    app.route('/', treasuryRoutes(deps.treasury, deps.payout));
     app.route('/', buyRoutes({ db, pricing, treasury: deps.treasury, x402: deps.x402 }));
-    app.route('/', sellRoutes({ db, pricing, treasuryAddress: deps.treasury.address }));
+    app.route('/', sellRoutes({ db, pricing, treasuryAddress: deps.treasury.address, payout: deps.payout }));
   }
 
   return { app, db, pricing };

src/index.ts

@@ -1,47 +1,84 @@
 import { serve } from '@hono/node-server';
 import { readFileSync } from 'fs';
 import { createSolanaRpc } from '@solana/kit';
+import { HTTPFacilitatorClient } from '@x402/core/http';
 import { createApp } from './app.js';
 import { TreasuryService } from './services/treasury.js';
 import { X402Service } from './services/x402.js';
+import { PayoutService } from './services/payout.js';
 import { DepositDetector } from './services/deposit.js';
 import { config } from './config.js';
 
 async function main() {
+  // Devnet treasury (SOL)
   const keypairJson = readFileSync(config.treasuryKeypair, 'utf-8');
   const keypairBytes = new Uint8Array(JSON.parse(keypairJson));
-
   const treasury = await TreasuryService.create({
     rpcUrl: config.devnetRpc,
     wssUrl: config.devnetWss,
     keypairBytes,
   });
 
+  // x402 facilitator (real)
+  const facilitator = new HTTPFacilitatorClient({ url: config.facilitatorUrl });
   const x402 = new X402Service({
-    facilitator: {
-      verify: async () => ({ isValid: true }),
-      settle: async () => ({ success: true, transaction: '', network: config.svmNetwork as `${string}:${string}` }),
-      getSupported: async () => ({ kinds: [], extensions: [], signers: {} }),
-    },
+    facilitator,
     payTo: treasury.address,
     network: config.svmNetwork,
   });
-  console.warn('WARNING: x402 facilitator is STUBBED — wire HTTPFacilitatorClient for production');
 
-  const { app, db } = createApp({ treasury, x402 });
+  // Mainnet payout (USDC) — optional, enables sell flow
+  let payout: PayoutService | undefined;
+  if (config.mainnetKeypair) {
+    const mainnetJson = readFileSync(config.mainnetKeypair, 'utf-8');
+    const mainnetBytes = new Uint8Array(JSON.parse(mainnetJson));
+    payout = await PayoutService.create({
+      rpcUrl: config.mainnetRpc,
+      wssUrl: config.mainnetWss,
+      keypairBytes: mainnetBytes,
+      maxPayoutUsdc: config.maxPayoutUsdc,
+      minReserveUsdc: config.minReserveUsdc,
+    });
+    console.log(`Payout wallet: ${payout.walletAddress}`);
+  } else {
+    console.warn('WARNING: No mainnet keypair configured — sell payouts disabled');
+  }
+
+  const { app, db } = createApp({ treasury, x402, payout });
 
+  // Deposit detector with payout callback
   const devnetRpc = createSolanaRpc(config.devnetRpc);
   const depositDetector = new DepositDetector({
     db,
     rpc: devnetRpc as any,
     treasuryAddress: treasury.address,
-    onDeposit: async (tx, sig) => {
-      console.log(`Deposit confirmed for sell ${tx.id}: ${sig}`);
-      // TODO: trigger USDC payout on mainnet
+    onDeposit: async (tx, devnetSig) => {
+      console.log(`Deposit confirmed for sell ${tx.id}: ${devnetSig}`);
+      if (!payout) {
+        console.warn(`No payout service — sell ${tx.id} completed without USDC payout`);
+        return;
+      }
+      try {
+        const mainnetSig = await payout.sendUsdc(tx.wallet, tx.usdc_amount);
+        db.update(tx.id, { mainnet_payout_tx: mainnetSig });
+        console.log(`USDC payout sent for sell ${tx.id}: ${mainnetSig}`);
+      } catch (err) {
+        console.error(`USDC payout failed for sell ${tx.id}:`, err);
+        // Refund devnet SOL
+        try {
+          const refundSig = await treasury.sendSol(tx.wallet, tx.sol_amount);
+          db.update(tx.id, { status: 'refunded', devnet_tx: refundSig });
+          console.log(`Refunded ${tx.sol_amount} SOL to ${tx.wallet}: ${refundSig}`);
+        } catch (refundErr) {
+          console.error(`CRITICAL: Refund also failed for sell ${tx.id}:`, refundErr);
+          db.update(tx.id, { status: 'failed' });
+        }
+      }
     },
   });
   depositDetector.start();
 
+  // Graceful shutdown
   const shutdown = () => {
     depositDetector.stop();
     db.close();