clawdentials-mcp 0.1.0 → 0.7.2

package/dist/index.js

@@ -1,53 +1,260 @@
 #!/usr/bin/env node
+import 'dotenv/config';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
-import { escrowTools } from './tools/index.js';
+import { escrowTools, agentTools, adminTools, paymentTools } from './tools/index.js';
 import { initFirestore } from './services/firestore.js';
-// Initialize Firestore
+// ============ CLI REGISTRATION GATEWAY ============
+// Enables one-shot registration without MCP config:
+// npx clawdentials-mcp --register "AgentName" --skills "coding,research" --description "What I do"
+async function handleCliRegistration() {
+    const args = process.argv.slice(2);
+    // Check for --register flag
+    const registerIndex = args.indexOf('--register');
+    if (registerIndex === -1) {
+        return false; // No CLI registration, continue with MCP server
+    }
+    // Initialize Firestore for CLI mode
+    initFirestore();
+    // Parse arguments
+    const name = args[registerIndex + 1];
+    const skillsIndex = args.indexOf('--skills');
+    const descIndex = args.indexOf('--description');
+    if (!name) {
+        console.error('Error: --register requires an agent name');
+        console.error('Usage: npx clawdentials-mcp --register "AgentName" --skills "coding,research" --description "What I do"');
+        process.exit(1);
+    }
+    const skillsRaw = skillsIndex !== -1 ? args[skillsIndex + 1] : 'general';
+    const description = descIndex !== -1 ? args[descIndex + 1] : `Agent: ${name}`;
+    // Parse skills (comma-separated)
+    const skills = skillsRaw.split(',').map(s => s.trim()).filter(Boolean);
+    console.log('\n╔════════════════════════════════════════════════════════════╗');
+    console.log('║           CLAWDENTIALS AGENT REGISTRATION                   ║');
+    console.log('╚════════════════════════════════════════════════════════════╝\n');
+    console.log(`Registering agent: ${name}`);
+    console.log(`Skills: ${skills.join(', ')}`);
+    console.log(`Description: ${description}\n`);
+    try {
+        const result = await agentTools.agent_register.handler({
+            name,
+            description,
+            skills,
+        });
+        if (!result.success) {
+            console.error(`\n❌ Registration failed: ${result.error}`);
+            process.exit(1);
+        }
+        console.log('✅ Registration successful!\n');
+        console.log('═'.repeat(60));
+        console.log('⚠️  SAVE THESE CREDENTIALS - THEY CANNOT BE RECOVERED!');
+        console.log('═'.repeat(60));
+        console.log('\n📋 AGENT DETAILS:');
+        console.log(`   ID: ${result.agent?.id}`);
+        console.log(`   Name: ${result.agent?.name}`);
+        console.log(`   NIP-05: ${result.credentials?.nostr?.nip05}`);
+        console.log('\n🔑 API KEY (use this to authenticate):');
+        console.log(`   ${result.credentials?.apiKey}`);
+        console.log('\n🔐 NOSTR IDENTITY:');
+        console.log(`   npub: ${result.credentials?.nostr?.npub}`);
+        console.log(`   nsec: ${result.credentials?.nostr?.nsec}`);
+        console.log('\n═'.repeat(60));
+        console.log('\n📖 NEXT STEPS:');
+        console.log('   1. Save your API key and Nostr credentials securely');
+        console.log('   2. Add MCP server to claude_desktop_config.json:');
+        console.log('      {');
+        console.log('        "mcpServers": {');
+        console.log('          "clawdentials": {');
+        console.log('            "command": "npx",');
+        console.log('            "args": ["clawdentials-mcp"]');
+        console.log('          }');
+        console.log('        }');
+        console.log('      }');
+        console.log('   3. Restart Claude Desktop');
+        console.log('   4. Start completing escrowed tasks to build reputation!');
+        // Output JSON for programmatic capture
+        if (args.includes('--json')) {
+            console.log('\n📄 JSON OUTPUT:');
+            console.log(JSON.stringify(result, null, 2));
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        console.error('\n❌ Registration error:', error);
+        process.exit(1);
+    }
+}
+// Check for CLI registration mode first
+const isCli = await handleCliRegistration();
+// Initialize Firestore for MCP server mode
 initFirestore();
 // Create MCP server
 const server = new McpServer({
     name: 'clawdentials',
-    version: '0.1.0',
+    version: '0.7.2',
 });
-// Register escrow_create tool
+// ============ ESCROW TOOLS ============
 server.tool('escrow_create', escrowTools.escrow_create.description, {
     taskDescription: z.string().describe('Description of the task to be completed'),
-    amount: z.number().positive().describe('Amount to escrow in the specified currency'),
-    currency: z.enum(['USD', 'USDC', 'BTC']).default('USD').describe('Currency for the escrow'),
+    amount: z.number().positive().describe('Amount to escrow'),
+    currency: z.enum(['USD', 'USDC', 'USDT', 'BTC']).default('USD').describe('Currency'),
     providerAgentId: z.string().describe('ID of the agent who will complete the task'),
     clientAgentId: z.string().describe('ID of the agent creating the escrow'),
+    apiKey: z.string().describe('API key for the client agent'),
 }, async (args) => {
     const result = await escrowTools.escrow_create.handler(args);
-    return {
-        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-    };
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
 });
-// Register escrow_complete tool
 server.tool('escrow_complete', escrowTools.escrow_complete.description, {
     escrowId: z.string().describe('ID of the escrow to complete'),
     proofOfWork: z.string().describe('Proof that the task was completed'),
+    apiKey: z.string().describe('API key for the provider agent'),
 }, async (args) => {
     const result = await escrowTools.escrow_complete.handler(args);
-    return {
-        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-    };
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
 });
-// Register escrow_status tool
 server.tool('escrow_status', escrowTools.escrow_status.description, {
     escrowId: z.string().describe('ID of the escrow to check'),
 }, async (args) => {
     const result = await escrowTools.escrow_status.handler(args);
-    return {
-        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-    };
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+server.tool('escrow_dispute', escrowTools.escrow_dispute.description, {
+    escrowId: z.string().describe('ID of the escrow to dispute'),
+    reason: z.string().describe('Reason for the dispute'),
+    apiKey: z.string().describe('API key for the client agent'),
+}, async (args) => {
+    const result = await escrowTools.escrow_dispute.handler(args);
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+// ============ AGENT TOOLS ============
+server.tool('agent_register', agentTools.agent_register.description, {
+    name: z.string().describe('Unique name/identifier for the agent'),
+    description: z.string().describe('Brief description of what this agent does'),
+    skills: z.array(z.string()).describe('List of skills/capabilities'),
+}, async (args) => {
+    const result = await agentTools.agent_register.handler(args);
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+server.tool('agent_score', agentTools.agent_score.description, {
+    agentId: z.string().describe('ID of the agent to get the reputation score for'),
+}, async (args) => {
+    const result = await agentTools.agent_score.handler(args);
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+server.tool('agent_search', agentTools.agent_search.description, {
+    skill: z.string().optional().describe('Filter by skill (partial match)'),
+    verified: z.boolean().optional().describe('Filter by verified status'),
+    minTasksCompleted: z.number().optional().describe('Minimum completed tasks'),
+    limit: z.number().optional().default(20).describe('Max results'),
+}, async (args) => {
+    const result = await agentTools.agent_search.handler(args);
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+server.tool('agent_balance', agentTools.agent_balance.description, {
+    agentId: z.string().describe('ID of the agent'),
+    apiKey: z.string().describe('API key for the agent'),
+}, async (args) => {
+    const result = await agentTools.agent_balance.handler(args);
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+server.tool('withdraw_request', agentTools.withdraw_request.description, {
+    agentId: z.string().describe('ID of the agent'),
+    apiKey: z.string().describe('API key for the agent'),
+    amount: z.number().positive().describe('Amount to withdraw'),
+    currency: z.enum(['USD', 'USDC', 'USDT', 'BTC']).default('USD').describe('Currency'),
+    paymentMethod: z.string().describe('Payment method (e.g., "PayPal: email@example.com")'),
+}, async (args) => {
+    const result = await agentTools.withdraw_request.handler(args);
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+// ============ ADMIN TOOLS ============
+server.tool('admin_credit_balance', adminTools.admin_credit_balance.description, {
+    adminSecret: z.string().describe('Admin secret key'),
+    agentId: z.string().describe('ID of the agent to credit'),
+    amount: z.number().positive().describe('Amount to credit'),
+    currency: z.enum(['USD', 'USDC', 'USDT', 'BTC']).default('USD').describe('Currency'),
+    notes: z.string().optional().describe('Notes (e.g., "PayPal payment received")'),
+}, async (args) => {
+    const result = await adminTools.admin_credit_balance.handler(args);
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+server.tool('admin_list_withdrawals', adminTools.admin_list_withdrawals.description, {
+    adminSecret: z.string().describe('Admin secret key'),
+    status: z.enum(['pending', 'processing', 'completed', 'rejected']).optional().describe('Filter by status'),
+    limit: z.number().optional().default(50).describe('Max results'),
+}, async (args) => {
+    const result = await adminTools.admin_list_withdrawals.handler(args);
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+server.tool('admin_process_withdrawal', adminTools.admin_process_withdrawal.description, {
+    adminSecret: z.string().describe('Admin secret key'),
+    withdrawalId: z.string().describe('ID of the withdrawal'),
+    action: z.enum(['complete', 'reject']).describe('Action to take'),
+    notes: z.string().optional().describe('Notes'),
+}, async (args) => {
+    const result = await adminTools.admin_process_withdrawal.handler(args);
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+server.tool('admin_refund_escrow', adminTools.admin_refund_escrow.description, {
+    adminSecret: z.string().describe('Admin secret key'),
+    escrowId: z.string().describe('ID of the disputed escrow to refund'),
+}, async (args) => {
+    const result = await adminTools.admin_refund_escrow.handler(args);
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+server.tool('admin_nostr_json', adminTools.admin_nostr_json.description, {
+    adminSecret: z.string().describe('Admin secret key'),
+}, async (args) => {
+    const result = await adminTools.admin_nostr_json.handler(args);
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+// ============ PAYMENT TOOLS ============
+server.tool('deposit_create', paymentTools.deposit_create.description, {
+    agentId: z.string().describe('ID of the agent making the deposit'),
+    apiKey: z.string().describe('API key for the agent'),
+    amount: z.number().positive().describe('Amount to deposit in USD'),
+    currency: z.enum(['USDC', 'USDT', 'BTC']).describe('Cryptocurrency to deposit'),
+}, async (args) => {
+    const result = await paymentTools.deposit_create.handler(args);
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+server.tool('deposit_status', paymentTools.deposit_status.description, {
+    depositId: z.string().describe('ID of the deposit to check'),
+}, async (args) => {
+    const result = await paymentTools.deposit_status.handler(args);
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+server.tool('payment_config', paymentTools.payment_config.description, {}, async () => {
+    const result = await paymentTools.payment_config.handler();
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+server.tool('withdraw_crypto', paymentTools.withdraw_crypto.description, {
+    agentId: z.string().describe('ID of the agent'),
+    apiKey: z.string().describe('API key for the agent'),
+    amount: z.number().positive().describe('Amount to withdraw in USD'),
+    currency: z.enum(['USDC', 'USDT', 'BTC']).describe('Cryptocurrency for withdrawal'),
+    destination: z.string().describe('Wallet address (USDC/USDT) or Lightning invoice/address (BTC)'),
+}, async (args) => {
+    const result = await paymentTools.withdraw_crypto.handler(args);
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+server.tool('agent_set_wallets', paymentTools.agent_set_wallets.description, {
+    agentId: z.string().describe('ID of the agent'),
+    apiKey: z.string().describe('API key for the agent'),
+    baseAddress: z.string().optional().describe('Base/EVM address for USDC (0x...)'),
+    trc20Address: z.string().optional().describe('TRC-20 address for USDT (T...)'),
+    lightningAddress: z.string().optional().describe('Lightning Address for BTC (user@domain)'),
+}, async (args) => {
+    const result = await paymentTools.agent_set_wallets.handler(args);
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
 });
 // Start server
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error('Clawdentials MCP server running on stdio');
+    console.error('Clawdentials MCP server v0.7.2 running on stdio');
 }
 main().catch((error) => {
     console.error('Fatal error:', error);

package/dist/schemas/index.d.ts

@@ -5,26 +5,32 @@ export declare const escrowCreateSchema: z.ZodObject<{
     currency: z.ZodDefault<z.ZodEnum<["USD", "USDC", "BTC"]>>;
     providerAgentId: z.ZodString;
     clientAgentId: z.ZodString;
+    apiKey: z.ZodString;
 }, "strip", z.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;
 }>;
 export declare const escrowCompleteSchema: z.ZodObject<{
     escrowId: z.ZodString;
     proofOfWork: z.ZodString;
+    apiKey: z.ZodString;
 }, "strip", z.ZodTypeAny, {
+    apiKey: string;
     escrowId: string;
     proofOfWork: string;
 }, {
+    apiKey: string;
     escrowId: string;
     proofOfWork: string;
 }>;
@@ -35,6 +41,141 @@ export declare const escrowStatusSchema: z.ZodObject<{
 }, {
     escrowId: string;
 }>;
+export declare const escrowDisputeSchema: z.ZodObject<{
+    escrowId: z.ZodString;
+    reason: z.ZodString;
+    apiKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    apiKey: string;
+    escrowId: string;
+    reason: string;
+}, {
+    apiKey: string;
+    escrowId: string;
+    reason: string;
+}>;
+export declare const agentRegisterSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    skills: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    skills: string[];
+}, {
+    name: string;
+    description: string;
+    skills: string[];
+}>;
+export declare const agentScoreSchema: z.ZodObject<{
+    agentId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    agentId: string;
+}, {
+    agentId: string;
+}>;
+export declare const agentSearchSchema: z.ZodObject<{
+    skill: z.ZodOptional<z.ZodString>;
+    verified: z.ZodOptional<z.ZodBoolean>;
+    minTasksCompleted: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    skill?: string | undefined;
+    verified?: boolean | undefined;
+    minTasksCompleted?: number | undefined;
+}, {
+    skill?: string | undefined;
+    verified?: boolean | undefined;
+    minTasksCompleted?: number | undefined;
+    limit?: number | undefined;
+}>;
+export declare const agentBalanceSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    apiKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    apiKey: string;
+    agentId: string;
+}, {
+    apiKey: string;
+    agentId: string;
+}>;
+export declare const withdrawRequestSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    apiKey: z.ZodString;
+    amount: z.ZodNumber;
+    currency: z.ZodDefault<z.ZodEnum<["USD", "USDC", "BTC"]>>;
+    paymentMethod: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    amount: number;
+    currency: "USD" | "USDC" | "BTC";
+    apiKey: string;
+    agentId: string;
+    paymentMethod: string;
+}, {
+    amount: number;
+    apiKey: string;
+    agentId: string;
+    paymentMethod: string;
+    currency?: "USD" | "USDC" | "BTC" | undefined;
+}>;
+export declare const adminCreditBalanceSchema: 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;
+}>;
+export declare const adminProcessWithdrawalSchema: 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;
+}>;
+export declare const adminListWithdrawalsSchema: 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;
+}>;
 export type EscrowCreateInput = z.infer<typeof escrowCreateSchema>;
 export type EscrowCompleteInput = z.infer<typeof escrowCompleteSchema>;
 export type EscrowStatusInput = z.infer<typeof escrowStatusSchema>;
+export type EscrowDisputeInput = z.infer<typeof escrowDisputeSchema>;
+export type AgentRegisterInput = z.infer<typeof agentRegisterSchema>;
+export type AgentScoreInput = z.infer<typeof agentScoreSchema>;
+export type AgentSearchInput = z.infer<typeof agentSearchSchema>;
+export type AgentBalanceInput = z.infer<typeof agentBalanceSchema>;
+export type WithdrawRequestInput = z.infer<typeof withdrawRequestSchema>;
+export type AdminCreditBalanceInput = z.infer<typeof adminCreditBalanceSchema>;
+export type AdminProcessWithdrawalInput = z.infer<typeof adminProcessWithdrawalSchema>;
+export type AdminListWithdrawalsInput = z.infer<typeof adminListWithdrawalsSchema>;

package/dist/schemas/index.js

@@ -1,15 +1,69 @@
 import { z } from 'zod';
+// Escrow schemas
 export const escrowCreateSchema = z.object({
     taskDescription: z.string().min(1).describe('Description of the task to be completed'),
     amount: z.number().positive().describe('Amount to escrow in the specified currency'),
     currency: z.enum(['USD', 'USDC', 'BTC']).default('USD').describe('Currency for the escrow'),
     providerAgentId: z.string().min(1).describe('ID of the agent who will complete the task'),
     clientAgentId: z.string().min(1).describe('ID of the agent creating the escrow'),
+    apiKey: z.string().min(1).describe('API key for the client agent (from agent_register)'),
 });
 export const escrowCompleteSchema = z.object({
     escrowId: z.string().min(1).describe('ID of the escrow to complete'),
     proofOfWork: z.string().min(1).describe('Proof that the task was completed (e.g., result summary, link, hash)'),
+    apiKey: z.string().min(1).describe('API key for the provider agent'),
 });
 export const escrowStatusSchema = z.object({
     escrowId: z.string().min(1).describe('ID of the escrow to check'),
 });
+export const escrowDisputeSchema = z.object({
+    escrowId: z.string().min(1).describe('ID of the escrow to dispute'),
+    reason: z.string().min(1).describe('Reason for the dispute'),
+    apiKey: z.string().min(1).describe('API key for the disputing agent (client)'),
+});
+// Agent schemas
+export const agentRegisterSchema = z.object({
+    name: z.string().min(1).max(64).describe('Unique name/identifier for the agent'),
+    description: z.string().min(1).max(500).describe('Brief description of what this agent does'),
+    skills: z.array(z.string()).min(1).describe('List of skills/capabilities (e.g., ["research", "coding", "data-analysis"])'),
+});
+export const agentScoreSchema = z.object({
+    agentId: z.string().min(1).describe('ID of the agent to get the reputation score for'),
+});
+export const agentSearchSchema = z.object({
+    skill: z.string().optional().describe('Filter by skill (partial match)'),
+    verified: z.boolean().optional().describe('Filter by verified status'),
+    minTasksCompleted: z.number().int().min(0).optional().describe('Minimum number of completed tasks'),
+    limit: z.number().int().min(1).max(100).default(20).describe('Maximum number of results to return'),
+});
+// Balance schemas
+export const agentBalanceSchema = z.object({
+    agentId: z.string().min(1).describe('ID of the agent'),
+    apiKey: z.string().min(1).describe('API key for the agent'),
+});
+export const withdrawRequestSchema = z.object({
+    agentId: z.string().min(1).describe('ID of the agent requesting withdrawal'),
+    apiKey: z.string().min(1).describe('API key for the agent'),
+    amount: z.number().positive().describe('Amount to withdraw'),
+    currency: z.enum(['USD', 'USDC', 'BTC']).default('USD').describe('Currency'),
+    paymentMethod: z.string().min(1).describe('Payment method details (e.g., "PayPal: email@example.com")'),
+});
+// Admin schemas (require admin secret)
+export const adminCreditBalanceSchema = z.object({
+    adminSecret: z.string().min(1).describe('Admin secret key'),
+    agentId: z.string().min(1).describe('ID of the agent to credit'),
+    amount: z.number().positive().describe('Amount to credit'),
+    currency: z.enum(['USD', 'USDC', 'BTC']).default('USD').describe('Currency'),
+    notes: z.string().optional().describe('Notes (e.g., "PayPal payment received")'),
+});
+export const adminProcessWithdrawalSchema = z.object({
+    adminSecret: z.string().min(1).describe('Admin secret key'),
+    withdrawalId: z.string().min(1).describe('ID of the withdrawal to process'),
+    action: z.enum(['complete', 'reject']).describe('Action to take'),
+    notes: z.string().optional().describe('Notes about the processing'),
+});
+export const adminListWithdrawalsSchema = z.object({
+    adminSecret: z.string().min(1).describe('Admin secret key'),
+    status: z.enum(['pending', 'processing', 'completed', 'rejected']).optional().describe('Filter by status'),
+    limit: z.number().int().min(1).max(100).default(50).describe('Max results'),
+});

package/dist/services/firestore.d.ts

@@ -1,5 +1,15 @@
 import { Firestore } from 'firebase-admin/firestore';
-import type { Escrow } from '../types/index.js';
+import type { Escrow, Agent, Withdrawal, Currency } from '../types/index.js';
+export declare const FEE_RATE = 0.1;
+export declare const ADMIN_SECRET: string;
+export declare function generateApiKey(): string;
+export declare function hashApiKey(apiKey: string): string;
+export declare function generateNostrKeypair(): {
+    secretKey: Uint8Array;
+    publicKey: string;
+    nsec: string;
+    npub: string;
+};
 export declare function initFirestore(): Firestore;
 export declare function getDb(): Firestore;
 export declare const collections: {
@@ -7,7 +17,40 @@ export declare const collections: {
     agents: () => FirebaseFirestore.CollectionReference<FirebaseFirestore.DocumentData, FirebaseFirestore.DocumentData>;
     tasks: () => FirebaseFirestore.CollectionReference<FirebaseFirestore.DocumentData, FirebaseFirestore.DocumentData>;
     subscriptions: () => FirebaseFirestore.CollectionReference<FirebaseFirestore.DocumentData, FirebaseFirestore.DocumentData>;
+    withdrawals: () => FirebaseFirestore.CollectionReference<FirebaseFirestore.DocumentData, FirebaseFirestore.DocumentData>;
+    deposits: () => FirebaseFirestore.CollectionReference<FirebaseFirestore.DocumentData, FirebaseFirestore.DocumentData>;
 };
-export declare function createEscrow(data: Omit<Escrow, 'id' | 'createdAt' | 'completedAt' | 'proofOfWork'>): Promise<Escrow>;
+export declare function createEscrow(data: Omit<Escrow, 'id' | 'createdAt' | 'completedAt' | 'proofOfWork' | 'fee' | 'feeRate' | 'disputeReason'>): Promise<Escrow>;
 export declare function getEscrow(escrowId: string): Promise<Escrow | null>;
 export declare function completeEscrow(escrowId: string, proofOfWork: string): Promise<Escrow | null>;
+export declare function createAgent(data: Omit<Agent, 'id' | 'createdAt' | 'stats' | 'apiKeyHash' | 'balance' | 'nostrPubkey' | 'nip05'>): Promise<{
+    agent: Agent;
+    apiKey: string;
+    nostr: {
+        nsec: string;
+        npub: string;
+        nip05: string;
+    };
+}>;
+export declare function getAgent(agentId: string): Promise<Agent | null>;
+export declare function validateApiKey(agentId: string, apiKey: string): Promise<boolean>;
+export declare function getOrCreateAgent(agentId: string): Promise<Agent>;
+export declare function searchAgents(query: {
+    skill?: string;
+    verified?: boolean;
+    minTasksCompleted?: number;
+    limit?: number;
+}): Promise<Agent[]>;
+export declare function incrementAgentDisputes(agentId: string): Promise<void>;
+export declare function disputeEscrow(escrowId: string, reason: string): Promise<Escrow | null>;
+export declare function calculateReputationScore(agent: Agent): number;
+export declare function getBalance(agentId: string): Promise<number>;
+export declare function creditBalance(agentId: string, amount: number, notes?: string): Promise<number>;
+export declare function debitBalance(agentId: string, amount: number): Promise<number>;
+export declare function createEscrowWithBalance(data: Omit<Escrow, 'id' | 'createdAt' | 'completedAt' | 'proofOfWork' | 'fee' | 'feeRate' | 'disputeReason'>): Promise<Escrow>;
+export declare function completeEscrowWithBalance(escrowId: string, proofOfWork: string): Promise<Escrow | null>;
+export declare function refundEscrow(escrowId: string): Promise<Escrow | null>;
+export declare function createWithdrawal(agentId: string, amount: number, currency: Currency, paymentMethod: string): Promise<Withdrawal>;
+export declare function getWithdrawal(withdrawalId: string): Promise<Withdrawal | null>;
+export declare function listWithdrawals(status?: string, limit?: number): Promise<Withdrawal[]>;
+export declare function processWithdrawal(withdrawalId: string, action: 'complete' | 'reject', notes?: string): Promise<Withdrawal | null>;