clawdentials-mcp 0.1.0 → 0.7.2

package/dist/tools/escrow.d.ts

@@ -1,50 +1,67 @@
-import { z } from 'zod';
-import { type EscrowCreateInput, type EscrowCompleteInput, type EscrowStatusInput } from '../schemas/index.js';
+import { type EscrowCreateInput, type EscrowCompleteInput, type EscrowStatusInput, type EscrowDisputeInput } from '../schemas/index.js';
 export declare const escrowTools: {
     escrow_create: {
         description: string;
-        inputSchema: z.ZodObject<{
-            taskDescription: z.ZodString;
-            amount: z.ZodNumber;
-            currency: z.ZodDefault<z.ZodEnum<["USD", "USDC", "BTC"]>>;
-            providerAgentId: z.ZodString;
-            clientAgentId: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
+        inputSchema: import("zod").ZodObject<{
+            taskDescription: import("zod").ZodString;
+            amount: import("zod").ZodNumber;
+            currency: import("zod").ZodDefault<import("zod").ZodEnum<["USD", "USDC", "BTC"]>>;
+            providerAgentId: import("zod").ZodString;
+            clientAgentId: import("zod").ZodString;
+            apiKey: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
             taskDescription: string;
             amount: number;
             currency: "USD" | "USDC" | "BTC";
             providerAgentId: string;
             clientAgentId: string;
+            apiKey: string;
         }, {
             taskDescription: string;
             amount: number;
             providerAgentId: string;
             clientAgentId: string;
+            apiKey: string;
             currency?: "USD" | "USDC" | "BTC" | undefined;
         }>;
         handler: (input: EscrowCreateInput) => Promise<{
+            success: boolean;
+            error: string;
+            escrowId?: undefined;
+            message?: undefined;
+            escrow?: undefined;
+            newBalance?: undefined;
+        } | {
             success: boolean;
             escrowId: string;
             message: string;
             escrow: {
                 id: string;
                 amount: number;
+                fee: number;
+                feeRate: number;
+                netAmount: number;
                 currency: import("../types/index.js").Currency;
                 status: import("../types/index.js").EscrowStatus;
                 providerAgentId: string;
                 createdAt: string;
             };
+            newBalance: number;
+            error?: undefined;
         }>;
     };
     escrow_complete: {
         description: string;
-        inputSchema: z.ZodObject<{
-            escrowId: z.ZodString;
-            proofOfWork: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
+        inputSchema: import("zod").ZodObject<{
+            escrowId: import("zod").ZodString;
+            proofOfWork: import("zod").ZodString;
+            apiKey: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            apiKey: string;
             escrowId: string;
             proofOfWork: string;
         }, {
+            apiKey: string;
             escrowId: string;
             proofOfWork: string;
         }>;
@@ -53,25 +70,29 @@ export declare const escrowTools: {
             error: string;
             message?: undefined;
             escrow?: undefined;
+            newBalance?: undefined;
         } | {
             success: boolean;
             message: string;
             escrow: {
                 id: string;
                 amount: number;
+                fee: number;
+                netAmount: number;
                 currency: import("../types/index.js").Currency;
                 status: import("../types/index.js").EscrowStatus;
                 completedAt: string | undefined;
                 proofOfWork: string | null;
             };
+            newBalance: number;
             error?: undefined;
         }>;
     };
     escrow_status: {
         description: string;
-        inputSchema: z.ZodObject<{
-            escrowId: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
+        inputSchema: import("zod").ZodObject<{
+            escrowId: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
             escrowId: string;
         }, {
             escrowId: string;
@@ -88,11 +109,48 @@ export declare const escrowTools: {
                 providerAgentId: string;
                 taskDescription: string;
                 amount: number;
+                fee: number;
+                feeRate: number;
+                netAmount: number;
                 currency: import("../types/index.js").Currency;
                 status: import("../types/index.js").EscrowStatus;
                 createdAt: string;
                 completedAt: string | null;
                 proofOfWork: string | null;
+                disputeReason: string | null;
+            };
+            error?: undefined;
+        }>;
+    };
+    escrow_dispute: {
+        description: string;
+        inputSchema: import("zod").ZodObject<{
+            escrowId: import("zod").ZodString;
+            reason: import("zod").ZodString;
+            apiKey: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            apiKey: string;
+            escrowId: string;
+            reason: string;
+        }, {
+            apiKey: string;
+            escrowId: string;
+            reason: string;
+        }>;
+        handler: (input: EscrowDisputeInput) => Promise<{
+            success: boolean;
+            error: string;
+            message?: undefined;
+            escrow?: undefined;
+        } | {
+            success: boolean;
+            message: string;
+            escrow: {
+                id: string;
+                status: import("../types/index.js").EscrowStatus;
+                disputeReason: string | null;
+                amount: number;
+                currency: import("../types/index.js").Currency;
             };
             error?: undefined;
         }>;

package/dist/tools/escrow.js

@@ -1,35 +1,64 @@
-import { escrowCreateSchema, escrowCompleteSchema, escrowStatusSchema, } from '../schemas/index.js';
-import { createEscrow, getEscrow, completeEscrow } from '../services/firestore.js';
+import { escrowCreateSchema, escrowCompleteSchema, escrowStatusSchema, escrowDisputeSchema, } from '../schemas/index.js';
+import { getEscrow, disputeEscrow, FEE_RATE, validateApiKey, createEscrowWithBalance, completeEscrowWithBalance, getBalance, } from '../services/firestore.js';
 export const escrowTools = {
     escrow_create: {
-        description: 'Create a new escrow to lock funds for a task. The funds will be held until the task is completed.',
+        description: 'Create a new escrow to lock funds for a task. Requires API key and sufficient balance.',
         inputSchema: escrowCreateSchema,
         handler: async (input) => {
-            const escrow = await createEscrow({
-                clientAgentId: input.clientAgentId,
-                providerAgentId: input.providerAgentId,
-                taskDescription: input.taskDescription,
-                amount: input.amount,
-                currency: input.currency,
-                status: 'pending',
-            });
-            return {
-                success: true,
-                escrowId: escrow.id,
-                message: `Escrow created successfully. ${input.amount} ${input.currency} locked for task: "${input.taskDescription}"`,
-                escrow: {
-                    id: escrow.id,
-                    amount: escrow.amount,
-                    currency: escrow.currency,
-                    status: escrow.status,
-                    providerAgentId: escrow.providerAgentId,
-                    createdAt: escrow.createdAt.toISOString(),
-                },
-            };
+            // Validate API key
+            const isValid = await validateApiKey(input.clientAgentId, input.apiKey);
+            if (!isValid) {
+                return {
+                    success: false,
+                    error: 'Invalid API key for client agent',
+                };
+            }
+            // Check balance first
+            const balance = await getBalance(input.clientAgentId);
+            if (balance < input.amount) {
+                return {
+                    success: false,
+                    error: `Insufficient balance: have ${balance} ${input.currency}, need ${input.amount} ${input.currency}. Add funds first.`,
+                };
+            }
+            try {
+                const escrow = await createEscrowWithBalance({
+                    clientAgentId: input.clientAgentId,
+                    providerAgentId: input.providerAgentId,
+                    taskDescription: input.taskDescription,
+                    amount: input.amount,
+                    currency: input.currency,
+                    status: 'pending',
+                });
+                const netAmount = escrow.amount - escrow.fee;
+                return {
+                    success: true,
+                    escrowId: escrow.id,
+                    message: `Escrow created. ${input.amount} ${input.currency} deducted from your balance. Provider receives ${netAmount} ${input.currency} on completion (${FEE_RATE * 100}% fee).`,
+                    escrow: {
+                        id: escrow.id,
+                        amount: escrow.amount,
+                        fee: escrow.fee,
+                        feeRate: escrow.feeRate,
+                        netAmount,
+                        currency: escrow.currency,
+                        status: escrow.status,
+                        providerAgentId: escrow.providerAgentId,
+                        createdAt: escrow.createdAt.toISOString(),
+                    },
+                    newBalance: balance - input.amount,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Failed to create escrow',
+                };
+            }
         },
     },
     escrow_complete: {
-        description: 'Mark an escrow as complete and release the funds to the provider agent. Requires proof of work.',
+        description: 'Mark an escrow as complete and release funds to provider. Only the provider can complete.',
         inputSchema: escrowCompleteSchema,
         handler: async (input) => {
             const existingEscrow = await getEscrow(input.escrowId);
@@ -39,6 +68,14 @@ export const escrowTools = {
                     error: `Escrow not found: ${input.escrowId}`,
                 };
             }
+            // Validate API key - must be the provider
+            const isValid = await validateApiKey(existingEscrow.providerAgentId, input.apiKey);
+            if (!isValid) {
+                return {
+                    success: false,
+                    error: 'Invalid API key. Only the provider agent can complete this escrow.',
+                };
+            }
             if (existingEscrow.status === 'completed') {
                 return {
                     success: false,
@@ -51,23 +88,34 @@ export const escrowTools = {
                     error: 'Escrow was cancelled',
                 };
             }
-            const escrow = await completeEscrow(input.escrowId, input.proofOfWork);
+            if (existingEscrow.status === 'disputed') {
+                return {
+                    success: false,
+                    error: 'Escrow is disputed. Contact admin for resolution.',
+                };
+            }
+            const escrow = await completeEscrowWithBalance(input.escrowId, input.proofOfWork);
+            const netAmount = escrow.amount - escrow.fee;
+            const newBalance = await getBalance(escrow.providerAgentId);
             return {
                 success: true,
-                message: `Escrow completed. ${escrow.amount} ${escrow.currency} released to ${escrow.providerAgentId}`,
+                message: `Escrow completed! ${netAmount} ${escrow.currency} credited to your balance.`,
                 escrow: {
                     id: escrow.id,
                     amount: escrow.amount,
+                    fee: escrow.fee,
+                    netAmount,
                     currency: escrow.currency,
                     status: escrow.status,
                     completedAt: escrow.completedAt?.toISOString(),
                     proofOfWork: escrow.proofOfWork,
                 },
+                newBalance,
             };
         },
     },
     escrow_status: {
-        description: 'Check the current status of an escrow.',
+        description: 'Check the current status of an escrow. Public - no auth required.',
         inputSchema: escrowStatusSchema,
         handler: async (input) => {
             const escrow = await getEscrow(input.escrowId);
@@ -85,13 +133,76 @@ export const escrowTools = {
                     providerAgentId: escrow.providerAgentId,
                     taskDescription: escrow.taskDescription,
                     amount: escrow.amount,
+                    fee: escrow.fee,
+                    feeRate: escrow.feeRate,
+                    netAmount: escrow.amount - escrow.fee,
                     currency: escrow.currency,
                     status: escrow.status,
                     createdAt: escrow.createdAt.toISOString(),
                     completedAt: escrow.completedAt?.toISOString() ?? null,
                     proofOfWork: escrow.proofOfWork,
+                    disputeReason: escrow.disputeReason,
                 },
             };
         },
     },
+    escrow_dispute: {
+        description: 'Flag an escrow for dispute. Only the client can dispute.',
+        inputSchema: escrowDisputeSchema,
+        handler: async (input) => {
+            const existingEscrow = await getEscrow(input.escrowId);
+            if (!existingEscrow) {
+                return {
+                    success: false,
+                    error: `Escrow not found: ${input.escrowId}`,
+                };
+            }
+            // Validate API key - must be the client
+            const isValid = await validateApiKey(existingEscrow.clientAgentId, input.apiKey);
+            if (!isValid) {
+                return {
+                    success: false,
+                    error: 'Invalid API key. Only the client agent can dispute this escrow.',
+                };
+            }
+            if (existingEscrow.status === 'completed') {
+                return {
+                    success: false,
+                    error: 'Cannot dispute a completed escrow',
+                };
+            }
+            if (existingEscrow.status === 'cancelled') {
+                return {
+                    success: false,
+                    error: 'Cannot dispute a cancelled escrow',
+                };
+            }
+            if (existingEscrow.status === 'disputed') {
+                return {
+                    success: false,
+                    error: 'Escrow is already disputed',
+                };
+            }
+            try {
+                const escrow = await disputeEscrow(input.escrowId, input.reason);
+                return {
+                    success: true,
+                    message: `Escrow disputed. Funds are held pending admin review. Reason: "${input.reason}"`,
+                    escrow: {
+                        id: escrow.id,
+                        status: escrow.status,
+                        disputeReason: escrow.disputeReason,
+                        amount: escrow.amount,
+                        currency: escrow.currency,
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Failed to dispute escrow',
+                };
+            }
+        },
+    },
 };

package/dist/tools/index.d.ts

@@ -1 +1,4 @@
 export { escrowTools } from './escrow.js';
+export { agentTools } from './agent.js';
+export { adminTools } from './admin.js';
+export { paymentTools } from './payment.js';

package/dist/tools/index.js

@@ -1 +1,4 @@
 export { escrowTools } from './escrow.js';
+export { agentTools } from './agent.js';
+export { adminTools } from './admin.js';
+export { paymentTools } from './payment.js';

package/dist/tools/payment.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Payment MCP Tools
+ *
+ * Tools for deposits and withdrawals in USDC, USDT, and BTC
+ */
+export declare const paymentTools: {
+    /**
+     * Create a deposit request (USDC, USDT, or BTC)
+     */
+    deposit_create: {
+        description: string;
+        handler: (args: {
+            agentId: string;
+            apiKey: string;
+            amount: number;
+            currency: "USDC" | "USDT" | "BTC";
+        }) => Promise<{
+            success: boolean;
+            error: string | undefined;
+            depositId?: undefined;
+            currency?: undefined;
+            amount?: undefined;
+            paymentInstructions?: undefined;
+            message?: undefined;
+        } | {
+            success: boolean;
+            depositId: string | undefined;
+            currency: "USDC" | "BTC" | "USDT";
+            amount: number;
+            paymentInstructions: {
+                currency: import("../types/index.js").Currency;
+                network: import("../types/index.js").PaymentNetwork;
+                address?: string;
+                url?: string;
+                amount: number;
+                amountRaw?: string;
+                expiresAt?: Date;
+                qrData?: string;
+            } | undefined;
+            message: string;
+            error?: undefined;
+        }>;
+    };
+    /**
+     * Check deposit status - verifies with payment provider and auto-credits if paid
+     */
+    deposit_status: {
+        description: string;
+        handler: (args: {
+            depositId: string;
+        }) => Promise<any>;
+    };
+    /**
+     * Get payment configuration status
+     */
+    payment_config: {
+        description: string;
+        handler: () => Promise<{
+            success: boolean;
+            paymentMethods: {
+                usdc: {
+                    configured: boolean;
+                    network: string;
+                    provider: string;
+                };
+                usdt: {
+                    configured: boolean;
+                    network: string;
+                    provider: string;
+                };
+                btc: {
+                    configured: boolean;
+                    network: string;
+                    provider: string;
+                };
+            };
+            supported: {
+                USDC: boolean;
+                USDT: boolean;
+                BTC: boolean;
+            };
+        }>;
+    };
+    /**
+     * Request crypto withdrawal
+     */
+    withdraw_crypto: {
+        description: string;
+        handler: (args: {
+            agentId: string;
+            apiKey: string;
+            amount: number;
+            currency: "USDC" | "USDT" | "BTC";
+            destination: string;
+        }) => Promise<{
+            success: boolean;
+            error: string;
+            withdrawalId?: undefined;
+            status?: undefined;
+            txId?: undefined;
+            message?: undefined;
+            newBalance?: undefined;
+        } | {
+            success: boolean;
+            withdrawalId: string;
+            status: string;
+            txId: string | undefined;
+            message: string;
+            error?: undefined;
+            newBalance?: undefined;
+        } | {
+            success: boolean;
+            withdrawalId: string;
+            status: string;
+            message: string;
+            newBalance: number;
+            error?: undefined;
+            txId?: undefined;
+        }>;
+    };
+    /**
+     * Set wallet addresses for an agent
+     */
+    agent_set_wallets: {
+        description: string;
+        handler: (args: {
+            agentId: string;
+            apiKey: string;
+            baseAddress?: string;
+            trc20Address?: string;
+            lightningAddress?: string;
+        }) => Promise<{
+            success: boolean;
+            error: string;
+            wallets?: undefined;
+            message?: undefined;
+        } | {
+            success: boolean;
+            wallets: any;
+            message: string;
+            error?: undefined;
+        }>;
+    };
+};