clawdentials-mcp 0.1.0 → 0.7.2

package/dist/services/payments/x402.js

@@ -0,0 +1,94 @@
+/**
+ * x402 Payment Service - USDC on Base
+ *
+ * Uses Coinbase's x402 protocol for instant stablecoin payments.
+ * Docs: https://docs.cdp.coinbase.com/x402/welcome
+ */
+// Configuration
+const X402_FACILITATOR_URL = process.env.X402_FACILITATOR_URL || 'https://x402.org/facilitator';
+const X402_WALLET_ADDRESS = process.env.X402_WALLET_ADDRESS || '0x7BAC327BF264BF530D002907b375B8C9E04b0212'; // Clawdentials Base wallet
+const X402_NETWORK = process.env.X402_NETWORK || 'eip155:8453'; // Base mainnet (84532 for testnet)
+/**
+ * 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 async function createX402Deposit(request) {
+    if (!X402_WALLET_ADDRESS) {
+        return {
+            success: false,
+            error: 'X402_WALLET_ADDRESS not configured. Set this environment variable to your Base wallet address.',
+        };
+    }
+    // x402 uses a simple payment scheme - we provide the details
+    // and the agent sends USDC directly using their wallet
+    const amountInWei = BigInt(Math.floor(request.amount * 1e6)).toString(); // USDC has 6 decimals
+    const depositId = `x402_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+    const expiresAt = new Date(Date.now() + 30 * 60 * 1000); // 30 minutes
+    return {
+        success: true,
+        deposit: {
+            id: depositId,
+            agentId: request.agentId,
+            amount: request.amount,
+            currency: 'USDC',
+            network: 'base',
+            status: 'pending',
+            provider: 'x402',
+            externalId: depositId,
+            paymentAddress: X402_WALLET_ADDRESS,
+            paymentUrl: null, // Direct transfer, no hosted page
+            createdAt: new Date(),
+            expiresAt,
+            completedAt: null,
+            txHash: null,
+        },
+        paymentDetails: {
+            payTo: X402_WALLET_ADDRESS,
+            amount: amountInWei,
+            network: X402_NETWORK,
+            facilitatorUrl: X402_FACILITATOR_URL,
+        },
+    };
+}
+/**
+ * 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 async function verifyX402Payment(txHash, expectedAmount) {
+    // TODO: Implement actual blockchain verification
+    // Options:
+    // 1. Use Coinbase's x402 facilitator verification
+    // 2. Use Base RPC to check transaction
+    // 3. Use a service like Alchemy or Infura
+    return {
+        success: true,
+        verified: false,
+        error: 'Automatic verification not yet implemented. Use admin tools to manually credit balance after confirming transaction.',
+    };
+}
+/**
+ * Send USDC withdrawal via x402/Base
+ */
+export async function sendX402Withdrawal(toAddress, amount) {
+    // TODO: Implement actual USDC transfer
+    // This requires a wallet private key or integration with a custodial service
+    return {
+        success: false,
+        error: 'Automated USDC withdrawals not yet implemented. Process manually and update withdrawal status.',
+    };
+}
+export const x402Service = {
+    createDeposit: createX402Deposit,
+    verifyPayment: verifyX402Payment,
+    sendWithdrawal: sendX402Withdrawal,
+    config: {
+        facilitatorUrl: X402_FACILITATOR_URL,
+        walletAddress: X402_WALLET_ADDRESS,
+        network: X402_NETWORK,
+    },
+};

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

