clawdentials-mcp 0.1.0 → 0.7.2

package/dist/services/payments/index.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Unified Payment Service
+ *
+ * Provides a single interface for all payment rails:
+ * - USDC via x402 on Base
+ * - USDT via OxaPay on TRC-20 (and other networks)
+ * - BTC via Cashu on Lightning (no KYC, privacy-preserving)
+ */
+import type { Currency, PaymentNetwork, Deposit } from '../../types/index.js';
+export { x402Service } from './x402.js';
+export { oxapayService } from './oxapay.js';
+export { cashuService } from './cashu.js';
+export { breezService } from './breez.js';
+export { oxapayService as coinremitterService } from './oxapay.js';
+export { breezService as albyService } from './breez.js';
+export { breezService as zbdService } from './breez.js';
+export interface CreateDepositRequest {
+    agentId: string;
+    amount: number;
+    currency: 'USDC' | 'USDT' | 'BTC';
+    description?: string;
+}
+export interface CreateDepositResponse {
+    success: boolean;
+    deposit?: Partial<Deposit>;
+    paymentInstructions?: {
+        currency: Currency;
+        network: PaymentNetwork;
+        address?: string;
+        url?: string;
+        amount: number;
+        amountRaw?: string;
+        expiresAt?: Date;
+        qrData?: string;
+    };
+    error?: string;
+}
+export interface SendWithdrawalRequest {
+    currency: 'USDC' | 'USDT' | 'BTC';
+    amount: number;
+    destination: string;
+}
+export interface SendWithdrawalResponse {
+    success: boolean;
+    txId?: string;
+    error?: string;
+}
+/**
+ * Create a deposit request for any supported currency
+ */
+export declare function createDeposit(request: CreateDepositRequest): Promise<CreateDepositResponse>;
+/**
+ * Send a withdrawal in any supported currency
+ */
+export declare function sendWithdrawal(request: SendWithdrawalRequest): Promise<SendWithdrawalResponse>;
+/**
+ * Get configuration status for all payment providers
+ */
+export declare function getPaymentConfig(): {
+    usdc: {
+        configured: boolean;
+        network: string;
+        provider: string;
+    };
+    usdt: {
+        configured: boolean;
+        network: string;
+        provider: string;
+    };
+    btc: {
+        configured: boolean;
+        network: string;
+        provider: string;
+    };
+};
+export declare const paymentService: {
+    createDeposit: typeof createDeposit;
+    sendWithdrawal: typeof sendWithdrawal;
+    getConfig: typeof getPaymentConfig;
+    x402: {
+        createDeposit: typeof import("./x402.js").createX402Deposit;
+        verifyPayment: typeof import("./x402.js").verifyX402Payment;
+        sendWithdrawal: typeof import("./x402.js").sendX402Withdrawal;
+        config: {
+            facilitatorUrl: string;
+            walletAddress: string;
+            network: string;
+        };
+    };
+    oxapay: {
+        createDeposit: typeof import("./oxapay.js").createOxaPayDeposit;
+        getPaymentStatus: typeof import("./oxapay.js").getPaymentStatus;
+        parseWebhookPayload: typeof import("./oxapay.js").parseWebhookPayload;
+        verifyWebhook: typeof import("./oxapay.js").verifyWebhook;
+        sendPayout: typeof import("./oxapay.js").sendOxaPayPayout;
+        getSupportedCurrencies: typeof import("./oxapay.js").getSupportedCurrencies;
+        testConnection: typeof import("./oxapay.js").testConnection;
+        config: {
+            configured: boolean;
+            webhookUrl: string;
+        };
+    };
+    cashu: {
+        config: {
+            readonly configured: boolean;
+            readonly mintUrl: string;
+        };
+        createDeposit: typeof import("./cashu.js").createDeposit;
+        checkDepositAndMint: typeof import("./cashu.js").checkDepositAndMint;
+        payInvoice: typeof import("./cashu.js").payInvoice;
+        sendToken: typeof import("./cashu.js").sendToken;
+        receiveToken: typeof import("./cashu.js").receiveToken;
+        calculateBalance: typeof import("./cashu.js").calculateBalance;
+        checkProofsSpendable: typeof import("./cashu.js").checkProofsSpendable;
+    };
+    breez: {
+        createDeposit: typeof import("./breez.js").createBreezDeposit;
+        sendPayment: typeof import("./breez.js").sendBreezPayment;
+        getWalletBalance: typeof import("./breez.js").getWalletBalance;
+        listPayments: typeof import("./breez.js").listPayments;
+        disconnect: typeof import("./breez.js").disconnect;
+        usdToSats: (usd: number) => number;
+        satsToUsd: (sats: number) => number;
+        config: {
+            configured: boolean;
+            apiKeySet: boolean;
+            mnemonicSet: boolean;
+            network: string;
+            satsPerUsd: number;
+        };
+    };
+};

