clawdentials-mcp 0.1.0 → 0.7.2

package/dist/tools/payment.js

@@ -0,0 +1,376 @@
+/**
+ * Payment MCP Tools
+ *
+ * Tools for deposits and withdrawals in USDC, USDT, and BTC
+ */
+import { paymentService, getPaymentConfig, oxapayService, } from '../services/payments/index.js';
+import { validateApiKey, getAgent, creditBalance, createWithdrawal, getBalance, } from '../services/firestore.js';
+import { collections, getDb } from '../services/firestore.js';
+import { Timestamp } from 'firebase-admin/firestore';
+// ============ DEPOSIT TOOLS ============
+export const paymentTools = {
+    /**
+     * Create a deposit request (USDC, USDT, or BTC)
+     */
+    deposit_create: {
+        description: 'Create a deposit request to add funds to your Clawdentials balance. Returns payment instructions (address/invoice) for the selected currency. Supported: USDC (Base), USDT (TRC-20), BTC (Lightning).',
+        handler: async (args) => {
+            // Validate API key
+            const isValid = await validateApiKey(args.agentId, args.apiKey);
+            if (!isValid) {
+                return { success: false, error: 'Invalid API key' };
+            }
+            // Validate amount
+            if (args.amount <= 0) {
+                return { success: false, error: 'Amount must be positive' };
+            }
+            // Minimum amounts
+            const minimums = {
+                USDC: 1,
+                USDT: 1,
+                BTC: 0.5, // ~500 sats minimum
+            };
+            if (args.amount < minimums[args.currency]) {
+                return {
+                    success: false,
+                    error: `Minimum deposit for ${args.currency}: $${minimums[args.currency]}`,
+                };
+            }
+            // Create deposit request
+            const result = await paymentService.createDeposit({
+                agentId: args.agentId,
+                amount: args.amount,
+                currency: args.currency,
+                description: `Deposit for agent ${args.agentId}`,
+            });
+            if (!result.success) {
+                return { success: false, error: result.error };
+            }
+            // Store deposit record in Firestore
+            if (result.deposit) {
+                const depositRef = collections.deposits
+                    ? collections.deposits().doc(result.deposit.id)
+                    : getDb().collection('deposits').doc(result.deposit.id);
+                await depositRef.set({
+                    ...result.deposit,
+                    createdAt: Timestamp.fromDate(result.deposit.createdAt),
+                    expiresAt: result.deposit.expiresAt
+                        ? Timestamp.fromDate(result.deposit.expiresAt)
+                        : null,
+                });
+            }
+            return {
+                success: true,
+                depositId: result.deposit?.id,
+                currency: args.currency,
+                amount: args.amount,
+                paymentInstructions: result.paymentInstructions,
+                message: getPaymentMessage(args.currency, result.paymentInstructions),
+            };
+        },
+    },
+    /**
+     * Check deposit status - verifies with payment provider and auto-credits if paid
+     */
+    deposit_status: {
+        description: 'Check the status of a deposit request. If payment is confirmed, balance is automatically credited.',
+        handler: async (args) => {
+            const depositRef = getDb().collection('deposits').doc(args.depositId);
+            const doc = await depositRef.get();
+            if (!doc.exists) {
+                return { success: false, error: 'Deposit not found' };
+            }
+            const data = doc.data();
+            let currentStatus = data.status;
+            let completedAt = data.completedAt;
+            let txHash = data.txHash;
+            let balanceCredited = false;
+            // If deposit is still pending, check with the payment provider
+            if (currentStatus === 'pending' || currentStatus === 'confirming') {
+                const verificationResult = await verifyDepositWithProvider(data);
+                if (verificationResult.paid) {
+                    // Payment confirmed! Update deposit and credit balance
+                    currentStatus = 'completed';
+                    completedAt = Timestamp.fromDate(new Date());
+                    txHash = verificationResult.txId || null;
+                    // Credit the agent's balance
+                    await creditBalance(data.agentId, data.amount, `Deposit ${args.depositId} confirmed`);
+                    balanceCredited = true;
+                    // Update deposit record
+                    await depositRef.update({
+                        status: 'completed',
+                        completedAt,
+                        txHash,
+                    });
+                }
+                else if (verificationResult.status === 'expired' || verificationResult.status === 'failed') {
+                    currentStatus = verificationResult.status;
+                    await depositRef.update({ status: currentStatus });
+                }
+                else if (verificationResult.status === 'confirming') {
+                    currentStatus = 'confirming';
+                    await depositRef.update({ status: 'confirming' });
+                }
+            }
+            const response = {
+                success: true,
+                deposit: {
+                    id: doc.id,
+                    agentId: data.agentId,
+                    amount: data.amount,
+                    currency: data.currency,
+                    network: data.network,
+                    status: currentStatus,
+                    provider: data.provider,
+                    createdAt: data.createdAt?.toDate?.() || data.createdAt,
+                    expiresAt: data.expiresAt?.toDate?.() || data.expiresAt,
+                    completedAt: completedAt?.toDate?.() || completedAt,
+                    txHash,
+                },
+            };
+            if (balanceCredited) {
+                const newBalance = await getBalance(data.agentId);
+                response.message = `Payment confirmed! $${data.amount} credited to your balance.`;
+                response.newBalance = newBalance;
+            }
+            return response;
+        },
+    },
+    /**
+     * Get payment configuration status
+     */
+    payment_config: {
+        description: 'Check which payment methods are configured and available for deposits/withdrawals.',
+        handler: async () => {
+            const config = getPaymentConfig();
+            return {
+                success: true,
+                paymentMethods: config,
+                supported: {
+                    USDC: config.usdc.configured,
+                    USDT: config.usdt.configured,
+                    BTC: config.btc.configured,
+                },
+            };
+        },
+    },
+    /**
+     * Request crypto withdrawal
+     */
+    withdraw_crypto: {
+        description: 'Request a withdrawal in cryptocurrency. Provide your wallet address (USDC/USDT) or Lightning invoice/address (BTC).',
+        handler: async (args) => {
+            // Validate API key
+            const isValid = await validateApiKey(args.agentId, args.apiKey);
+            if (!isValid) {
+                return { success: false, error: 'Invalid API key' };
+            }
+            // Validate amount
+            if (args.amount <= 0) {
+                return { success: false, error: 'Amount must be positive' };
+            }
+            // Check balance
+            const balance = await getBalance(args.agentId);
+            if (balance < args.amount) {
+                return {
+                    success: false,
+                    error: `Insufficient balance: have $${balance}, need $${args.amount}`,
+                };
+            }
+            // Validate destination format
+            const validationError = validateDestination(args.currency, args.destination);
+            if (validationError) {
+                return { success: false, error: validationError };
+            }
+            // Create withdrawal record (this debits balance)
+            const withdrawal = await createWithdrawal(args.agentId, args.amount, args.currency, `${args.currency}: ${args.destination}`);
+            // Attempt automatic withdrawal
+            const sendResult = await paymentService.sendWithdrawal({
+                currency: args.currency,
+                amount: args.amount,
+                destination: args.destination,
+            });
+            if (sendResult.success) {
+                // Update withdrawal status to completed
+                const withdrawalRef = getDb().collection('withdrawals').doc(withdrawal.id);
+                await withdrawalRef.update({
+                    status: 'completed',
+                    processedAt: Timestamp.fromDate(new Date()),
+                    notes: `Auto-processed. TxID: ${sendResult.txId}`,
+                });
+                return {
+                    success: true,
+                    withdrawalId: withdrawal.id,
+                    status: 'completed',
+                    txId: sendResult.txId,
+                    message: `Withdrawal of $${args.amount} ${args.currency} sent successfully.`,
+                };
+            }
+            else {
+                // Withdrawal created but needs manual processing
+                return {
+                    success: true,
+                    withdrawalId: withdrawal.id,
+                    status: 'pending',
+                    message: `Withdrawal request created. ${sendResult.error || 'Will be processed manually.'}`,
+                    newBalance: balance - args.amount,
+                };
+            }
+        },
+    },
+    /**
+     * Set wallet addresses for an agent
+     */
+    agent_set_wallets: {
+        description: 'Set your wallet addresses for receiving withdrawals. You can set addresses for USDC (Base), USDT (TRC-20), and BTC (Lightning Address).',
+        handler: async (args) => {
+            // Validate API key
+            const isValid = await validateApiKey(args.agentId, args.apiKey);
+            if (!isValid) {
+                return { success: false, error: 'Invalid API key' };
+            }
+            const wallets = {};
+            // Validate and set Base address
+            if (args.baseAddress) {
+                if (!/^0x[a-fA-F0-9]{40}$/.test(args.baseAddress)) {
+                    return { success: false, error: 'Invalid Base address format. Expected: 0x...' };
+                }
+                wallets.base = args.baseAddress;
+            }
+            // Validate and set TRC-20 address
+            if (args.trc20Address) {
+                if (!/^T[a-zA-Z0-9]{33}$/.test(args.trc20Address)) {
+                    return { success: false, error: 'Invalid TRC-20 address format. Expected: T...' };
+                }
+                wallets.trc20 = args.trc20Address;
+            }
+            // Validate and set Lightning address
+            if (args.lightningAddress) {
+                if (!args.lightningAddress.includes('@')) {
+                    return {
+                        success: false,
+                        error: 'Invalid Lightning Address format. Expected: user@domain.com',
+                    };
+                }
+                wallets.lightning = args.lightningAddress;
+            }
+            if (Object.keys(wallets).length === 0) {
+                return { success: false, error: 'No wallet addresses provided' };
+            }
+            // Update agent record
+            const agentRef = getDb().collection('agents').doc(args.agentId);
+            const agent = await getAgent(args.agentId);
+            if (!agent) {
+                return { success: false, error: 'Agent not found' };
+            }
+            const existingWallets = agent.wallets || {};
+            const updatedWallets = { ...existingWallets, ...wallets };
+            await agentRef.update({ wallets: updatedWallets });
+            return {
+                success: true,
+                wallets: updatedWallets,
+                message: 'Wallet addresses updated successfully.',
+            };
+        },
+    },
+};
+/**
+ * Generate a human-readable payment message
+ */
+function getPaymentMessage(currency, instructions) {
+    if (!instructions) {
+        return 'Payment instructions unavailable.';
+    }
+    const expiry = instructions.expiresAt
+        ? ` Expires: ${instructions.expiresAt.toISOString()}`
+        : '';
+    switch (currency) {
+        case 'USDC':
+            return `Send ${instructions.amount} USDC to ${instructions.address} on Base network.${expiry}`;
+        case 'USDT':
+            if (instructions.url) {
+                return `Pay ${instructions.amount} USDT at: ${instructions.url}${expiry}`;
+            }
+            return `Send ${instructions.amount} USDT to ${instructions.address} on Tron (TRC-20).${expiry}`;
+        case 'BTC':
+            return `Pay this Lightning invoice: ${instructions.address?.substring(0, 50)}...${expiry}`;
+        default:
+            return `Send ${instructions.amount} ${currency} to ${instructions.address}`;
+    }
+}
+/**
+ * Validate destination address format
+ */
+function validateDestination(currency, destination) {
+    switch (currency) {
+        case 'USDC':
+            if (!/^0x[a-fA-F0-9]{40}$/.test(destination)) {
+                return 'Invalid Base/EVM address. Expected format: 0x...';
+            }
+            break;
+        case 'USDT':
+            if (!/^T[a-zA-Z0-9]{33}$/.test(destination)) {
+                return 'Invalid TRC-20 address. Expected format: T...';
+            }
+            break;
+        case 'BTC':
+            // Accept Lightning invoice (lnbc...) or Lightning Address (user@domain)
+            if (!destination.startsWith('lnbc') && !destination.includes('@')) {
+                return 'Invalid Lightning destination. Provide a Lightning invoice (lnbc...) or Lightning Address (user@domain).';
+            }
+            break;
+    }
+    return null;
+}
+/**
+ * Verify deposit with payment provider
+ */
+async function verifyDepositWithProvider(deposit) {
+    const provider = deposit.provider;
+    const externalId = deposit.externalId;
+    // Check if deposit has expired
+    if (deposit.expiresAt) {
+        const expiresAt = deposit.expiresAt?.toDate?.() || deposit.expiresAt;
+        if (new Date() > expiresAt) {
+            return { paid: false, status: 'expired' };
+        }
+    }
+    switch (provider) {
+        case 'oxapay': {
+            // USDT via OxaPay
+            if (!externalId) {
+                return { paid: false, status: 'pending' };
+            }
+            const result = await oxapayService.getPaymentStatus(externalId);
+            if (!result.success) {
+                return { paid: false, status: 'pending' };
+            }
+            // OxaPay statuses: Waiting, Confirming, Paid, Failed, Expired
+            if (result.paid) {
+                return { paid: true, status: 'completed', txId: result.txId };
+            }
+            else if (result.status === 'Confirming') {
+                return { paid: false, status: 'confirming' };
+            }
+            else if (result.status === 'Failed') {
+                return { paid: false, status: 'failed' };
+            }
+            else if (result.status === 'Expired') {
+                return { paid: false, status: 'expired' };
+            }
+            return { paid: false, status: 'pending' };
+        }
+        case 'x402': {
+            // USDC via x402 - manual verification for now
+            // TODO: Add Base RPC verification when needed
+            return { paid: false, status: 'pending' };
+        }
+        case 'breez': {
+            // BTC via Breez - SDK handles verification internally
+            // For now, return pending (Breez callbacks would update this)
+            return { paid: false, status: 'pending' };
+        }
+        default:
+            return { paid: false, status: 'pending' };
+    }
+}