@@ -0,0 +1,88 @@
+/**
+ * ZBD Payment Service - Bitcoin on Lightning
+ *
+ * Uses ZBD API for instant Bitcoin Lightning payments.
+ * Docs: https://zbd.dev
+ * Fee: ~1%
+ */
+import type { Deposit } from '../../types/index.js';
+export interface ZBDPaymentRequest {
+    amount: number;
+    agentId: string;
+    description?: string;
+}
+export interface ZBDPaymentResponse {
+    success: boolean;
+    deposit?: Partial<Deposit>;
+    invoice?: {
+        id: string;
+        invoice: string;
+        amount: string;
+        expiresAt: string;
+    };
+    error?: string;
+}
+/**
+ * Convert USD to millisats
+ */
+declare function usdToMillisats(usd: number): string;
+/**
+ * Convert millisats to USD
+ */
+declare function millisatsToUsd(millisats: string | number): number;
+/**
+ * Create a Lightning invoice for BTC deposit
+ */
+export declare function createZBDDeposit(request: ZBDPaymentRequest): Promise<ZBDPaymentResponse>;
+/**
+ * Check charge/invoice status
+ */
+export declare function getChargeStatus(chargeId: string): Promise<{
+    success: boolean;
+    status?: string;
+    paid?: boolean;
+    amountUsd?: number;
+    error?: string;
+}>;
+/**
+ * Process webhook callback from ZBD
+ */
+export declare function parseWebhookPayload(body: Record<string, any>): {
+    chargeId: string;
+    status: string;
+    amountUsd: number;
+    agentId: string;
+};
+/**
+ * Send BTC withdrawal via Lightning
+ */
+export declare function sendZBDWithdrawal(destination: string, // Lightning invoice or Lightning Address
+amountUsd: number): Promise<{
+    success: boolean;
+    paymentId?: string;
+    error?: string;
+}>;
+/**
+ * Get ZBD wallet balance
+ */
+export declare function getWalletBalance(): Promise<{
+    success: boolean;
+    balanceSats?: number;
+    balanceUsd?: number;
+    error?: string;
+}>;
+export declare const zbdService: {
+    createDeposit: typeof createZBDDeposit;
+    getChargeStatus: typeof getChargeStatus;
+    parseWebhookPayload: typeof parseWebhookPayload;
+    sendWithdrawal: typeof sendZBDWithdrawal;
+    getWalletBalance: typeof getWalletBalance;
+    usdToMillisats: typeof usdToMillisats;
+    millisatsToUsd: typeof millisatsToUsd;
+    config: {
+        configured: boolean;
+        callbackUrl: string;
+        satsPerUsd: number;
+    };
+};
+export {};

package/dist/services/payments/zbd.js

