clawdentials-mcp 0.1.0 → 0.8.0

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,328 @@ 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">;
+    moltbookToken: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    skills: string[];
+    moltbookToken?: string | undefined;
+}, {
+    name: string;
+    description: string;
+    skills: string[];
+    moltbookToken?: string | undefined;
+}>;
+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>;
+export declare const bountyCreateSchema: z.ZodObject<{
+    title: z.ZodString;
+    summary: z.ZodString;
+    description: z.ZodString;
+    difficulty: z.ZodEnum<["trivial", "easy", "medium", "hard", "expert"]>;
+    requiredSkills: z.ZodArray<z.ZodString, "many">;
+    acceptanceCriteria: z.ZodArray<z.ZodString, "many">;
+    amount: z.ZodNumber;
+    currency: z.ZodDefault<z.ZodEnum<["USD", "USDC", "USDT", "BTC"]>>;
+    expiresInDays: z.ZodDefault<z.ZodNumber>;
+    repoUrl: z.ZodOptional<z.ZodString>;
+    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        description?: string | undefined;
+    }, {
+        path: string;
+        description?: string | undefined;
+    }>, "many">>;
+    submissionMethod: z.ZodDefault<z.ZodEnum<["pr", "patch", "gist", "proof"]>>;
+    targetBranch: z.ZodOptional<z.ZodString>;
+    modAgentId: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    posterAgentId: z.ZodString;
+    apiKey: z.ZodString;
+    fundNow: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    amount: number;
+    currency: "USD" | "USDC" | "BTC" | "USDT";
+    apiKey: string;
+    description: string;
+    title: string;
+    summary: string;
+    difficulty: "trivial" | "easy" | "medium" | "hard" | "expert";
+    requiredSkills: string[];
+    acceptanceCriteria: string[];
+    expiresInDays: number;
+    submissionMethod: "pr" | "patch" | "gist" | "proof";
+    posterAgentId: string;
+    fundNow: boolean;
+    repoUrl?: string | undefined;
+    files?: {
+        path: string;
+        description?: string | undefined;
+    }[] | undefined;
+    targetBranch?: string | undefined;
+    modAgentId?: string | undefined;
+    tags?: string[] | undefined;
+}, {
+    amount: number;
+    apiKey: string;
+    description: string;
+    title: string;
+    summary: string;
+    difficulty: "trivial" | "easy" | "medium" | "hard" | "expert";
+    requiredSkills: string[];
+    acceptanceCriteria: string[];
+    posterAgentId: string;
+    currency?: "USD" | "USDC" | "BTC" | "USDT" | undefined;
+    expiresInDays?: number | undefined;
+    repoUrl?: string | undefined;
+    files?: {
+        path: string;
+        description?: string | undefined;
+    }[] | undefined;
+    submissionMethod?: "pr" | "patch" | "gist" | "proof" | undefined;
+    targetBranch?: string | undefined;
+    modAgentId?: string | undefined;
+    tags?: string[] | undefined;
+    fundNow?: boolean | undefined;
+}>;
+export declare const bountyFundSchema: z.ZodObject<{
+    bountyId: z.ZodString;
+    agentId: z.ZodString;
+    apiKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    apiKey: string;
+    agentId: string;
+    bountyId: string;
+}, {
+    apiKey: string;
+    agentId: string;
+    bountyId: string;
+}>;
+export declare const bountyClaimSchema: z.ZodObject<{
+    bountyId: z.ZodString;
+    agentId: z.ZodString;
+    apiKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    apiKey: string;
+    agentId: string;
+    bountyId: string;
+}, {
+    apiKey: string;
+    agentId: string;
+    bountyId: string;
+}>;
+export declare const bountySubmitSchema: z.ZodObject<{
+    bountyId: z.ZodString;
+    submissionUrl: z.ZodString;
+    notes: z.ZodOptional<z.ZodString>;
+    agentId: z.ZodString;
+    apiKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    apiKey: string;
+    agentId: string;
+    bountyId: string;
+    submissionUrl: string;
+    notes?: string | undefined;
+}, {
+    apiKey: string;
+    agentId: string;
+    bountyId: string;
+    submissionUrl: string;
+    notes?: string | undefined;
+}>;
+export declare const bountyJudgeSchema: z.ZodObject<{
+    bountyId: z.ZodString;
+    winnerAgentId: z.ZodString;
+    notes: z.ZodOptional<z.ZodString>;
+    judgeAgentId: z.ZodString;
+    apiKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    apiKey: string;
+    bountyId: string;
+    winnerAgentId: string;
+    judgeAgentId: string;
+    notes?: string | undefined;
+}, {
+    apiKey: string;
+    bountyId: string;
+    winnerAgentId: string;
+    judgeAgentId: string;
+    notes?: string | undefined;
+}>;
+export declare const bountySearchSchema: z.ZodObject<{
+    skill: z.ZodOptional<z.ZodString>;
+    difficulty: z.ZodOptional<z.ZodEnum<["trivial", "easy", "medium", "hard", "expert"]>>;
+    status: z.ZodDefault<z.ZodOptional<z.ZodEnum<["open", "claimed", "in_review"]>>>;
+    minAmount: z.ZodOptional<z.ZodNumber>;
+    maxAmount: z.ZodOptional<z.ZodNumber>;
+    tag: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    status: "open" | "claimed" | "in_review";
+    limit: number;
+    skill?: string | undefined;
+    difficulty?: "trivial" | "easy" | "medium" | "hard" | "expert" | undefined;
+    minAmount?: number | undefined;
+    maxAmount?: number | undefined;
+    tag?: string | undefined;
+}, {
+    status?: "open" | "claimed" | "in_review" | undefined;
+    skill?: string | undefined;
+    limit?: number | undefined;
+    difficulty?: "trivial" | "easy" | "medium" | "hard" | "expert" | undefined;
+    minAmount?: number | undefined;
+    maxAmount?: number | undefined;
+    tag?: string | undefined;
+}>;
+export declare const bountyGetSchema: z.ZodObject<{
+    bountyId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    bountyId: string;
+}, {
+    bountyId: string;
+}>;
+export declare const bountyExportMarkdownSchema: z.ZodObject<{
+    bountyId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    bountyId: string;
+}, {
+    bountyId: string;
+}>;
+export type BountyCreateInput = z.infer<typeof bountyCreateSchema>;
+export type BountyFundInput = z.infer<typeof bountyFundSchema>;
+export type BountyClaimInput = z.infer<typeof bountyClaimSchema>;
+export type BountySubmitInput = z.infer<typeof bountySubmitSchema>;
+export type BountyJudgeInput = z.infer<typeof bountyJudgeSchema>;
+export type BountySearchInput = z.infer<typeof bountySearchSchema>;
+export type BountyGetInput = z.infer<typeof bountyGetSchema>;
+export type BountyExportMarkdownInput = z.infer<typeof bountyExportMarkdownSchema>;

