@fiber-pay/agent 0.1.0-rc.1

package/dist/mcp-tools.d.ts

@@ -0,0 +1,842 @@
+import * as _fiber_pay_sdk from '@fiber-pay/sdk';
+import { PolicyCheckResult, SecurityPolicy, HexString, InvoiceVerificationResult, PaymentProof, PaymentProofSummary, LiquidityReport } from '@fiber-pay/sdk';
+import { DownloadProgress } from '@fiber-pay/node';
+
+/**
+ * Standard result format for all operations
+ * Designed to be easily parsed by AI agents
+ */
+interface AgentResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: {
+        code: string;
+        message: string;
+        recoverable: boolean;
+        suggestion?: string;
+    };
+    metadata?: {
+        timestamp: number;
+        policyCheck?: PolicyCheckResult;
+    };
+}
+/**
+ * Balance information in human-readable format
+ */
+interface BalanceInfo {
+    /** Total balance across all channels (in CKB) */
+    totalCkb: number;
+    /** Available to send (in CKB) */
+    availableToSend: number;
+    /** Available to receive (in CKB) */
+    availableToReceive: number;
+    /** Number of active channels */
+    channelCount: number;
+    /** Remaining spending allowance this period (in CKB) */
+    spendingAllowance: number;
+}
+/**
+ * Payment result with tracking info
+ */
+interface PaymentResult {
+    /** Payment hash for tracking */
+    paymentHash: string;
+    /** Status of the payment */
+    status: 'pending' | 'success' | 'failed';
+    /** Amount sent (in CKB) */
+    amountCkb: number;
+    /** Fee paid (in CKB) */
+    feeCkb: number;
+    /** Error message if failed */
+    failureReason?: string;
+}
+/**
+ * Invoice result
+ */
+interface InvoiceResult {
+    /** Invoice string to share with payer */
+    invoice: string;
+    /** Payment hash for tracking */
+    paymentHash: string;
+    /** Amount to receive (in CKB) */
+    amountCkb: number;
+    /** Expiry time (ISO string) */
+    expiresAt: string;
+    /** Status */
+    status: 'open' | 'accepted' | 'settled' | 'cancelled';
+}
+/**
+ * Hold invoice result (for escrow / conditional payments)
+ */
+interface HoldInvoiceResult {
+    /** Invoice string to share with payer */
+    invoice: string;
+    /** Payment hash for tracking */
+    paymentHash: string;
+    /** Amount to receive (in CKB) */
+    amountCkb: number;
+    /** Expiry time (ISO string) */
+    expiresAt: string;
+    /** Status — starts as 'open', becomes 'accepted' when payer sends */
+    status: 'open' | 'accepted' | 'settled' | 'cancelled';
+}
+/**
+ * Channel summary
+ */
+interface ChannelSummary {
+    /** Channel ID */
+    id: string;
+    /** Peer node ID */
+    peerId: string;
+    /** Local balance (in CKB) */
+    localBalanceCkb: number;
+    /** Remote balance (in CKB) */
+    remoteBalanceCkb: number;
+    /** Channel state */
+    state: string;
+    /** Is public channel */
+    isPublic: boolean;
+}
+/**
+ * Verification result for invoices
+ */
+type InvoiceValidationResult = InvoiceVerificationResult;
+/**
+ * Liquidity analysis result
+ */
+type LiquidityAnalysisResult = LiquidityReport;
+interface FiberPayConfig {
+    /** Path to the fnn binary (optional - will auto-download if not provided) */
+    binaryPath?: string;
+    /** Base directory for all data */
+    dataDir: string;
+    /** Path to the config file (optional - will use built-in testnet config if not provided) */
+    configFilePath?: string;
+    /** Security policy */
+    policy?: SecurityPolicy;
+    /** Key encryption password (recommended: set via FIBER_KEY_PASSWORD env var) */
+    keyPassword?: string;
+    /** CKB RPC URL */
+    ckbRpcUrl?: string;
+    /** Chain: mainnet or testnet */
+    chain?: 'mainnet' | 'testnet';
+    /** Bootstrap nodes */
+    bootnodes?: string[];
+    /** Auto-start the node */
+    autoStart?: boolean;
+    /** RPC port */
+    rpcPort?: number;
+    /** P2P port */
+    p2pPort?: number;
+    /** Auto-download binary if not found */
+    autoDownload?: boolean;
+    /** RPC URL for connecting to an existing node (when autoStart is false) */
+    rpcUrl?: string;
+    /** Enable runtime job orchestration for payments/invoices/channels (default: true) */
+    useRuntimeJobs?: boolean;
+    /** Optional sqlite path for runtime jobs */
+    runtimeJobsDbPath?: string;
+}
+/**
+ * FiberPay - Main interface for AI agents
+ *
+ * @example
+ * ```typescript
+ * const fiber = new FiberPay({
+ *   binaryPath: '/usr/local/bin/fnn',
+ *   dataDir: '~/.fiber-pay',
+ * });
+ *
+ * await fiber.initialize();
+ *
+ * // Check balance
+ * const balance = await fiber.getBalance();
+ *
+ * // Send payment
+ * const result = await fiber.pay({
+ *   invoice: 'fibt1...',
+ * });
+ *
+ * // Create invoice to receive payment
+ * const invoice = await fiber.createInvoice({
+ *   amountCkb: 10,
+ *   description: 'Payment for services',
+ * });
+ * ```
+ */
+declare class FiberPay {
+    private config;
+    private process;
+    private rpc;
+    private policy;
+    private keys;
+    private initialized;
+    private invoiceVerifier;
+    private paymentProofManager;
+    private liquidityAnalyzer;
+    private runtimeJobStore;
+    private runtimeJobManager;
+    constructor(config: FiberPayConfig);
+    /**
+     * Initialize the FiberPay instance
+     * - Downloads the binary if needed (and autoDownload is true)
+     * - Generates or loads keys
+     * - Starts the Fiber node (if autoStart is true)
+     * - Connects to RPC
+     */
+    initialize(options?: {
+        onDownloadProgress?: (progress: DownloadProgress) => void;
+    }): Promise<AgentResult<{
+        nodeId: string;
+    }>>;
+    /**
+     * Shutdown the FiberPay instance
+     */
+    shutdown(): Promise<AgentResult<void>>;
+    /**
+     * Pay an invoice or send directly to a node
+     *
+     * @example
+     * // Pay invoice
+     * await fiber.pay({ invoice: 'fibt1...' });
+     *
+     * // Send directly (keysend)
+     * await fiber.pay({
+     *   recipientNodeId: 'QmXXX...',
+     *   amountCkb: 10,
+     * });
+     */
+    pay(params: {
+        /** Invoice string to pay */
+        invoice?: string;
+        /** Recipient node ID for keysend */
+        recipientNodeId?: string;
+        /** Amount in CKB (for keysend) */
+        amountCkb?: number;
+        /** Maximum fee in CKB */
+        maxFeeCkb?: number;
+        /** Custom TLV records to attach (up to 2KB) */
+        customRecords?: Record<string, HexString>;
+        /** Maximum number of MPP parts (e.g. 4) */
+        maxParts?: number;
+    }): Promise<AgentResult<PaymentResult>>;
+    /**
+     * Create an invoice to receive payment
+     *
+     * @example
+     * const invoice = await fiber.createInvoice({
+     *   amountCkb: 10,
+     *   description: 'For coffee',
+     *   expiryMinutes: 60,
+     * });
+     * console.log(invoice.data?.invoice); // Share this with payer
+     */
+    createInvoice(params: {
+        /** Amount to receive in CKB */
+        amountCkb: number;
+        /** Description for the payer */
+        description?: string;
+        /** Expiry time in minutes (default: 60) */
+        expiryMinutes?: number;
+    }): Promise<AgentResult<InvoiceResult>>;
+    /**
+     * Get current balance information
+     */
+    getBalance(): Promise<AgentResult<BalanceInfo>>;
+    /**
+     * Check payment status
+     */
+    getPaymentStatus(paymentHash: string): Promise<AgentResult<PaymentResult>>;
+    /**
+     * Check invoice status
+     */
+    getInvoiceStatus(paymentHash: string): Promise<AgentResult<InvoiceResult>>;
+    /**
+     * List all channels
+     */
+    listChannels(): Promise<AgentResult<ChannelSummary[]>>;
+    /**
+     * Open a new channel
+     */
+    openChannel(params: {
+        /** Peer node ID or address */
+        peer: string;
+        /** Funding amount in CKB */
+        fundingCkb: number;
+        /** Make channel public */
+        isPublic?: boolean;
+        /**
+         * Optional idempotency key for retries.
+         * Reuse the same key when retrying the same open intent; use a new key for a distinct open request.
+         */
+        idempotencyKey?: string;
+    }): Promise<AgentResult<{
+        channelId: string;
+    }>>;
+    /**
+     * Close a channel
+     */
+    closeChannel(params: {
+        /** Channel ID */
+        channelId: string;
+        /** Force close (unilateral) */
+        force?: boolean;
+    }): Promise<AgentResult<void>>;
+    /**
+     * Get node information
+     */
+    getNodeInfo(): Promise<AgentResult<{
+        nodeId: string;
+        version: string;
+        channelCount: number;
+        peersCount: number;
+    }>>;
+    /**
+     * Validate an invoice before payment
+     * Checks format, expiry, amount, cryptographic correctness, and peer connectivity
+     *
+     * @example
+     * ```typescript
+     * const validation = await fiber.validateInvoice('fibt1...');
+     * if (validation.data?.recommendation === 'reject') {
+     *   console.log('Do not pay:', validation.data.reason);
+     * }
+     * ```
+     */
+    validateInvoice(invoice: string): Promise<AgentResult<InvoiceValidationResult>>;
+    /**
+     * Get payment proof (cryptographic evidence of payment)
+     * Returns stored proof if available, or creates one from RPC status
+     */
+    getPaymentProof(paymentHash: string): Promise<AgentResult<{
+        proof: PaymentProof | null;
+        verified: boolean;
+        status: string;
+    }>>;
+    /**
+     * Get payment proof summary for audit trail
+     */
+    getPaymentProofSummary(): Promise<AgentResult<PaymentProofSummary>>;
+    /**
+     * Export payment audit report
+     */
+    getPaymentAuditReport(options?: {
+        startTime?: number;
+        endTime?: number;
+    }): Promise<AgentResult<string>>;
+    /**
+     * Create a hold invoice (for escrow / conditional payments)
+     * The payer's funds are held until you explicitly settle with the preimage,
+     * or cancelled if you don't settle before expiry.
+     *
+     * @example
+     * ```typescript
+     * const invoice = await fiber.createHoldInvoice({
+     *   amountCkb: 10,
+     *   paymentHash: '0x...',  // SHA-256 hash of your secret preimage
+     *   description: 'Escrow for service',
+     * });
+     * // Share invoice.data.invoice with the payer
+     * // When conditions are met, call settleInvoice() with the preimage
+     * ```
+     */
+    createHoldInvoice(params: {
+        /** Amount to receive in CKB */
+        amountCkb: number;
+        /** Payment hash (SHA-256 of preimage you control) */
+        paymentHash: string;
+        /** Description for the payer */
+        description?: string;
+        /** Expiry time in minutes (default: 60) */
+        expiryMinutes?: number;
+    }): Promise<AgentResult<HoldInvoiceResult>>;
+    /**
+     * Settle a hold invoice by revealing the preimage
+     * This releases the held funds to you. No policy check needed since
+     * settling receives money, it doesn't spend it.
+     *
+     * @example
+     * ```typescript
+     * await fiber.settleInvoice({
+     *   paymentHash: '0x...',
+     *   preimage: '0x...',  // The secret preimage whose hash matches paymentHash
+     * });
+     * ```
+     */
+    settleInvoice(params: {
+        /** Payment hash of the hold invoice */
+        paymentHash: string;
+        /** Preimage that hashes to the payment hash */
+        preimage: string;
+    }): Promise<AgentResult<void>>;
+    /**
+     * Wait for a payment to complete (Success or Failed)
+     * Wraps the SDK-level polling helper with AgentResult return type.
+     */
+    waitForPayment(paymentHash: string, options?: {
+        /** Timeout in ms (default: 120000) */
+        timeoutMs?: number;
+    }): Promise<AgentResult<PaymentResult>>;
+    /**
+     * Wait for a channel to become ready (ChannelReady state)
+     * Useful after opening a channel — waits for on-chain confirmation.
+     */
+    waitForChannelReady(channelId: string, options?: {
+        /** Timeout in ms (default: 300000 = 5 min) */
+        timeoutMs?: number;
+    }): Promise<AgentResult<ChannelSummary>>;
+    /**
+     * Analyze liquidity across all channels
+     * Provides detailed health metrics and recommendations
+     *
+     * @example
+     * ```typescript
+     * const analysis = await fiber.analyzeLiquidity();
+     * console.log(`Health score: ${analysis.data?.channels.averageHealthScore}`);
+     * console.log(analysis.data?.summary);
+     * ```
+     */
+    analyzeLiquidity(): Promise<AgentResult<LiquidityAnalysisResult>>;
+    /**
+     * Check if you have enough liquidity to send a specific amount
+     */
+    canSend(amountCkb: number): Promise<AgentResult<{
+        canSend: boolean;
+        shortfallCkb: number;
+        availableCkb: number;
+        recommendation: string;
+    }>>;
+    /**
+     * Get remaining spending allowance
+     */
+    getSpendingAllowance(): {
+        perTransactionCkb: number;
+        perWindowCkb: number;
+    };
+    /**
+     * Get audit log
+     */
+    getAuditLog(options?: {
+        limit?: number;
+        since?: number;
+    }): _fiber_pay_sdk.AuditLogEntry[];
+    private ensureInitialized;
+    private getRpc;
+    private waitForRuntimeJobTerminal;
+    /**
+     * Map RPC CkbInvoiceStatus to agent-level status string
+     */
+    private mapInvoiceStatus;
+    private getInvoiceExpiryIso;
+    private getAttributeU64;
+    private errorResult;
+}
+/**
+ * Create a FiberPay instance with sensible defaults
+ * Binary will be auto-downloaded if not provided
+ */
+declare function createFiberPay(options?: {
+    /** Path to the fnn binary (optional - will auto-download if not provided) */
+    binaryPath?: string;
+    /** Base directory for data */
+    dataDir?: string;
+    /** Path to the config file (optional - will use built-in testnet config if not provided) */
+    configFilePath?: string;
+    /** Network: testnet or mainnet */
+    network?: 'testnet' | 'mainnet';
+    /** Chain: testnet or mainnet (alias for network) */
+    chain?: 'testnet' | 'mainnet';
+    /** Auto-download binary if not found (default: true) */
+    autoDownload?: boolean;
+    /** Auto-start the Fiber node on initialize (default: true) */
+    autoStart?: boolean;
+    /** RPC URL to connect to an existing node (overrides autoStart) */
+    rpcUrl?: string;
+    /** Key encryption password */
+    keyPassword?: string;
+}): FiberPay;
+
+/**
+ * Tool definitions for MCP integration
+ * Each tool has:
+ * - name: unique identifier
+ * - description: what the tool does (shown to the LLM)
+ * - inputSchema: JSON Schema for parameters
+ */
+declare const MCP_TOOLS: {
+    readonly fiber_pay: {
+        readonly name: "fiber_pay";
+        readonly description: "Pay an invoice or send CKB directly to a node on the Lightning Network.\n    \nExamples:\n- Pay an invoice: fiber_pay({ invoice: \"fibt1...\" })\n- Send directly: fiber_pay({ recipientNodeId: \"QmXXX...\", amountCkb: 10 })\n\nReturns payment status and tracking hash.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly invoice: {
+                    readonly type: "string";
+                    readonly description: "Lightning invoice string to pay (starts with fibt or fibb)";
+                };
+                readonly recipientNodeId: {
+                    readonly type: "string";
+                    readonly description: "Recipient node ID for direct payment (keysend)";
+                };
+                readonly amountCkb: {
+                    readonly type: "number";
+                    readonly description: "Amount to send in CKB (required for keysend)";
+                };
+                readonly maxFeeCkb: {
+                    readonly type: "number";
+                    readonly description: "Maximum fee willing to pay in CKB";
+                };
+            };
+            readonly oneOf: readonly [{
+                readonly required: readonly ["invoice"];
+            }, {
+                readonly required: readonly ["recipientNodeId", "amountCkb"];
+            }];
+        };
+    };
+    readonly fiber_create_invoice: {
+        readonly name: "fiber_create_invoice";
+        readonly description: "Create an invoice to receive payment.\n    \nExample: fiber_create_invoice({ amountCkb: 10, description: \"For coffee\" })\n\nReturns invoice string to share with payer.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly amountCkb: {
+                    readonly type: "number";
+                    readonly description: "Amount to receive in CKB";
+                };
+                readonly description: {
+                    readonly type: "string";
+                    readonly description: "Description for the payer";
+                };
+                readonly expiryMinutes: {
+                    readonly type: "number";
+                    readonly description: "Invoice expiry time in minutes (default: 60)";
+                };
+            };
+            readonly required: readonly ["amountCkb"];
+        };
+    };
+    readonly fiber_get_balance: {
+        readonly name: "fiber_get_balance";
+        readonly description: "Get current balance information including:\n- Total balance in CKB\n- Available to send\n- Available to receive\n- Number of channels\n- Remaining spending allowance\n\nNo parameters required.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {};
+        };
+    };
+    readonly fiber_get_payment_status: {
+        readonly name: "fiber_get_payment_status";
+        readonly description: "Check the status of a payment by its hash.\n    \nExample: fiber_get_payment_status({ paymentHash: \"0x...\" })";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly paymentHash: {
+                    readonly type: "string";
+                    readonly description: "Payment hash to check";
+                };
+            };
+            readonly required: readonly ["paymentHash"];
+        };
+    };
+    readonly fiber_get_invoice_status: {
+        readonly name: "fiber_get_invoice_status";
+        readonly description: "Check the status of an invoice (whether it's been paid).\n    \nExample: fiber_get_invoice_status({ paymentHash: \"0x...\" })";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly paymentHash: {
+                    readonly type: "string";
+                    readonly description: "Payment hash of the invoice";
+                };
+            };
+            readonly required: readonly ["paymentHash"];
+        };
+    };
+    readonly fiber_list_channels: {
+        readonly name: "fiber_list_channels";
+        readonly description: "List all payment channels with their balances and states.\n\nNo parameters required.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {};
+        };
+    };
+    readonly fiber_open_channel: {
+        readonly name: "fiber_open_channel";
+        readonly description: "Open a new payment channel with a peer.\n    \nExample: fiber_open_channel({ \n  peer: \"/ip4/x.x.x.x/tcp/8228/p2p/QmXXX...\", \n  fundingCkb: 100 \n})\n\nNote: This requires on-chain CKB for funding.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly peer: {
+                    readonly type: "string";
+                    readonly description: "Peer multiaddr or node ID";
+                };
+                readonly fundingCkb: {
+                    readonly type: "number";
+                    readonly description: "Amount of CKB to fund the channel";
+                };
+                readonly isPublic: {
+                    readonly type: "boolean";
+                    readonly description: "Whether to make the channel public (default: true)";
+                };
+            };
+            readonly required: readonly ["peer", "fundingCkb"];
+        };
+    };
+    readonly fiber_close_channel: {
+        readonly name: "fiber_close_channel";
+        readonly description: "Close a payment channel and settle funds on-chain.\n    \nExample: fiber_close_channel({ channelId: \"0x...\" })\n\nUse force: true only if peer is unresponsive.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly channelId: {
+                    readonly type: "string";
+                    readonly description: "Channel ID to close";
+                };
+                readonly force: {
+                    readonly type: "boolean";
+                    readonly description: "Force close (unilateral, use only if peer unresponsive)";
+                };
+            };
+            readonly required: readonly ["channelId"];
+        };
+    };
+    readonly fiber_get_node_info: {
+        readonly name: "fiber_get_node_info";
+        readonly description: "Get information about this node including node ID, public key, and statistics.\n\nNo parameters required.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {};
+        };
+    };
+    readonly fiber_get_spending_allowance: {
+        readonly name: "fiber_get_spending_allowance";
+        readonly description: "Get remaining spending allowance based on security policy.\n\nReturns:\n- Per-transaction limit in CKB\n- Remaining allowance for current time window\n\nNo parameters required.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {};
+        };
+    };
+    readonly fiber_download_binary: {
+        readonly name: "fiber_download_binary";
+        readonly description: "Download and install the Fiber Network Node (fnn) binary for the current platform.\n\nThis is required before using any Fiber payment features. The binary will be automatically \ndownloaded from GitHub releases and installed to the data directory.\n\nExamples:\n- Download latest: fiber_download_binary({})\n- Download specific version: fiber_download_binary({ version: \"v0.4.0\" })\n- Force re-download: fiber_download_binary({ force: true })\n\nReturns the path to the installed binary.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly version: {
+                    readonly type: "string";
+                    readonly description: "Specific version to download (e.g., \"v0.4.0\"). Defaults to latest.";
+                };
+                readonly force: {
+                    readonly type: "boolean";
+                    readonly description: "Force re-download even if binary already exists";
+                };
+            };
+        };
+    };
+    readonly fiber_validate_invoice: {
+        readonly name: "fiber_validate_invoice";
+        readonly description: "Validate an invoice before payment. Checks format, cryptographic correctness, expiry, \namount, and peer connectivity. Returns recommendation to proceed, warn, or reject.\n\nUse this BEFORE paying an invoice to ensure safety.\n\nExample: fiber_validate_invoice({ invoice: \"fibt1...\" })\n\nReturns:\n- valid: boolean (overall validity)\n- details: parsed invoice details (amount, expiry, payment hash)\n- checks: individual validation results (format, expiry, amount, preimage, peer)\n- issues: list of warnings and critical issues found\n- recommendation: 'proceed' | 'warn' | 'reject'\n- reason: human-readable recommendation reason";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly invoice: {
+                    readonly type: "string";
+                    readonly description: "Invoice string to validate (starts with fibt or fibb)";
+                };
+            };
+            readonly required: readonly ["invoice"];
+        };
+    };
+    readonly fiber_get_payment_proof: {
+        readonly name: "fiber_get_payment_proof";
+        readonly description: "Get cryptographic proof of payment execution. Useful for audit trail and reconciliation.\n\nExample: fiber_get_payment_proof({ paymentHash: \"0x...\" })\n\nReturns stored payment proof including:\n- Invoice original\n- Preimage (if available)\n- Fee breakdown\n- Verification status\n- Proof metadata";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly paymentHash: {
+                    readonly type: "string";
+                    readonly description: "Payment hash to retrieve proof for";
+                };
+            };
+            readonly required: readonly ["paymentHash"];
+        };
+    };
+    readonly fiber_analyze_liquidity: {
+        readonly name: "fiber_analyze_liquidity";
+        readonly description: "Comprehensive liquidity analysis across all channels. Provides health metrics,\nidentifies issues, and generates recommendations for rebalancing and funding.\n\nUse this to:\n- Understand current channel health\n- Identify liquidity gaps\n- Get rebalancing recommendations\n- Estimate available runway\n\nNo parameters required.\n\nReturns:\n- balance: total, available to send/receive\n- channels: health metrics for each channel\n- liquidity: gaps and runway estimation\n- recommendations: rebalance suggestions and funding needs\n- summary: human-readable status";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {};
+        };
+    };
+    readonly fiber_can_send: {
+        readonly name: "fiber_can_send";
+        readonly description: "Check if you have enough liquidity to send a specific amount. Returns shortfall \nif insufficient and recommendations.\n\nUse this BEFORE attempting a payment to verify you have enough liquidity.\n\nExample: fiber_can_send({ amountCkb: 100 })\n\nReturns:\n- canSend: boolean\n- shortfallCkb: missing amount (0 if can send)\n- availableCkb: current available balance\n- recommendation: what to do if insufficient";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly amountCkb: {
+                    readonly type: "number";
+                    readonly description: "Amount in CKB to check";
+                };
+            };
+            readonly required: readonly ["amountCkb"];
+        };
+    };
+    readonly fiber_create_hold_invoice: {
+        readonly name: "fiber_create_hold_invoice";
+        readonly description: "Create a hold invoice for escrow or conditional payments.\n    \nA hold invoice locks the payer's funds until you explicitly settle with the preimage,\nor the invoice expires. This enables escrow patterns without a trusted third party.\n\nExample: fiber_create_hold_invoice({ \n  amountCkb: 10, \n  paymentHash: \"0x...\", \n  description: \"Escrow for service delivery\" \n})\n\nFlow:\n1. Generate a secret preimage and compute its SHA-256 hash\n2. Create hold invoice with the hash\n3. Share invoice with payer — their funds are held when they pay\n4. When conditions are met, call fiber_settle_invoice with the preimage\n5. If conditions are NOT met, let the invoice expire (funds return to payer)\n\nReturns invoice string and payment hash.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly amountCkb: {
+                    readonly type: "number";
+                    readonly description: "Amount to receive in CKB";
+                };
+                readonly paymentHash: {
+                    readonly type: "string";
+                    readonly description: "SHA-256 hash of your secret preimage (0x-prefixed hex)";
+                };
+                readonly description: {
+                    readonly type: "string";
+                    readonly description: "Description for the payer";
+                };
+                readonly expiryMinutes: {
+                    readonly type: "number";
+                    readonly description: "Invoice expiry time in minutes (default: 60)";
+                };
+            };
+            readonly required: readonly ["amountCkb", "paymentHash"];
+        };
+    };
+    readonly fiber_settle_invoice: {
+        readonly name: "fiber_settle_invoice";
+        readonly description: "Settle a hold invoice by revealing the preimage.\n    \nThis releases the held funds to you. Only call this after conditions are met.\nThe preimage must hash (SHA-256) to the payment_hash used when creating the hold invoice.\n\nExample: fiber_settle_invoice({ \n  paymentHash: \"0x...\", \n  preimage: \"0x...\" \n})";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly paymentHash: {
+                    readonly type: "string";
+                    readonly description: "Payment hash of the hold invoice";
+                };
+                readonly preimage: {
+                    readonly type: "string";
+                    readonly description: "Secret preimage (0x-prefixed hex, 32 bytes)";
+                };
+            };
+            readonly required: readonly ["paymentHash", "preimage"];
+        };
+    };
+    readonly fiber_wait_for_payment: {
+        readonly name: "fiber_wait_for_payment";
+        readonly description: "Wait for a payment to complete (reach Success or Failed status).\n    \nPolls the payment status until it reaches a terminal state. Useful after sending\na payment to wait for confirmation.\n\nExample: fiber_wait_for_payment({ paymentHash: \"0x...\", timeoutMs: 60000 })\n\nReturns the final payment status.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly paymentHash: {
+                    readonly type: "string";
+                    readonly description: "Payment hash to wait for";
+                };
+                readonly timeoutMs: {
+                    readonly type: "number";
+                    readonly description: "Timeout in milliseconds (default: 120000 = 2 min)";
+                };
+            };
+            readonly required: readonly ["paymentHash"];
+        };
+    };
+    readonly fiber_wait_for_channel_ready: {
+        readonly name: "fiber_wait_for_channel_ready";
+        readonly description: "Wait for a channel to become ready after opening.\n    \nAfter opening a channel, it takes time for the funding transaction to be confirmed\non-chain. This tool polls until the channel reaches ChannelReady state.\n\nExample: fiber_wait_for_channel_ready({ channelId: \"0x...\", timeoutMs: 300000 })\n\nReturns channel info once ready.";
+        readonly inputSchema: {
+            readonly type: "object";
+            readonly properties: {
+                readonly channelId: {
+                    readonly type: "string";
+                    readonly description: "Channel ID to wait for";
+                };
+                readonly timeoutMs: {
+                    readonly type: "number";
+                    readonly description: "Timeout in milliseconds (default: 300000 = 5 min)";
+                };
+            };
+            readonly required: readonly ["channelId"];
+        };
+    };
+};
+type McpToolName = keyof typeof MCP_TOOLS;
+type EmptyInput = Record<string, never>;
+type McpToolInput<T extends McpToolName> = T extends 'fiber_pay' ? {
+    invoice?: string;
+    recipientNodeId?: string;
+    amountCkb?: number;
+    maxFeeCkb?: number;
+    customRecords?: Record<string, string>;
+    maxParts?: number;
+} : T extends 'fiber_create_invoice' ? {
+    amountCkb: number;
+    description?: string;
+    expiryMinutes?: number;
+} : T extends 'fiber_get_balance' ? EmptyInput : T extends 'fiber_get_payment_status' ? {
+    paymentHash: string;
+} : T extends 'fiber_get_invoice_status' ? {
+    paymentHash: string;
+} : T extends 'fiber_list_channels' ? EmptyInput : T extends 'fiber_open_channel' ? {
+    peer: string;
+    fundingCkb: number;
+    isPublic?: boolean;
+} : T extends 'fiber_close_channel' ? {
+    channelId: string;
+    force?: boolean;
+} : T extends 'fiber_get_node_info' ? EmptyInput : T extends 'fiber_get_spending_allowance' ? EmptyInput : T extends 'fiber_download_binary' ? {
+    version?: string;
+    force?: boolean;
+} : T extends 'fiber_validate_invoice' ? {
+    invoice: string;
+} : T extends 'fiber_get_payment_proof' ? {
+    paymentHash: string;
+} : T extends 'fiber_analyze_liquidity' ? EmptyInput : T extends 'fiber_can_send' ? {
+    amountCkb: number;
+} : T extends 'fiber_create_hold_invoice' ? {
+    amountCkb: number;
+    paymentHash: string;
+    description?: string;
+    expiryMinutes?: number;
+} : T extends 'fiber_settle_invoice' ? {
+    paymentHash: string;
+    preimage: string;
+} : T extends 'fiber_wait_for_payment' ? {
+    paymentHash: string;
+    timeoutMs?: number;
+} : T extends 'fiber_wait_for_channel_ready' ? {
+    channelId: string;
+    timeoutMs?: number;
+} : never;
+type McpToolResult<T extends McpToolName> = T extends 'fiber_pay' ? AgentResult<PaymentResult> : T extends 'fiber_create_invoice' ? AgentResult<InvoiceResult> : T extends 'fiber_get_balance' ? AgentResult<BalanceInfo> : T extends 'fiber_get_payment_status' ? AgentResult<PaymentResult> : T extends 'fiber_get_invoice_status' ? AgentResult<InvoiceResult> : T extends 'fiber_list_channels' ? AgentResult<ChannelSummary[]> : T extends 'fiber_open_channel' ? AgentResult<{
+    channelId: string;
+}> : T extends 'fiber_close_channel' ? AgentResult<void> : T extends 'fiber_get_node_info' ? AgentResult<{
+    nodeId: string;
+    publicKey: string;
+    version: string;
+    channelCount: number;
+    peersCount: number;
+}> : T extends 'fiber_get_spending_allowance' ? {
+    perTransactionCkb: number;
+    perWindowCkb: number;
+} : T extends 'fiber_download_binary' ? AgentResult<{
+    path: string;
+    version: string;
+    platform: string;
+    arch: string;
+}> : T extends 'fiber_validate_invoice' ? AgentResult<InvoiceValidationResult> : T extends 'fiber_get_payment_proof' ? AgentResult<{
+    proof: PaymentProof | null;
+    verified: boolean;
+    status: string;
+}> : T extends 'fiber_analyze_liquidity' ? AgentResult<LiquidityAnalysisResult> : T extends 'fiber_can_send' ? AgentResult<{
+    canSend: boolean;
+    shortfallCkb: number;
+    availableCkb: number;
+    recommendation: string;
+}> : T extends 'fiber_create_hold_invoice' ? AgentResult<HoldInvoiceResult> : T extends 'fiber_settle_invoice' ? AgentResult<void> : T extends 'fiber_wait_for_payment' ? AgentResult<PaymentResult> : T extends 'fiber_wait_for_channel_ready' ? AgentResult<ChannelSummary> : never;
+
+export { type AgentResult as A, type BalanceInfo as B, type ChannelSummary as C, FiberPay as F, type HoldInvoiceResult as H, type InvoiceResult as I, MCP_TOOLS, type McpToolInput, type McpToolName, type McpToolResult, type PaymentResult as P, type FiberPayConfig as a, createFiberPay as c };