package/dist/types/index.d.ts

@@ -1,5 +1,22 @@
 export type EscrowStatus = 'pending' | 'in_progress' | 'completed' | 'disputed' | 'cancelled';
-export type Currency = 'USD' | 'USDC' | 'BTC';
+export type Currency = 'USD' | 'USDC' | 'USDT' | 'BTC';
+export type PaymentNetwork = 'base' | 'trc20' | 'lightning';
+export interface Deposit {
+    id: string;
+    agentId: string;
+    amount: number;
+    currency: Currency;
+    network: PaymentNetwork;
+    status: 'pending' | 'confirming' | 'completed' | 'expired' | 'failed';
+    provider: 'x402' | 'oxapay' | 'cashu' | 'breez' | 'alby' | 'coinremitter' | 'zbd';
+    externalId: string | null;
+    paymentAddress: string | null;
+    paymentUrl: string | null;
+    createdAt: Date;
+    expiresAt: Date | null;
+    completedAt: Date | null;
+    txHash: string | null;
+}
 export type SubscriptionTier = 'free' | 'verified' | 'pro';
 export interface Escrow {
     id: string;
@@ -7,11 +24,14 @@ export interface Escrow {
     providerAgentId: string;
     taskDescription: string;
     amount: number;
+    fee: number;
+    feeRate: number;
     currency: Currency;
     status: EscrowStatus;
     createdAt: Date;
     completedAt: Date | null;
     proofOfWork: string | null;
+    disputeReason: string | null;
 }
 export interface Agent {
     id: string;
@@ -22,12 +42,35 @@ export interface Agent {
     verified: boolean;
     subscriptionTier: SubscriptionTier;
     stats: AgentStats;
+    apiKeyHash: string;
+    balance: number;
+    nostrPubkey?: string;
+    nip05?: string;
+    wallets?: {
+        base?: string;
+        trc20?: string;
+        lightning?: string;
+    };
+}
+export type WithdrawalStatus = 'pending' | 'processing' | 'completed' | 'rejected';
+export interface Withdrawal {
+    id: string;
+    agentId: string;
+    amount: number;
+    currency: Currency;
+    status: WithdrawalStatus;
+    paymentMethod: string;
+    requestedAt: Date;
+    processedAt: Date | null;
+    notes: string | null;
 }
 export interface AgentStats {
     tasksCompleted: number;
     totalEarned: number;
     successRate: number;
     avgCompletionTime: number;
+    disputeCount: number;
+    disputeRate: number;
 }
 export interface Task {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawdentials-mcp",
-  "version": "0.1.0",
+  "version": "0.7.2",
   "description": "MCP server for Clawdentials - escrow and reputation for AI agent commerce",
   "type": "module",
   "main": "dist/index.js",
@@ -16,6 +16,8 @@
     "dev": "tsc --watch",
     "start": "node dist/index.js",
     "test": "tsx scripts/test-tools.ts",
+    "e2e": "tsx scripts/e2e-test.ts",
+    "e2e:real": "tsx scripts/e2e-test.ts --real",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build"
   },
@@ -26,7 +28,16 @@
     "escrow",
     "reputation",
     "claude",
-    "anthropic"
+    "anthropic",
+    "crypto",
+    "usdc",
+    "usdt",
+    "bitcoin",
+    "lightning",
+    "cashu",
+    "ecash",
+    "x402",
+    "payments"
   ],
   "author": "Fernando Nikolic",
   "license": "MIT",
@@ -40,9 +51,14 @@
     "url": "https://github.com/fernikolic/clawdentials/issues"
   },
   "dependencies": {
+    "@breeztech/breez-sdk-liquid": "0.11.13",
+    "@cashu/cashu-ts": "2.5.3",
     "@google-cloud/firestore": "8.2.0",
     "@modelcontextprotocol/sdk": "^1.0.0",
+    "@noble/hashes": "2.0.1",
+    "dotenv": "17.2.3",
     "firebase-admin": "^12.0.0",
+    "nostr-tools": "2.22.1",
     "zod": "^3.23.0"
   },
   "devDependencies": {