clodds 1.1.0

package/dist/api/compute/gateway.js

@@ -0,0 +1,958 @@
+"use strict";
+/**
+ * Compute Gateway - Main entry point for agent compute marketplace
+ *
+ * Agents pay USDC for compute resources. No API keys needed - just a wallet.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createComputeGateway = createComputeGateway;
+const crypto_1 = require("crypto");
+const eventemitter3_1 = require("eventemitter3");
+const logger_1 = require("../../utils/logger");
+const persistence_1 = require("./persistence");
+const types_1 = require("./types");
+// =============================================================================
+// CONSTANTS
+// =============================================================================
+const DEFAULT_CONFIG = {
+    minBalance: 0.001,
+    jobTimeout: 300000,
+    maxConcurrent: 10,
+    maxRetries: 3,
+    retryDelayMs: 1000,
+    retryBackoffMultiplier: 2,
+    circuitBreakerThreshold: 5,
+    circuitBreakerResetMs: 30000,
+    usdcAddress: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC on Base
+    treasuryWallet: process.env.CLODDS_TREASURY_WALLET || '',
+    walletRateLimit: 60, // 60 requests per minute
+    ipRateLimit: 100, // 100 requests per minute
+    dbPath: '',
+    supportedNetworks: ['base', 'ethereum', 'polygon'],
+};
+// Transient errors that should trigger retry
+const RETRYABLE_ERRORS = [
+    'ECONNRESET',
+    'ETIMEDOUT',
+    'ECONNREFUSED',
+    'ENOTFOUND',
+    'EAI_AGAIN',
+    'socket hang up',
+    'network error',
+    'rate limit',
+    '429',
+    '502',
+    '503',
+    '504',
+];
+// RPC endpoints for payment verification
+const RPC_ENDPOINTS = {
+    base: 'https://mainnet.base.org',
+    ethereum: 'https://eth.llamarpc.com',
+    polygon: 'https://polygon-rpc.com',
+};
+// USDC addresses per network
+const USDC_ADDRESSES = {
+    base: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+    ethereum: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+    polygon: '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174',
+};
+// ERC20 Transfer event signature
+const TRANSFER_EVENT_SIG = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef';
+// =============================================================================
+// IMPLEMENTATION
+// =============================================================================
+function createComputeGateway(config = {}, pricing) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    const events = new eventemitter3_1.EventEmitter();
+    const startTime = Date.now();
+    // Initialize persistence
+    const db = (0, persistence_1.createPersistenceLayer)(cfg.dbPath || undefined);
+    // Service handlers
+    const handlers = new Map();
+    // In-memory job tracking for active jobs
+    const activeJobs = new Map();
+    const circuitBreakers = new Map();
+    // Recent errors tracking (keep last 100)
+    const recentErrors = [];
+    const MAX_RECENT_ERRORS = 100;
+    function recordError(service, error) {
+        recentErrors.push({ service, error, timestamp: Date.now() });
+        if (recentErrors.length > MAX_RECENT_ERRORS) {
+            recentErrors.shift();
+        }
+    }
+    function getCircuitBreaker(service) {
+        if (!circuitBreakers.has(service)) {
+            circuitBreakers.set(service, {
+                state: 'closed',
+                failures: 0,
+                lastFailure: 0,
+                lastSuccess: Date.now(),
+            });
+        }
+        return circuitBreakers.get(service);
+    }
+    function checkCircuitBreaker(service) {
+        const cb = getCircuitBreaker(service);
+        if (cb.state === 'closed') {
+            return { allowed: true };
+        }
+        if (cb.state === 'open') {
+            // Check if reset timeout has passed
+            if (Date.now() - cb.lastFailure > cfg.circuitBreakerResetMs) {
+                cb.state = 'half-open';
+                logger_1.logger.info({ service }, 'Circuit breaker entering half-open state');
+                return { allowed: true };
+            }
+            return {
+                allowed: false,
+                reason: `Service ${service} is temporarily unavailable (circuit breaker open). Retry after ${Math.ceil((cfg.circuitBreakerResetMs - (Date.now() - cb.lastFailure)) / 1000)}s`,
+            };
+        }
+        // half-open - allow one request through
+        return { allowed: true };
+    }
+    function recordCircuitSuccess(service) {
+        const cb = getCircuitBreaker(service);
+        cb.failures = 0;
+        cb.lastSuccess = Date.now();
+        if (cb.state === 'half-open') {
+            cb.state = 'closed';
+            logger_1.logger.info({ service }, 'Circuit breaker closed after successful request');
+        }
+    }
+    function recordCircuitFailure(service) {
+        const cb = getCircuitBreaker(service);
+        cb.failures++;
+        cb.lastFailure = Date.now();
+        if (cb.state === 'half-open') {
+            cb.state = 'open';
+            logger_1.logger.warn({ service, failures: cb.failures }, 'Circuit breaker re-opened after failure in half-open state');
+        }
+        else if (cb.failures >= cfg.circuitBreakerThreshold) {
+            cb.state = 'open';
+            logger_1.logger.warn({ service, failures: cb.failures, threshold: cfg.circuitBreakerThreshold }, 'Circuit breaker opened');
+        }
+    }
+    // Metrics
+    let totalRequests = 0;
+    let totalRevenue = 0;
+    const requestsByService = {};
+    const jobsByStatus = { pending: 0, processing: 0, completed: 0, failed: 0 };
+    function generateJobId() {
+        return `job_${Date.now()}_${(0, crypto_1.randomBytes)(8).toString('hex')}`;
+    }
+    function registerHandler(service, handler) {
+        handlers.set(service, handler);
+        logger_1.logger.info({ service }, 'Service handler registered');
+    }
+    function isRetryableError(error) {
+        const errorStr = String(error).toLowerCase();
+        return RETRYABLE_ERRORS.some(e => errorStr.includes(e.toLowerCase()));
+    }
+    async function withRetry(fn, context) {
+        let lastError;
+        let delay = cfg.retryDelayMs;
+        for (let attempt = 0; attempt <= cfg.maxRetries; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < cfg.maxRetries && isRetryableError(error)) {
+                    logger_1.logger.warn({
+                        jobId: context.jobId,
+                        service: context.service,
+                        attempt: attempt + 1,
+                        maxRetries: cfg.maxRetries,
+                        error: String(error),
+                        nextRetryMs: delay,
+                    }, 'Retrying after transient error');
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                    delay *= cfg.retryBackoffMultiplier;
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        throw lastError;
+    }
+    function getOrCreateBalance(wallet) {
+        const row = db.getBalance(wallet);
+        if (row) {
+            return {
+                wallet: row.wallet,
+                available: row.available,
+                pending: row.pending,
+                totalDeposited: row.total_deposited,
+                totalSpent: row.total_spent,
+            };
+        }
+        return {
+            wallet: wallet.toLowerCase(),
+            available: 0,
+            pending: 0,
+            totalDeposited: 0,
+            totalSpent: 0,
+        };
+    }
+    function saveBalance(balance) {
+        db.upsertBalance(balance.wallet, balance.available, balance.pending, balance.totalDeposited, balance.totalSpent);
+    }
+    function calculateUnits(service, payload) {
+        let units = 1;
+        if (service === 'llm') {
+            const messages = payload?.messages || [];
+            const totalChars = messages.reduce((sum, m) => sum + (m.content?.length || 0), 0);
+            units = Math.ceil(totalChars / 4);
+        }
+        else if (service === 'code') {
+            const timeout = payload?.timeout || 30000;
+            units = Math.ceil(timeout / 1000);
+        }
+        else if (service === 'storage') {
+            const content = payload?.content || '';
+            units = Math.max(1, Math.ceil(content.length / 1024 / 1024));
+        }
+        else if (service === 'data') {
+            units = 1;
+        }
+        else if (service === 'web') {
+            units = 1;
+        }
+        else if (service === 'trade') {
+            units = 1;
+        }
+        return units;
+    }
+    function estimateCostInternal(service, payload, priority = 'normal') {
+        const price = pricing[service];
+        if (!price)
+            return 0;
+        const units = calculateUnits(service, payload);
+        const baseCost = price.basePrice + (units * price.pricePerUnit);
+        const clampedCost = Math.min(Math.max(baseCost, price.minCharge), price.maxCharge);
+        // Apply priority multiplier
+        const priorityMultiplier = types_1.PRIORITY_MULTIPLIERS[priority];
+        return clampedCost * priorityMultiplier;
+    }
+    function estimateCost(service, payload) {
+        const price = pricing[service];
+        // Extract priority from payload if present
+        const priority = payload?.priority || 'normal';
+        const priorityMultiplier = types_1.PRIORITY_MULTIPLIERS[priority] || 1.0;
+        if (!price) {
+            return {
+                service,
+                estimatedCost: 0,
+                breakdown: { base: 0, usage: 0, total: 0, priorityMultiplier },
+                units: 0,
+                unitType: 'unknown',
+                minCharge: 0,
+                maxCharge: 0,
+                priority,
+            };
+        }
+        const units = calculateUnits(service, payload);
+        const baseCost = price.basePrice;
+        const usageCost = units * price.pricePerUnit;
+        const subtotal = Math.min(Math.max(baseCost + usageCost, price.minCharge), price.maxCharge);
+        const total = subtotal * priorityMultiplier;
+        return {
+            service,
+            estimatedCost: total,
+            breakdown: {
+                base: baseCost,
+                usage: usageCost,
+                subtotal,
+                priorityMultiplier,
+                total,
+            },
+            units,
+            unitType: price.unit,
+            minCharge: price.minCharge * priorityMultiplier,
+            maxCharge: price.maxCharge * priorityMultiplier,
+            priority,
+        };
+    }
+    async function verifyPayment(proof) {
+        if (!proof.txHash || !proof.network) {
+            return { valid: false, amount: 0, error: 'Missing txHash or network' };
+        }
+        // Check supported network
+        if (!cfg.supportedNetworks.includes(proof.network)) {
+            return { valid: false, amount: 0, error: `Unsupported network: ${proof.network}` };
+        }
+        // Check for replay attack
+        if (db.isTransactionUsed(proof.txHash)) {
+            return { valid: false, amount: 0, error: 'Transaction already used' };
+        }
+        const rpcUrl = RPC_ENDPOINTS[proof.network];
+        const usdcAddress = USDC_ADDRESSES[proof.network];
+        if (!rpcUrl || !usdcAddress) {
+            return { valid: false, amount: 0, error: `Network ${proof.network} not configured` };
+        }
+        try {
+            // Get transaction receipt
+            const response = await fetch(rpcUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    jsonrpc: '2.0',
+                    method: 'eth_getTransactionReceipt',
+                    params: [proof.txHash],
+                    id: 1,
+                }),
+            });
+            const data = await response.json();
+            if (!data.result) {
+                return { valid: false, amount: 0, error: 'Transaction not found' };
+            }
+            // Check success status
+            if (data.result.status !== '0x1') {
+                return { valid: false, amount: 0, error: 'Transaction failed' };
+            }
+            // Find USDC Transfer event to our treasury
+            const treasury = cfg.treasuryWallet.toLowerCase();
+            let transferAmount = 0;
+            for (const log of data.result.logs) {
+                // Check if it's USDC contract
+                if (log.address.toLowerCase() !== usdcAddress.toLowerCase())
+                    continue;
+                // Check if it's Transfer event
+                if (log.topics[0] !== TRANSFER_EVENT_SIG)
+                    continue;
+                // topics[2] is the 'to' address (padded to 32 bytes)
+                const toAddress = '0x' + log.topics[2].slice(26).toLowerCase();
+                if (toAddress === treasury) {
+                    // Decode amount from data (USDC has 6 decimals)
+                    const amountHex = log.data;
+                    const amountRaw = BigInt(amountHex);
+                    transferAmount = Number(amountRaw) / 1e6;
+                    break;
+                }
+            }
+            if (transferAmount === 0) {
+                return { valid: false, amount: 0, error: 'No transfer to treasury found' };
+            }
+            // Verify amount matches (with 1% tolerance for gas)
+            if (Math.abs(transferAmount - proof.amountUsd) / proof.amountUsd > 0.01) {
+                return { valid: false, amount: transferAmount, error: `Amount mismatch: expected ${proof.amountUsd}, got ${transferAmount}` };
+            }
+            return { valid: true, amount: transferAmount };
+        }
+        catch (error) {
+            logger_1.logger.error({ error, txHash: proof.txHash }, 'Payment verification failed');
+            return { valid: false, amount: 0, error: 'Verification failed' };
+        }
+    }
+    function checkRateLimit(wallet, ip) {
+        const windowMs = 60000; // 1 minute
+        const walletCount = db.getRequestCount(wallet, windowMs);
+        if (walletCount >= cfg.walletRateLimit) {
+            return {
+                allowed: false,
+                retryAfter: 60,
+                remaining: 0,
+            };
+        }
+        const ipCount = db.getIpRequestCount(ip, windowMs);
+        if (ipCount >= cfg.ipRateLimit) {
+            return {
+                allowed: false,
+                retryAfter: 60,
+                remaining: 0,
+            };
+        }
+        db.recordRequest(wallet, ip);
+        return {
+            allowed: true,
+            remaining: Math.min(cfg.walletRateLimit - walletCount - 1, cfg.ipRateLimit - ipCount - 1),
+        };
+    }
+    async function submit(request) {
+        const jobId = generateJobId();
+        const startTime = Date.now();
+        totalRequests++;
+        requestsByService[request.service] = (requestsByService[request.service] || 0) + 1;
+        try {
+            // Validate service
+            if (!pricing[request.service]) {
+                return {
+                    id: request.id,
+                    jobId,
+                    service: request.service,
+                    status: 'failed',
+                    error: `Unknown service: ${request.service}`,
+                    cost: 0,
+                    timestamp: startTime,
+                };
+            }
+            // Check handler exists
+            if (!handlers.has(request.service)) {
+                return {
+                    id: request.id,
+                    jobId,
+                    service: request.service,
+                    status: 'failed',
+                    error: `Service ${request.service} not available`,
+                    cost: 0,
+                    timestamp: startTime,
+                };
+            }
+            // Check circuit breaker
+            const cbCheck = checkCircuitBreaker(request.service);
+            if (!cbCheck.allowed) {
+                return {
+                    id: request.id,
+                    jobId,
+                    service: request.service,
+                    status: 'failed',
+                    error: cbCheck.reason || 'Service temporarily unavailable',
+                    cost: 0,
+                    timestamp: startTime,
+                };
+            }
+            // Check balance (with priority pricing)
+            const balance = getOrCreateBalance(request.wallet);
+            const priority = request.priority || 'normal';
+            const estimatedCost = estimateCostInternal(request.service, request.payload, priority);
+            if (balance.available < estimatedCost) {
+                // Check for payment proof
+                if (request.paymentProof) {
+                    const verification = await verifyPayment(request.paymentProof);
+                    if (verification.valid) {
+                        // Mark transaction as used
+                        db.markTransactionUsed(request.paymentProof.txHash, request.wallet, verification.amount);
+                        balance.available += verification.amount;
+                        balance.totalDeposited += verification.amount;
+                        saveBalance(balance);
+                    }
+                    else {
+                        return {
+                            id: request.id,
+                            jobId,
+                            service: request.service,
+                            status: 'failed',
+                            error: verification.error || 'Invalid payment proof',
+                            cost: 0,
+                            timestamp: startTime,
+                        };
+                    }
+                }
+                // Re-check after payment
+                if (balance.available < estimatedCost) {
+                    return {
+                        id: request.id,
+                        jobId,
+                        service: request.service,
+                        status: 'failed',
+                        error: `Insufficient balance. Need $${estimatedCost.toFixed(4)}, have $${balance.available.toFixed(4)}`,
+                        cost: 0,
+                        timestamp: startTime,
+                    };
+                }
+            }
+            // Check spending limits
+            const spendingCheck = checkSpendingLimits(request.wallet, estimatedCost);
+            if (!spendingCheck.allowed) {
+                return {
+                    id: request.id,
+                    jobId,
+                    service: request.service,
+                    status: 'failed',
+                    error: spendingCheck.reason || 'Spending limit exceeded',
+                    cost: 0,
+                    timestamp: startTime,
+                };
+            }
+            // Reserve balance
+            balance.available -= estimatedCost;
+            balance.pending += estimatedCost;
+            saveBalance(balance);
+            // Create job in database
+            db.createJob({
+                job_id: jobId,
+                request_id: request.id,
+                wallet: request.wallet,
+                service: request.service,
+                status: 'pending',
+                payload: JSON.stringify(request.payload),
+                result: null,
+                error: null,
+                cost: estimatedCost,
+                usage: null,
+                created_at: startTime,
+                started_at: null,
+                completed_at: null,
+            });
+            jobsByStatus.pending++;
+            logger_1.logger.info({
+                jobId,
+                service: request.service,
+                wallet: request.wallet,
+                estimatedCost,
+            }, 'Compute job created');
+            // Execute async
+            executeJob(jobId, request, estimatedCost).catch(error => {
+                logger_1.logger.error({ error, jobId }, 'Job execution failed');
+            });
+            return {
+                id: request.id,
+                jobId,
+                service: request.service,
+                status: 'pending',
+                cost: estimatedCost,
+                timestamp: startTime,
+            };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            return {
+                id: request.id,
+                jobId,
+                service: request.service,
+                status: 'failed',
+                error: errorMsg,
+                cost: 0,
+                timestamp: startTime,
+            };
+        }
+    }
+    async function executeJob(jobId, request, estimatedCost) {
+        const startedAt = Date.now();
+        // Update status to processing
+        db.updateJob(jobId, { status: 'processing', started_at: startedAt });
+        jobsByStatus.pending--;
+        jobsByStatus.processing++;
+        activeJobs.set(jobId, { wallet: request.wallet, startedAt });
+        events.emit('job:started', { jobId, wallet: request.wallet, service: request.service });
+        try {
+            const handler = handlers.get(request.service);
+            if (!handler) {
+                throw new Error(`No handler for service: ${request.service}`);
+            }
+            // Execute with timeout and retry
+            const result = await withRetry(() => Promise.race([
+                handler(request),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Job timeout')), cfg.jobTimeout)),
+            ]), { jobId, service: request.service });
+            const completedAt = Date.now();
+            const durationMs = completedAt - startedAt;
+            // Calculate actual usage
+            const usage = calculateUsage(request.service, durationMs, request.payload);
+            // Update balance
+            const balance = getOrCreateBalance(request.wallet);
+            const actualCost = usage.breakdown.total;
+            const refund = estimatedCost - actualCost;
+            balance.pending -= estimatedCost;
+            balance.available += refund;
+            balance.totalSpent += actualCost;
+            saveBalance(balance);
+            // Update job
+            db.updateJob(jobId, {
+                status: 'completed',
+                result: JSON.stringify(result),
+                cost: actualCost,
+                usage: JSON.stringify(usage),
+                completed_at: completedAt,
+            });
+            // Record usage stats
+            db.recordUsage(request.wallet, request.service, actualCost, durationMs);
+            jobsByStatus.processing--;
+            jobsByStatus.completed++;
+            totalRevenue += actualCost;
+            activeJobs.delete(jobId);
+            events.emit('job:completed', { jobId, wallet: request.wallet, service: request.service, cost: actualCost });
+            // Send callback if configured
+            if (request.callbackUrl) {
+                sendCallback(request.callbackUrl, {
+                    id: request.id,
+                    jobId,
+                    service: request.service,
+                    status: 'completed',
+                    result,
+                    cost: actualCost,
+                    usage,
+                    timestamp: completedAt,
+                }).catch(err => {
+                    logger_1.logger.error({ err, jobId }, 'Callback failed');
+                });
+            }
+            logger_1.logger.info({
+                jobId,
+                service: request.service,
+                cost: actualCost,
+                durationMs,
+            }, 'Job completed');
+            // Record success for circuit breaker
+            recordCircuitSuccess(request.service);
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const completedAt = Date.now();
+            // Track error for admin metrics
+            recordError(request.service, errorMsg);
+            // Refund on failure
+            const balance = getOrCreateBalance(request.wallet);
+            balance.pending -= estimatedCost;
+            balance.available += estimatedCost;
+            saveBalance(balance);
+            db.updateJob(jobId, {
+                status: 'failed',
+                error: errorMsg,
+                cost: 0,
+                completed_at: completedAt,
+            });
+            jobsByStatus.processing--;
+            jobsByStatus.failed++;
+            activeJobs.delete(jobId);
+            events.emit('job:failed', { jobId, wallet: request.wallet, error: errorMsg });
+            // Record failure for circuit breaker (only for non-user errors)
+            if (isRetryableError(error)) {
+                recordCircuitFailure(request.service);
+            }
+            logger_1.logger.error({ jobId, error: errorMsg }, 'Job failed');
+        }
+    }
+    function calculateUsage(service, durationMs, payload) {
+        const price = pricing[service];
+        let units;
+        switch (service) {
+            case 'llm': {
+                // Would get actual tokens from result, estimate for now
+                const messages = payload?.messages || [];
+                const totalChars = messages.reduce((sum, m) => sum + (m.content?.length || 0), 0);
+                units = Math.ceil(totalChars / 4);
+                break;
+            }
+            case 'code':
+                units = Math.ceil(durationMs / 1000);
+                break;
+            case 'storage': {
+                const content = payload?.content || '';
+                units = Math.max(1, Math.ceil(content.length / 1024 / 1024));
+                break;
+            }
+            default:
+                units = 1;
+        }
+        const baseCost = price.basePrice;
+        const usageCost = units * price.pricePerUnit;
+        const total = Math.min(Math.max(baseCost + usageCost, price.minCharge), price.maxCharge);
+        return {
+            units,
+            unitType: price.unit,
+            durationMs,
+            breakdown: {
+                base: baseCost,
+                usage: usageCost,
+                total,
+            },
+        };
+    }
+    async function sendCallback(url, data) {
+        const secret = process.env.CLODDS_WEBHOOK_SECRET || 'default-secret';
+        const signature = (0, crypto_1.createHmac)('sha256', secret)
+            .update(JSON.stringify(data))
+            .digest('hex');
+        await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Clodds-Signature': signature,
+                'X-Clodds-Timestamp': Date.now().toString(),
+            },
+            body: JSON.stringify(data),
+        });
+    }
+    async function getJob(jobId, wallet) {
+        const row = db.getJob(jobId);
+        if (!row)
+            return null;
+        // Verify ownership if wallet provided
+        if (wallet && row.wallet.toLowerCase() !== wallet.toLowerCase()) {
+            return null; // Don't reveal job exists to non-owner
+        }
+        return {
+            id: row.request_id,
+            jobId: row.job_id,
+            service: row.service,
+            status: row.status,
+            result: row.result ? JSON.parse(row.result) : undefined,
+            error: row.error || undefined,
+            cost: row.cost,
+            usage: row.usage ? JSON.parse(row.usage) : undefined,
+            timestamp: row.completed_at || row.started_at || row.created_at,
+        };
+    }
+    async function getJobsByWallet(wallet, limit = 50) {
+        const rows = db.getJobsByWallet(wallet, limit);
+        return rows.map(row => ({
+            id: row.request_id,
+            jobId: row.job_id,
+            service: row.service,
+            status: row.status,
+            result: row.result ? JSON.parse(row.result) : undefined,
+            error: row.error || undefined,
+            cost: row.cost,
+            usage: row.usage ? JSON.parse(row.usage) : undefined,
+            timestamp: row.completed_at || row.started_at || row.created_at,
+        }));
+    }
+    async function cancelJob(jobId, wallet) {
+        const row = db.getJob(jobId);
+        if (!row)
+            return false;
+        // Verify ownership
+        if (row.wallet.toLowerCase() !== wallet.toLowerCase()) {
+            return false;
+        }
+        // Can only cancel pending jobs
+        if (row.status !== 'pending') {
+            return false;
+        }
+        // Refund
+        const balance = getOrCreateBalance(wallet);
+        balance.pending -= row.cost;
+        balance.available += row.cost;
+        saveBalance(balance);
+        db.updateJob(jobId, {
+            status: 'failed',
+            error: 'Cancelled by user',
+            cost: 0,
+            completed_at: Date.now(),
+        });
+        jobsByStatus.pending--;
+        jobsByStatus.failed++;
+        events.emit('job:cancelled', { jobId, wallet });
+        return true;
+    }
+    function getPricing(service) {
+        return pricing[service];
+    }
+    async function getBalance(wallet) {
+        return getOrCreateBalance(wallet);
+    }
+    async function depositCredits(wallet, proof) {
+        const verification = await verifyPayment(proof);
+        if (!verification.valid) {
+            return {
+                success: false,
+                credits: 0,
+                txHash: proof.txHash,
+                error: verification.error,
+            };
+        }
+        // Mark as used
+        db.markTransactionUsed(proof.txHash, wallet, verification.amount);
+        // Update balance
+        const balance = getOrCreateBalance(wallet);
+        balance.available += verification.amount;
+        balance.totalDeposited += verification.amount;
+        saveBalance(balance);
+        logger_1.logger.info({
+            wallet,
+            amount: verification.amount,
+            txHash: proof.txHash,
+        }, 'Credits deposited');
+        return {
+            success: true,
+            credits: verification.amount,
+            txHash: proof.txHash,
+        };
+    }
+    async function getUsage(wallet, period = 'all') {
+        const rows = db.getUsage(wallet, period);
+        const byService = {};
+        let totalCost = 0;
+        let totalRequests = 0;
+        for (const row of rows) {
+            byService[row.service] = {
+                requests: row.requests,
+                cost: row.total_cost,
+                avgDuration: row.total_duration_ms / row.requests,
+            };
+            totalCost += row.total_cost;
+            totalRequests += row.requests;
+        }
+        return {
+            wallet,
+            period,
+            byService,
+            totalCost,
+            totalRequests,
+        };
+    }
+    function getMetrics() {
+        return {
+            uptime: Date.now() - startTime,
+            totalRequests,
+            totalRevenue,
+            activeJobs: activeJobs.size,
+            jobsByStatus: { ...jobsByStatus },
+            requestsByService: { ...requestsByService },
+        };
+    }
+    function getAdminMetrics() {
+        const base = getMetrics();
+        // Build circuit breaker status for all services
+        const cbStatus = {};
+        for (const service of Object.keys(pricing)) {
+            const cb = circuitBreakers.get(service);
+            if (cb) {
+                cbStatus[service] = {
+                    state: cb.state,
+                    failures: cb.failures,
+                    lastFailure: cb.lastFailure || null,
+                    cooldownUntil: cb.state === 'open' && cb.lastFailure
+                        ? cb.lastFailure + cfg.circuitBreakerResetMs
+                        : null,
+                };
+            }
+            else {
+                cbStatus[service] = {
+                    state: 'closed',
+                    failures: 0,
+                    lastFailure: null,
+                    cooldownUntil: null,
+                };
+            }
+        }
+        // Get system info
+        const memUsage = process.memoryUsage();
+        return {
+            ...base,
+            circuitBreakers: cbStatus,
+            recentErrors: [...recentErrors].reverse().slice(0, 50), // Most recent first
+            systemInfo: {
+                nodeVersion: process.version,
+                platform: process.platform,
+                memoryUsageMB: Math.round(memUsage.heapUsed / 1024 / 1024),
+                cpuUsagePercent: 0, // Would need async measurement
+            },
+        };
+    }
+    function shutdown() {
+        db.close();
+    }
+    async function getSpendingLimits(wallet) {
+        const limits = db.getSpendingLimits(wallet);
+        const dailySpent = db.getSpentInPeriod(wallet, 86400000); // 24 hours
+        const monthlySpent = db.getSpentInPeriod(wallet, 2592000000); // 30 days
+        return {
+            wallet: wallet.toLowerCase(),
+            dailyLimit: limits?.daily_limit ?? null,
+            monthlyLimit: limits?.monthly_limit ?? null,
+            dailySpent,
+            monthlySpent,
+            dailyRemaining: limits?.daily_limit != null ? Math.max(0, limits.daily_limit - dailySpent) : null,
+            monthlyRemaining: limits?.monthly_limit != null ? Math.max(0, limits.monthly_limit - monthlySpent) : null,
+        };
+    }
+    async function setSpendingLimits(wallet, limits) {
+        const current = db.getSpendingLimits(wallet);
+        db.setSpendingLimits(wallet, limits.dailyLimit !== undefined ? limits.dailyLimit : (current?.daily_limit ?? null), limits.monthlyLimit !== undefined ? limits.monthlyLimit : (current?.monthly_limit ?? null));
+        logger_1.logger.info({ wallet, limits }, 'Spending limits updated');
+    }
+    function checkSpendingLimits(wallet, amount) {
+        const limits = db.getSpendingLimits(wallet);
+        if (!limits) {
+            return { allowed: true };
+        }
+        const dailySpent = db.getSpentInPeriod(wallet, 86400000);
+        const monthlySpent = db.getSpentInPeriod(wallet, 2592000000);
+        if (limits.daily_limit != null && dailySpent + amount > limits.daily_limit) {
+            return {
+                allowed: false,
+                reason: `Daily spending limit exceeded. Limit: $${limits.daily_limit}, spent: $${dailySpent.toFixed(4)}, requested: $${amount.toFixed(4)}`,
+                dailyLimit: limits.daily_limit,
+                dailySpent,
+            };
+        }
+        if (limits.monthly_limit != null && monthlySpent + amount > limits.monthly_limit) {
+            return {
+                allowed: false,
+                reason: `Monthly spending limit exceeded. Limit: $${limits.monthly_limit}, spent: $${monthlySpent.toFixed(4)}, requested: $${amount.toFixed(4)}`,
+                monthlyLimit: limits.monthly_limit,
+                monthlySpent,
+            };
+        }
+        return {
+            allowed: true,
+            dailyLimit: limits.daily_limit ?? undefined,
+            dailySpent,
+            monthlyLimit: limits.monthly_limit ?? undefined,
+            monthlySpent,
+        };
+    }
+    // Cleanup old jobs periodically (keep 7 days)
+    setInterval(() => {
+        const cleaned = db.cleanupOldJobs(7 * 24 * 60 * 60 * 1000);
+        if (cleaned > 0) {
+            logger_1.logger.info({ count: cleaned }, 'Cleaned up old jobs');
+        }
+    }, 3600000); // Every hour
+    // ==========================================================================
+    // API KEY MANAGEMENT
+    // ==========================================================================
+    async function createApiKey(wallet, name) {
+        const apiKey = `clodds_${(0, crypto_1.randomBytes)(24).toString('hex')}`;
+        db.createApiKey(apiKey, wallet, name);
+        logger_1.logger.info({ wallet, name }, 'API key created');
+        return { apiKey, wallet: wallet.toLowerCase(), name };
+    }
+    function getApiKeyWallet(apiKey) {
+        const row = db.getApiKey(apiKey);
+        return row?.wallet || null;
+    }
+    function listApiKeys(wallet) {
+        const rows = db.getApiKeysByWallet(wallet);
+        return rows.map(row => ({
+            apiKey: row.api_key.slice(0, 12) + '...' + row.api_key.slice(-4), // Masked
+            name: row.name,
+            createdAt: row.created_at,
+            lastUsedAt: row.last_used_at,
+            revoked: row.revoked_at != null,
+        }));
+    }
+    function revokeApiKey(wallet, apiKey) {
+        // Verify the key belongs to this wallet
+        const row = db.getApiKey(apiKey);
+        if (!row || row.wallet.toLowerCase() !== wallet.toLowerCase()) {
+            return false;
+        }
+        const success = db.revokeApiKey(apiKey);
+        if (success) {
+            logger_1.logger.info({ wallet, apiKey: apiKey.slice(0, 12) }, 'API key revoked');
+        }
+        return success;
+    }
+    return {
+        submit,
+        getJob,
+        getJobsByWallet,
+        cancelJob,
+        getPricing,
+        estimateCost,
+        getBalance,
+        depositCredits,
+        getUsage,
+        getSpendingLimits,
+        setSpendingLimits,
+        checkSpendingLimits,
+        registerHandler,
+        checkRateLimit,
+        getMetrics,
+        getAdminMetrics,
+        events,
+        createApiKey,
+        getApiKeyWallet,
+        listApiKeys,
+        revokeApiKey,
+        shutdown,
+    };
+}
+//# sourceMappingURL=gateway.js.map