package/dist/services/payments/index.js

@@ -0,0 +1,180 @@
+/**
+ * Unified Payment Service
+ *
+ * Provides a single interface for all payment rails:
+ * - USDC via x402 on Base
+ * - USDT via OxaPay on TRC-20 (and other networks)
+ * - BTC via Cashu on Lightning (no KYC, privacy-preserving)
+ */
+import { x402Service } from './x402.js';
+import { oxapayService } from './oxapay.js';
+import { cashuService } from './cashu.js';
+import { breezService } from './breez.js';
+export { x402Service } from './x402.js';
+export { oxapayService } from './oxapay.js';
+export { cashuService } from './cashu.js';
+export { breezService } from './breez.js';
+// Legacy exports for backwards compatibility
+export { oxapayService as coinremitterService } from './oxapay.js';
+export { breezService as albyService } from './breez.js';
+export { breezService as zbdService } from './breez.js';
+/**
+ * Create a deposit request for any supported currency
+ */
+export async function createDeposit(request) {
+    switch (request.currency) {
+        case 'USDC': {
+            const result = await x402Service.createDeposit({
+                amount: request.amount,
+                agentId: request.agentId,
+                description: request.description,
+            });
+            if (!result.success) {
+                return { success: false, error: result.error };
+            }
+            return {
+                success: true,
+                deposit: result.deposit,
+                paymentInstructions: {
+                    currency: 'USDC',
+                    network: 'base',
+                    address: result.paymentDetails?.payTo,
+                    amount: request.amount,
+                    amountRaw: result.paymentDetails?.amount,
+                    expiresAt: result.deposit?.expiresAt || undefined,
+                    qrData: result.paymentDetails?.payTo, // EVM address for QR
+                },
+            };
+        }
+        case 'USDT': {
+            const result = await oxapayService.createDeposit({
+                amount: request.amount,
+                agentId: request.agentId,
+                description: request.description,
+            });
+            if (!result.success) {
+                return { success: false, error: result.error };
+            }
+            return {
+                success: true,
+                deposit: result.deposit,
+                paymentInstructions: {
+                    currency: 'USDT',
+                    network: 'trc20',
+                    address: undefined, // OxaPay uses payment URL instead of direct address
+                    url: result.invoice?.paymentUrl,
+                    amount: request.amount,
+                    expiresAt: result.deposit?.expiresAt || undefined,
+                    qrData: result.invoice?.paymentUrl, // QR links to payment page
+                },
+            };
+        }
+        case 'BTC': {
+            // Use Cashu for BTC - no KYC, privacy-preserving ecash
+            const result = await cashuService.createDeposit({
+                amount: request.amount, // Amount in sats
+                agentId: request.agentId,
+                description: request.description,
+            });
+            if (!result.success) {
+                return { success: false, error: result.error };
+            }
+            return {
+                success: true,
+                deposit: {
+                    id: result.quote?.quoteId,
+                    agentId: request.agentId,
+                    amount: request.amount,
+                    currency: 'BTC',
+                    status: 'pending',
+                    provider: 'cashu',
+                    createdAt: new Date(),
+                    expiresAt: result.quote?.expiresAt,
+                },
+                paymentInstructions: {
+                    currency: 'BTC',
+                    network: 'lightning',
+                    address: result.quote?.bolt11, // Lightning invoice
+                    amount: request.amount,
+                    amountRaw: result.quote?.amount?.toString(),
+                    expiresAt: result.quote?.expiresAt,
+                    qrData: result.quote?.bolt11, // Lightning invoice for QR
+                },
+            };
+        }
+        default:
+            return {
+                success: false,
+                error: `Unsupported currency: ${request.currency}. Supported: USDC, USDT, BTC`,
+            };
+    }
+}
+/**
+ * Send a withdrawal in any supported currency
+ */
+export async function sendWithdrawal(request) {
+    switch (request.currency) {
+        case 'USDC': {
+            const result = await x402Service.sendWithdrawal(request.destination, request.amount);
+            return {
+                success: result.success,
+                txId: result.txHash,
+                error: result.error,
+            };
+        }
+        case 'USDT': {
+            const result = await oxapayService.sendPayout(request.destination, request.amount, 'USDT', 'TRC20');
+            return {
+                success: result.success,
+                txId: result.txId,
+                error: result.error,
+            };
+        }
+        case 'BTC': {
+            // BTC withdrawals via Cashu require stored proofs
+            // This is handled at a higher level in the payment tools
+            // where we track agent's ecash proofs in Firestore
+            return {
+                success: false,
+                error: 'BTC withdrawal requires proofs. Use withdraw_crypto tool with stored Cashu proofs.',
+            };
+        }
+        default:
+            return {
+                success: false,
+                error: `Unsupported currency: ${request.currency}. Supported: USDC, USDT, BTC`,
+            };
+    }
+}
+/**
+ * Get configuration status for all payment providers
+ */
+export function getPaymentConfig() {
+    return {
+        usdc: {
+            configured: !!x402Service.config.walletAddress,
+            network: 'Base L2',
+            provider: 'x402 (Coinbase)',
+        },
+        usdt: {
+            configured: oxapayService.config.configured,
+            network: 'Tron TRC-20',
+            provider: 'OxaPay',
+        },
+        btc: {
+            configured: cashuService.config.configured,
+            network: 'Lightning (Cashu)',
+            provider: 'Cashu ecash',
+        },
+    };
+}
+export const paymentService = {
+    createDeposit,
+    sendWithdrawal,
+    getConfig: getPaymentConfig,
+    // Individual services for advanced use
+    x402: x402Service,
+    oxapay: oxapayService,
+    cashu: cashuService,
+    breez: breezService, // Legacy, kept for backwards compatibility
+};