@@ -0,0 +1,221 @@
+/**
+ * ZBD Payment Service - Bitcoin on Lightning
+ *
+ * Uses ZBD API for instant Bitcoin Lightning payments.
+ * Docs: https://zbd.dev
+ * Fee: ~1%
+ */
+// Configuration
+const ZBD_API_KEY = process.env.ZBD_API_KEY || '';
+const ZBD_CALLBACK_URL = process.env.ZBD_CALLBACK_URL || '';
+// API base URL
+const API_BASE = 'https://api.zebedee.io/v0';
+// Current BTC/USD rate (in production, fetch from an API)
+// 1 sat = 0.00000001 BTC
+// At ~$100k/BTC: 1 sat ≈ $0.001, so $1 ≈ 1000 sats
+const SATS_PER_USD = parseInt(process.env.ZBD_SATS_PER_USD || '1000', 10);
+/**
+ * Make API request to ZBD
+ */
+async function apiRequest(endpoint, method = 'POST', data) {
+    if (!ZBD_API_KEY) {
+        throw new Error('ZBD_API_KEY not configured');
+    }
+    const response = await fetch(`${API_BASE}${endpoint}`, {
+        method,
+        headers: {
+            'Content-Type': 'application/json',
+            apikey: ZBD_API_KEY,
+        },
+        body: data ? JSON.stringify(data) : undefined,
+    });
+    const result = await response.json();
+    if (!result.success) {
+        throw new Error(result.message || 'ZBD API error');
+    }
+    return result.data;
+}
+/**
+ * Convert USD to millisats
+ */
+function usdToMillisats(usd) {
+    const sats = Math.floor(usd * SATS_PER_USD);
+    const millisats = sats * 1000;
+    return millisats.toString();
+}
+/**
+ * Convert millisats to USD
+ */
+function millisatsToUsd(millisats) {
+    const sats = typeof millisats === 'string' ? parseInt(millisats, 10) / 1000 : millisats / 1000;
+    return sats / SATS_PER_USD;
+}
+/**
+ * Create a Lightning invoice for BTC deposit
+ */
+export async function createZBDDeposit(request) {
+    if (!ZBD_API_KEY) {
+        return {
+            success: false,
+            error: 'ZBD_API_KEY not configured. Set this environment variable to your ZBD API key.',
+        };
+    }
+    try {
+        const amountMillisats = usdToMillisats(request.amount);
+        const chargeData = await apiRequest('/charges', 'POST', {
+            amount: amountMillisats,
+            description: request.description || `Clawdentials deposit for ${request.agentId}`,
+            expiresIn: 600, // 10 minutes (Lightning invoices expire fast)
+            internalId: request.agentId,
+            callbackUrl: ZBD_CALLBACK_URL,
+        });
+        const expiresAt = new Date(chargeData.expiresAt);
+        return {
+            success: true,
+            deposit: {
+                id: `zbd_${chargeData.id}`,
+                agentId: request.agentId,
+                amount: request.amount,
+                currency: 'BTC',
+                network: 'lightning',
+                status: 'pending',
+                provider: 'zbd',
+                externalId: chargeData.id,
+                paymentAddress: chargeData.invoice.request, // bolt11 invoice
+                paymentUrl: null, // No hosted page, agent pays invoice directly
+                createdAt: new Date(),
+                expiresAt,
+                completedAt: null,
+                txHash: null,
+            },
+            invoice: {
+                id: chargeData.id,
+                invoice: chargeData.invoice.request,
+                amount: amountMillisats,
+                expiresAt: chargeData.expiresAt,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to create Lightning invoice',
+        };
+    }
+}
+/**
+ * Check charge/invoice status
+ */
+export async function getChargeStatus(chargeId) {
+    if (!ZBD_API_KEY) {
+        return { success: false, error: 'ZBD_API_KEY not configured' };
+    }
+    try {
+        const data = await apiRequest(`/charges/${chargeId}`, 'GET');
+        return {
+            success: true,
+            status: data.status,
+            paid: data.status === 'completed',
+            amountUsd: millisatsToUsd(data.amount),
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to get charge status',
+        };
+    }
+}
+/**
+ * Process webhook callback from ZBD
+ */
+export function parseWebhookPayload(body) {
+    return {
+        chargeId: body.id,
+        status: body.status,
+        amountUsd: millisatsToUsd(body.amount),
+        agentId: body.internalId,
+    };
+}
+/**
+ * Send BTC withdrawal via Lightning
+ */
+export async function sendZBDWithdrawal(destination, // Lightning invoice or Lightning Address
+amountUsd) {
+    if (!ZBD_API_KEY) {
+        return { success: false, error: 'ZBD_API_KEY not configured' };
+    }
+    try {
+        const amountMillisats = usdToMillisats(amountUsd);
+        // Check if it's a Lightning Address (contains @)
+        if (destination.includes('@')) {
+            // Pay to Lightning Address
+            const data = await apiRequest('/ln-address/send-payment', 'POST', {
+                lnAddress: destination,
+                amount: amountMillisats,
+                comment: 'Clawdentials withdrawal',
+                callbackUrl: ZBD_CALLBACK_URL,
+            });
+            return {
+                success: true,
+                paymentId: data.id,
+            };
+        }
+        else {
+            // Pay to bolt11 invoice
+            const data = await apiRequest('/payments', 'POST', {
+                invoice: destination,
+                description: 'Clawdentials withdrawal',
+                internalId: `withdrawal_${Date.now()}`,
+                callbackUrl: ZBD_CALLBACK_URL,
+            });
+            return {
+                success: true,
+                paymentId: data.id,
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to send payment',
+        };
+    }
+}
+/**
+ * Get ZBD wallet balance
+ */
+export async function getWalletBalance() {
+    if (!ZBD_API_KEY) {
+        return { success: false, error: 'ZBD_API_KEY not configured' };
+    }
+    try {
+        const data = await apiRequest('/wallet', 'GET');
+        const balanceSats = parseInt(data.balance, 10) / 1000; // millisats to sats
+        return {
+            success: true,
+            balanceSats,
+            balanceUsd: balanceSats / SATS_PER_USD,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to get balance',
+        };
+    }
+}
+export const zbdService = {
+    createDeposit: createZBDDeposit,
+    getChargeStatus,
+    parseWebhookPayload,
+    sendWithdrawal: sendZBDWithdrawal,
+    getWalletBalance,
+    usdToMillisats,
+    millisatsToUsd,
+    config: {
+        configured: !!ZBD_API_KEY,
+        callbackUrl: ZBD_CALLBACK_URL,
+        satsPerUsd: SATS_PER_USD,
+    },
+};

package/dist/tools/admin.d.ts

@@ -0,0 +1,195 @@
+import { type AdminCreditBalanceInput, type AdminProcessWithdrawalInput, type AdminListWithdrawalsInput } from '../schemas/index.js';
+import { z } from 'zod';
+declare const adminRefundSchema: z.ZodObject<{
+    adminSecret: z.ZodString;
+    escrowId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    escrowId: string;
+    adminSecret: string;
+}, {
+    escrowId: string;
+    adminSecret: string;
+}>;
+type AdminRefundInput = z.infer<typeof adminRefundSchema>;
+export declare const adminTools: {
+    admin_credit_balance: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            adminSecret: z.ZodString;
+            agentId: z.ZodString;
+            amount: z.ZodNumber;
+            currency: z.ZodDefault<z.ZodEnum<["USD", "USDC", "BTC"]>>;
+            notes: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            amount: number;
+            currency: "USD" | "USDC" | "BTC";
+            agentId: string;
+            adminSecret: string;
+            notes?: string | undefined;
+        }, {
+            amount: number;
+            agentId: string;
+            adminSecret: string;
+            currency?: "USD" | "USDC" | "BTC" | undefined;
+            notes?: string | undefined;
+        }>;
+        handler: (input: AdminCreditBalanceInput) => Promise<{
+            success: boolean;
+            error: string;
+            message?: undefined;
+            agentId?: undefined;
+            oldBalance?: undefined;
+            credited?: undefined;
+            newBalance?: undefined;
+            currency?: undefined;
+            notes?: undefined;
+        } | {
+            success: boolean;
+            message: string;
+            agentId: string;
+            oldBalance: number;
+            credited: number;
+            newBalance: number;
+            currency: "USD" | "USDC" | "BTC";
+            notes: string | undefined;
+            error?: undefined;
+        }>;
+    };
+    admin_list_withdrawals: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            adminSecret: z.ZodString;
+            status: z.ZodOptional<z.ZodEnum<["pending", "processing", "completed", "rejected"]>>;
+            limit: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            limit: number;
+            adminSecret: string;
+            status?: "pending" | "processing" | "completed" | "rejected" | undefined;
+        }, {
+            adminSecret: string;
+            status?: "pending" | "processing" | "completed" | "rejected" | undefined;
+            limit?: number | undefined;
+        }>;
+        handler: (input: AdminListWithdrawalsInput) => Promise<{
+            success: boolean;
+            error: string;
+            withdrawals?: undefined;
+            count?: undefined;
+        } | {
+            success: boolean;
+            withdrawals: {
+                id: string;
+                agentId: string;
+                amount: number;
+                currency: import("../types/index.js").Currency;
+                status: import("../types/index.js").WithdrawalStatus;
+                paymentMethod: string;
+                requestedAt: string;
+                processedAt: string | null;
+                notes: string | null;
+            }[];
+            count: number;
+            error?: undefined;
+        }>;
+    };
+    admin_process_withdrawal: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            adminSecret: z.ZodString;
+            withdrawalId: z.ZodString;
+            action: z.ZodEnum<["complete", "reject"]>;
+            notes: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            adminSecret: string;
+            withdrawalId: string;
+            action: "complete" | "reject";
+            notes?: string | undefined;
+        }, {
+            adminSecret: string;
+            withdrawalId: string;
+            action: "complete" | "reject";
+            notes?: string | undefined;
+        }>;
+        handler: (input: AdminProcessWithdrawalInput) => Promise<{
+            success: boolean;
+            error: string;
+            message?: undefined;
+            withdrawal?: undefined;
+        } | {
+            success: boolean;
+            message: string;
+            withdrawal: {
+                id: string;
+                agentId: string;
+                amount: number;
+                currency: import("../types/index.js").Currency;
+                status: import("../types/index.js").WithdrawalStatus;
+                paymentMethod: string;
+                processedAt: string | undefined;
+                notes: string | null;
+            };
+            error?: undefined;
+        }>;
+    };
+    admin_refund_escrow: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            adminSecret: z.ZodString;
+            escrowId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            escrowId: string;
+            adminSecret: string;
+        }, {
+            escrowId: string;
+            adminSecret: string;
+        }>;
+        handler: (input: AdminRefundInput) => Promise<{
+            success: boolean;
+            error: string;
+            message?: undefined;
+            escrow?: undefined;
+            clientNewBalance?: undefined;
+        } | {
+            success: boolean;
+            message: string;
+            escrow: {
+                id: string;
+                status: import("../types/index.js").EscrowStatus;
+                amount: number;
+                currency: import("../types/index.js").Currency;
+            };
+            clientNewBalance: number;
+            error?: undefined;
+        }>;
+    };
+    admin_nostr_json: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            adminSecret: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            adminSecret: string;
+        }, {
+            adminSecret: string;
+        }>;
+        handler: (input: {
+            adminSecret: string;
+        }) => Promise<{
+            success: boolean;
+            error: string;
+            message?: undefined;
+            agentCount?: undefined;
+            nostrJson?: undefined;
+            nostrJsonString?: undefined;
+        } | {
+            success: boolean;
+            message: string;
+            agentCount: number;
+            nostrJson: {
+                names: Record<string, string>;
+            };
+            nostrJsonString: string;
+            error?: undefined;
+        }>;
+    };
+};
+export {};