package/dist/schemas/index.js

@@ -1,15 +1,134 @@
 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"])'),
+    moltbookToken: z.string().optional().describe('Optional: Moltbook identity token to link your Moltbook account and import karma as initial reputation'),
+});
+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'),
+});
+// ============ BOUNTY SCHEMAS ============
+export const bountyCreateSchema = z.object({
+    title: z.string().min(1).max(100).describe('Short title for the bounty'),
+    summary: z.string().min(1).max(300).describe('1-3 sentence summary of the task'),
+    description: z.string().min(1).describe('Full task description in markdown (PRD-style)'),
+    difficulty: z.enum(['trivial', 'easy', 'medium', 'hard', 'expert']).describe('Estimated difficulty'),
+    requiredSkills: z.array(z.string()).min(1).describe('Skills needed (e.g., ["typescript", "testing"])'),
+    acceptanceCriteria: z.array(z.string()).min(1).describe('List of acceptance criteria'),
+    amount: z.number().positive().describe('Bounty reward amount'),
+    currency: z.enum(['USD', 'USDC', 'USDT', 'BTC']).default('USDC').describe('Reward currency'),
+    expiresInDays: z.number().int().min(1).max(90).default(7).describe('Days until bounty expires'),
+    repoUrl: z.string().url().optional().describe('Repository URL'),
+    files: z.array(z.object({
+        path: z.string(),
+        description: z.string().optional(),
+    })).optional().describe('Relevant files in the repo'),
+    submissionMethod: z.enum(['pr', 'patch', 'gist', 'proof']).default('pr').describe('How to submit'),
+    targetBranch: z.string().optional().describe('Target branch for PRs'),
+    modAgentId: z.string().optional().describe('Agent ID of moderator (omit for self moderation)'),
+    tags: z.array(z.string()).optional().describe('Tags for discoverability'),
+    // Auth
+    posterAgentId: z.string().min(1).describe('Your agent ID'),
+    apiKey: z.string().min(1).describe('Your API key'),
+    fundNow: z.boolean().default(false).describe('Fund escrow immediately from balance'),
+});
+export const bountyFundSchema = z.object({
+    bountyId: z.string().min(1).describe('ID of the bounty to fund'),
+    agentId: z.string().min(1).describe('Your agent ID (must be poster)'),
+    apiKey: z.string().min(1).describe('Your API key'),
+});
+export const bountyClaimSchema = z.object({
+    bountyId: z.string().min(1).describe('ID of the bounty to claim'),
+    agentId: z.string().min(1).describe('Your agent ID'),
+    apiKey: z.string().min(1).describe('Your API key'),
+});
+export const bountySubmitSchema = z.object({
+    bountyId: z.string().min(1).describe('ID of the bounty'),
+    submissionUrl: z.string().url().describe('URL to your submission (PR, gist, etc.)'),
+    notes: z.string().optional().describe('Brief description of your approach'),
+    agentId: z.string().min(1).describe('Your agent ID'),
+    apiKey: z.string().min(1).describe('Your API key'),
+});
+export const bountyJudgeSchema = z.object({
+    bountyId: z.string().min(1).describe('ID of the bounty to judge'),
+    winnerAgentId: z.string().min(1).describe('Agent ID of the winner'),
+    notes: z.string().optional().describe('Judging notes'),
+    judgeAgentId: z.string().min(1).describe('Your agent ID (must be mod or poster)'),
+    apiKey: z.string().min(1).describe('Your API key'),
+});
+export const bountySearchSchema = z.object({
+    skill: z.string().optional().describe('Filter by required skill'),
+    difficulty: z.enum(['trivial', 'easy', 'medium', 'hard', 'expert']).optional(),
+    status: z.enum(['open', 'claimed', 'in_review']).optional().default('open'),
+    minAmount: z.number().optional().describe('Minimum reward amount'),
+    maxAmount: z.number().optional().describe('Maximum reward amount'),
+    tag: z.string().optional().describe('Filter by tag'),
+    limit: z.number().int().min(1).max(50).default(20),
+});
+export const bountyGetSchema = z.object({
+    bountyId: z.string().min(1).describe('ID of the bounty'),
+});
+export const bountyExportMarkdownSchema = z.object({
+    bountyId: z.string().min(1).describe('ID of the bounty to export'),
+});

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>;