package/dist/services/payments/oxapay.d.ts

@@ -0,0 +1,89 @@
+/**
+ * OxaPay Payment Service - USDT (and other cryptos)
+ *
+ * Uses OxaPay API v1 for USDT deposits and withdrawals.
+ * Docs: https://docs.oxapay.com
+ * Fee: 0.4%
+ */
+import type { Deposit } from '../../types/index.js';
+export interface OxaPayPaymentRequest {
+    amount: number;
+    agentId: string;
+    description?: string;
+    currency?: string;
+}
+export interface OxaPayPaymentResponse {
+    success: boolean;
+    deposit?: Partial<Deposit>;
+    invoice?: {
+        trackId: string;
+        paymentUrl: string;
+        expiredAt: number;
+    };
+    error?: string;
+}
+/**
+ * Create a USDT deposit invoice via OxaPay
+ */
+export declare function createOxaPayDeposit(request: OxaPayPaymentRequest): Promise<OxaPayPaymentResponse>;
+/**
+ * Check payment status
+ */
+export declare function getPaymentStatus(trackId: string): Promise<{
+    success: boolean;
+    status?: string;
+    paid?: boolean;
+    amount?: number;
+    txId?: string;
+    error?: string;
+}>;
+/**
+ * Process webhook callback from OxaPay
+ */
+export declare function parseWebhookPayload(body: Record<string, any>): {
+    trackId: string;
+    status: string;
+    amount: number;
+    orderId: string;
+    txId: string | null;
+};
+/**
+ * Verify webhook signature (OxaPay uses HMAC SHA512)
+ */
+export declare function verifyWebhook(body: string, signature: string): boolean;
+/**
+ * Send USDT payout via OxaPay
+ */
+export declare function sendOxaPayPayout(toAddress: string, amount: number, currency?: string, network?: string): Promise<{
+    success: boolean;
+    txId?: string;
+    error?: string;
+}>;
+/**
+ * Get supported currencies and networks
+ */
+export declare function getSupportedCurrencies(): Promise<{
+    success: boolean;
+    currencies?: any[];
+    error?: string;
+}>;
+/**
+ * Test API connection
+ */
+export declare function testConnection(): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+export declare const oxapayService: {
+    createDeposit: typeof createOxaPayDeposit;
+    getPaymentStatus: typeof getPaymentStatus;
+    parseWebhookPayload: typeof parseWebhookPayload;
+    verifyWebhook: typeof verifyWebhook;
+    sendPayout: typeof sendOxaPayPayout;
+    getSupportedCurrencies: typeof getSupportedCurrencies;
+    testConnection: typeof testConnection;
+    config: {
+        configured: boolean;
+        webhookUrl: string;
+    };
+};

package/dist/services/payments/oxapay.js

@@ -0,0 +1,221 @@
+/**
+ * OxaPay Payment Service - USDT (and other cryptos)
+ *
+ * Uses OxaPay API v1 for USDT deposits and withdrawals.
+ * Docs: https://docs.oxapay.com
+ * Fee: 0.4%
+ */
+// Configuration
+const OXAPAY_API_KEY = process.env.OXAPAY_API_KEY || '';
+const OXAPAY_WEBHOOK_URL = process.env.OXAPAY_WEBHOOK_URL || '';
+// API base URL
+const API_BASE = 'https://api.oxapay.com/v1';
+/**
+ * Make API request to OxaPay v1
+ */
+async function apiRequest(endpoint, data) {
+    if (!OXAPAY_API_KEY) {
+        throw new Error('OXAPAY_API_KEY not configured');
+    }
+    const response = await fetch(`${API_BASE}${endpoint}`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'merchant_api_key': OXAPAY_API_KEY,
+        },
+        body: JSON.stringify(data),
+    });
+    const result = await response.json();
+    if (result.status !== 200) {
+        throw new Error(result.message || `OxaPay API error: ${result.status}`);
+    }
+    return result;
+}
+/**
+ * Create a USDT deposit invoice via OxaPay
+ */
+export async function createOxaPayDeposit(request) {
+    if (!OXAPAY_API_KEY) {
+        return {
+            success: false,
+            error: 'OXAPAY_API_KEY not configured. Set this environment variable.',
+        };
+    }
+    try {
+        const orderId = `clw_${request.agentId}_${Date.now()}`;
+        const result = await apiRequest('/payment/invoice', {
+            amount: request.amount,
+            currency: 'USD',
+            to_currency: request.currency || 'USDT',
+            lifetime: 30, // 30 minutes
+            order_id: orderId,
+            description: request.description || `Deposit for ${request.agentId}`,
+            callback_url: OXAPAY_WEBHOOK_URL || undefined,
+            fee_paid_by_payer: 0, // We pay the fee
+            sandbox: false,
+        });
+        const expiresAt = new Date(result.data.expired_at * 1000);
+        return {
+            success: true,
+            deposit: {
+                id: `oxapay_${result.data.track_id}`,
+                agentId: request.agentId,
+                amount: request.amount,
+                currency: 'USDT',
+                network: 'trc20',
+                status: 'pending',
+                provider: 'oxapay',
+                externalId: result.data.track_id,
+                paymentAddress: null, // OxaPay uses payment URL instead
+                paymentUrl: result.data.payment_url,
+                createdAt: new Date(),
+                expiresAt,
+                completedAt: null,
+                txHash: null,
+            },
+            invoice: {
+                trackId: result.data.track_id,
+                paymentUrl: result.data.payment_url,
+                expiredAt: result.data.expired_at,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to create invoice',
+        };
+    }
+}
+/**
+ * Check payment status
+ */
+export async function getPaymentStatus(trackId) {
+    if (!OXAPAY_API_KEY) {
+        return { success: false, error: 'OXAPAY_API_KEY not configured' };
+    }
+    try {
+        const result = await apiRequest('/payment/inquiry', {
+            track_id: trackId,
+        });
+        // OxaPay statuses: Waiting, Confirming, Paid, Failed, Expired
+        return {
+            success: true,
+            status: result.data.status,
+            paid: result.data.status === 'Paid',
+            amount: parseFloat(result.data.amount || '0'),
+            txId: result.data.txID,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to get payment status',
+        };
+    }
+}
+/**
+ * Process webhook callback from OxaPay
+ */
+export function parseWebhookPayload(body) {
+    return {
+        trackId: body.track_id,
+        status: body.status,
+        amount: parseFloat(body.amount || '0'),
+        orderId: body.order_id, // Contains agentId
+        txId: body.txID || null,
+    };
+}
+/**
+ * Verify webhook signature (OxaPay uses HMAC SHA512)
+ */
+export function verifyWebhook(body, signature) {
+    if (!OXAPAY_API_KEY)
+        return false;
+    const crypto = require('crypto');
+    const hmac = crypto.createHmac('sha512', OXAPAY_API_KEY);
+    hmac.update(body);
+    const calculatedSignature = hmac.digest('hex');
+    return calculatedSignature === signature;
+}
+/**
+ * Send USDT payout via OxaPay
+ */
+export async function sendOxaPayPayout(toAddress, amount, currency = 'USDT', network = 'TRC20') {
+    if (!OXAPAY_API_KEY) {
+        return { success: false, error: 'OXAPAY_API_KEY not configured' };
+    }
+    try {
+        const result = await apiRequest('/payment/payout', {
+            address: toAddress,
+            amount,
+            currency,
+            network,
+            callback_url: OXAPAY_WEBHOOK_URL || undefined,
+            description: 'Clawdentials withdrawal',
+        });
+        return {
+            success: true,
+            txId: result.data.track_id,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to send payout',
+        };
+    }
+}
+/**
+ * Get supported currencies and networks
+ */
+export async function getSupportedCurrencies() {
+    if (!OXAPAY_API_KEY) {
+        return { success: false, error: 'OXAPAY_API_KEY not configured' };
+    }
+    try {
+        const result = await apiRequest('/payment/currencies', {});
+        return {
+            success: true,
+            currencies: result.data,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to get currencies',
+        };
+    }
+}
+/**
+ * Test API connection
+ */
+export async function testConnection() {
+    if (!OXAPAY_API_KEY) {
+        return { success: false, error: 'OXAPAY_API_KEY not configured' };
+    }
+    try {
+        // Try to get currencies as a simple API test
+        await getSupportedCurrencies();
+        return { success: true };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'API connection failed',
+        };
+    }
+}
+export const oxapayService = {
+    createDeposit: createOxaPayDeposit,
+    getPaymentStatus,
+    parseWebhookPayload,
+    verifyWebhook,
+    sendPayout: sendOxaPayPayout,
+    getSupportedCurrencies,
+    testConnection,
+    config: {
+        configured: !!OXAPAY_API_KEY,
+        webhookUrl: OXAPAY_WEBHOOK_URL,
+    },
+};

package/dist/services/payments/x402.d.ts

@@ -0,0 +1,61 @@
+/**
+ * x402 Payment Service - USDC on Base
+ *
+ * Uses Coinbase's x402 protocol for instant stablecoin payments.
+ * Docs: https://docs.cdp.coinbase.com/x402/welcome
+ */
+import type { Deposit } from '../../types/index.js';
+export interface X402PaymentRequest {
+    amount: number;
+    agentId: string;
+    description?: string;
+}
+export interface X402PaymentResponse {
+    success: boolean;
+    deposit?: Partial<Deposit>;
+    paymentDetails?: {
+        payTo: string;
+        amount: string;
+        network: string;
+        facilitatorUrl: string;
+    };
+    error?: string;
+}
+/**
+ * Create a payment request for USDC via x402
+ *
+ * For x402, the flow is different - it's typically used as middleware
+ * where the client pays before accessing a resource. For deposits,
+ * we generate payment details that the agent can use to send USDC.
+ */
+export declare function createX402Deposit(request: X402PaymentRequest): Promise<X402PaymentResponse>;
+/**
+ * Verify a payment was received via x402
+ *
+ * In production, this would check the blockchain or use the x402 facilitator
+ * to verify the payment. For now, we provide a manual verification endpoint.
+ */
+export declare function verifyX402Payment(txHash: string, expectedAmount: number): Promise<{
+    success: boolean;
+    verified: boolean;
+    amount?: number;
+    error?: string;
+}>;
+/**
+ * Send USDC withdrawal via x402/Base
+ */
+export declare function sendX402Withdrawal(toAddress: string, amount: number): Promise<{
+    success: boolean;
+    txHash?: string;
+    error?: string;
+}>;
+export declare const x402Service: {
+    createDeposit: typeof createX402Deposit;
+    verifyPayment: typeof verifyX402Payment;
+    sendWithdrawal: typeof sendX402Withdrawal;
+    config: {
+        facilitatorUrl: string;
+        walletAddress: string;
+        network: string;
+    };
+};