clawdentials-mcp 0.1.0 → 0.7.2

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

@@ -0,0 +1,127 @@
+/**
+ * Cashu Payment Service
+ *
+ * Cashu is a free and open-source ecash protocol built for Bitcoin.
+ * - No KYC required
+ * - Privacy-preserving (ecash tokens are anonymous)
+ * - Lightning Network compatible
+ * - Self-custodial
+ *
+ * @see https://cashu.space
+ * @see https://github.com/cashubtc/cashu-ts
+ */
+export interface CashuProof {
+    id: string;
+    amount: number;
+    secret: string;
+    C: string;
+}
+/**
+ * Configuration status
+ */
+export declare const config: {
+    readonly configured: boolean;
+    readonly mintUrl: string;
+};
+export interface CashuDepositResult {
+    success: boolean;
+    quote?: {
+        quoteId: string;
+        bolt11: string;
+        amount: number;
+        expiresAt?: Date;
+    };
+    error?: string;
+}
+export interface CashuDepositStatus {
+    success: boolean;
+    paid: boolean;
+    proofs?: CashuProof[];
+    error?: string;
+}
+export interface CashuPaymentResult {
+    success: boolean;
+    paid?: boolean;
+    preimage?: string;
+    feePaid?: number;
+    change?: CashuProof[];
+    error?: string;
+}
+export interface CashuSendResult {
+    success: boolean;
+    token?: string;
+    change?: CashuProof[];
+    error?: string;
+}
+/**
+ * Create a deposit request (Lightning invoice)
+ *
+ * Returns a Lightning invoice that, when paid, will mint ecash tokens.
+ * After payment, call checkDepositAndMint to get the proofs.
+ */
+export declare function createDeposit(request: {
+    amount: number;
+    agentId: string;
+    description?: string;
+}): Promise<CashuDepositResult>;
+/**
+ * Check if a deposit was paid and mint the tokens
+ *
+ * Call this after the Lightning invoice has been paid.
+ * Returns the ecash proofs which MUST be stored - they are the money!
+ */
+export declare function checkDepositAndMint(quoteId: string, amount: number): Promise<CashuDepositStatus>;
+/**
+ * Pay a Lightning invoice using ecash proofs
+ *
+ * @param invoice - The Lightning invoice (bolt11) to pay
+ * @param proofs - Ecash proofs to spend
+ * @returns Payment result with preimage and any change proofs
+ */
+export declare function payInvoice(invoice: string, proofs: CashuProof[]): Promise<CashuPaymentResult>;
+/**
+ * Create a Cashu token for sending to another user
+ *
+ * This creates an ecash token string that can be sent off-chain.
+ * The recipient can receive it using receiveToken().
+ */
+export declare function sendToken(amount: number, proofs: CashuProof[]): Promise<CashuSendResult>;
+/**
+ * Receive a Cashu token
+ *
+ * Validates and claims the ecash token, returning new proofs.
+ */
+export declare function receiveToken(token: string): Promise<{
+    success: boolean;
+    proofs?: CashuProof[];
+    amount?: number;
+    error?: string;
+}>;
+/**
+ * Calculate total balance from proofs
+ */
+export declare function calculateBalance(proofs: CashuProof[]): number;
+/**
+ * Check which proofs are still spendable
+ *
+ * Proofs can become spent if:
+ * - They were used in a transaction
+ * - They were double-spent by someone else (if token was shared)
+ */
+export declare function checkProofsSpendable(proofs: CashuProof[]): Promise<{
+    spendable: CashuProof[];
+    spent: CashuProof[];
+}>;
+export declare const cashuService: {
+    config: {
+        readonly configured: boolean;
+        readonly mintUrl: string;
+    };
+    createDeposit: typeof createDeposit;
+    checkDepositAndMint: typeof checkDepositAndMint;
+    payInvoice: typeof payInvoice;
+    sendToken: typeof sendToken;
+    receiveToken: typeof receiveToken;
+    calculateBalance: typeof calculateBalance;
+    checkProofsSpendable: typeof checkProofsSpendable;
+};

package/dist/services/payments/cashu.js

@@ -0,0 +1,248 @@
+/**
+ * Cashu Payment Service
+ *
+ * Cashu is a free and open-source ecash protocol built for Bitcoin.
+ * - No KYC required
+ * - Privacy-preserving (ecash tokens are anonymous)
+ * - Lightning Network compatible
+ * - Self-custodial
+ *
+ * @see https://cashu.space
+ * @see https://github.com/cashubtc/cashu-ts
+ */
+import { CashuWallet, CashuMint, getEncodedToken } from '@cashu/cashu-ts';
+// Default public mint - Minibits is reliable and well-known
+const DEFAULT_MINT_URL = process.env.CASHU_MINT_URL || 'https://mint.minibits.cash/Bitcoin';
+// Wallet instance (lazy initialized)
+let wallet = null;
+/**
+ * Get or create the Cashu wallet instance
+ */
+async function getWallet() {
+    if (!wallet) {
+        const mint = new CashuMint(DEFAULT_MINT_URL);
+        wallet = new CashuWallet(mint);
+        await wallet.loadMint();
+    }
+    return wallet;
+}
+/**
+ * Configuration status
+ */
+export const config = {
+    get configured() {
+        return true; // Cashu works with any public mint, no API key needed
+    },
+    get mintUrl() {
+        return DEFAULT_MINT_URL;
+    },
+};
+/**
+ * Create a deposit request (Lightning invoice)
+ *
+ * Returns a Lightning invoice that, when paid, will mint ecash tokens.
+ * After payment, call checkDepositAndMint to get the proofs.
+ */
+export async function createDeposit(request) {
+    try {
+        const w = await getWallet();
+        // Create a mint quote (Lightning invoice)
+        const quote = await w.createMintQuote(request.amount);
+        return {
+            success: true,
+            quote: {
+                quoteId: quote.quote,
+                bolt11: quote.request, // The Lightning invoice
+                amount: request.amount,
+                expiresAt: quote.expiry ? new Date(quote.expiry * 1000) : undefined,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to create Cashu deposit',
+        };
+    }
+}
+/**
+ * Check if a deposit was paid and mint the tokens
+ *
+ * Call this after the Lightning invoice has been paid.
+ * Returns the ecash proofs which MUST be stored - they are the money!
+ */
+export async function checkDepositAndMint(quoteId, amount) {
+    try {
+        const w = await getWallet();
+        // Check the quote status
+        const quote = await w.checkMintQuote(quoteId);
+        if (quote.state === 'PAID') {
+            // Invoice was paid - mint the proofs
+            const proofs = await w.mintProofs(amount, quoteId);
+            return {
+                success: true,
+                paid: true,
+                proofs: proofs, // Store these! They are the ecash tokens
+            };
+        }
+        else if (quote.state === 'ISSUED') {
+            // Proofs were already minted (shouldn't happen in normal flow)
+            return {
+                success: true,
+                paid: true,
+                proofs: [], // Already minted, proofs were returned before
+            };
+        }
+        else {
+            // Not paid yet
+            return {
+                success: true,
+                paid: false,
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            paid: false,
+            error: error instanceof Error ? error.message : 'Failed to check Cashu deposit',
+        };
+    }
+}
+/**
+ * Pay a Lightning invoice using ecash proofs
+ *
+ * @param invoice - The Lightning invoice (bolt11) to pay
+ * @param proofs - Ecash proofs to spend
+ * @returns Payment result with preimage and any change proofs
+ */
+export async function payInvoice(invoice, proofs) {
+    try {
+        const w = await getWallet();
+        // Get a quote for paying this invoice
+        const meltQuote = await w.createMeltQuote(invoice);
+        // Calculate total proof value
+        const totalProofValue = proofs.reduce((sum, p) => sum + p.amount, 0);
+        const requiredAmount = meltQuote.amount + meltQuote.fee_reserve;
+        if (totalProofValue < requiredAmount) {
+            return {
+                success: false,
+                error: `Insufficient funds: have ${totalProofValue} sats, need ${requiredAmount} sats (${meltQuote.amount} + ${meltQuote.fee_reserve} fee)`,
+            };
+        }
+        // Pay the invoice
+        const result = await w.meltProofs(meltQuote, proofs);
+        const changeAmount = result.change?.reduce((s, p) => s + p.amount, 0) || 0;
+        return {
+            success: true,
+            paid: result.quote.state === 'PAID',
+            preimage: result.quote.payment_preimage || undefined,
+            feePaid: meltQuote.fee_reserve - changeAmount,
+            change: result.change, // Return these to the user's balance
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to pay Lightning invoice',
+        };
+    }
+}
+/**
+ * Create a Cashu token for sending to another user
+ *
+ * This creates an ecash token string that can be sent off-chain.
+ * The recipient can receive it using receiveToken().
+ */
+export async function sendToken(amount, proofs) {
+    try {
+        const w = await getWallet();
+        const result = await w.send(amount, proofs);
+        // Encode the proofs to send as a token string
+        const token = result.send ? getEncodedToken({
+            mint: DEFAULT_MINT_URL,
+            proofs: result.send,
+        }) : undefined;
+        return {
+            success: true,
+            token,
+            change: result.keep,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to create Cashu token',
+        };
+    }
+}
+/**
+ * Receive a Cashu token
+ *
+ * Validates and claims the ecash token, returning new proofs.
+ */
+export async function receiveToken(token) {
+    try {
+        const w = await getWallet();
+        const proofs = await w.receive(token);
+        const amount = proofs.reduce((sum, p) => sum + p.amount, 0);
+        return {
+            success: true,
+            proofs: proofs,
+            amount,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to receive Cashu token',
+        };
+    }
+}
+/**
+ * Calculate total balance from proofs
+ */
+export function calculateBalance(proofs) {
+    return proofs.reduce((sum, p) => sum + p.amount, 0);
+}
+/**
+ * Check which proofs are still spendable
+ *
+ * Proofs can become spent if:
+ * - They were used in a transaction
+ * - They were double-spent by someone else (if token was shared)
+ */
+export async function checkProofsSpendable(proofs) {
+    try {
+        const w = await getWallet();
+        const states = await w.checkProofsStates(proofs);
+        const spendable = [];
+        const spent = [];
+        states.forEach((state, index) => {
+            if (state.state === 'UNSPENT') {
+                spendable.push(proofs[index]);
+            }
+            else {
+                spent.push(proofs[index]);
+            }
+        });
+        return { spendable, spent };
+    }
+    catch (error) {
+        // If we can't check, assume all are spendable
+        return {
+            spendable: proofs,
+            spent: [],
+        };
+    }
+}
+export const cashuService = {
+    config,
+    createDeposit,
+    checkDepositAndMint,
+    payInvoice,
+    sendToken,
+    receiveToken,
+    calculateBalance,
+    checkProofsSpendable,
+};

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

@@ -0,0 +1,84 @@
+/**
+ * CoinRemitter Payment Service - USDT on TRC-20
+ *
+ * Uses CoinRemitter API for USDT deposits and withdrawals.
+ * Docs: https://github.com/CoinRemitter/nodejs-api
+ * Fee: 0.23%
+ */
+import type { Deposit } from '../../types/index.js';
+interface CoinRemitterInvoice {
+    id: string;
+    invoice_id: string;
+    url: string;
+    address: string;
+    total_amount: {
+        USD: string;
+        USDTTRC20: string;
+    };
+    status: string;
+    expire_time: string;
+}
+export interface CoinRemitterPaymentRequest {
+    amount: number;
+    agentId: string;
+    description?: string;
+}
+export interface CoinRemitterPaymentResponse {
+    success: boolean;
+    deposit?: Partial<Deposit>;
+    invoice?: CoinRemitterInvoice;
+    error?: string;
+}
+/**
+ * Create a USDT deposit invoice
+ */
+export declare function createCoinRemitterDeposit(request: CoinRemitterPaymentRequest): Promise<CoinRemitterPaymentResponse>;
+/**
+ * Check invoice status
+ */
+export declare function getInvoiceStatus(invoiceId: string): Promise<{
+    success: boolean;
+    status?: string;
+    paid?: boolean;
+    amount?: number;
+    txId?: string;
+    error?: string;
+}>;
+/**
+ * Process webhook callback from CoinRemitter
+ */
+export declare function parseWebhookPayload(body: Record<string, any>): {
+    invoiceId: string;
+    status: string;
+    amount: number;
+    agentId: string;
+    txId: string | null;
+};
+/**
+ * Send USDT withdrawal
+ */
+export declare function sendCoinRemitterWithdrawal(toAddress: string, amount: number): Promise<{
+    success: boolean;
+    txId?: string;
+    error?: string;
+}>;
+/**
+ * Get wallet balance from CoinRemitter
+ */
+export declare function getWalletBalance(): Promise<{
+    success: boolean;
+    balance?: number;
+    error?: string;
+}>;
+export declare const coinremitterService: {
+    createDeposit: typeof createCoinRemitterDeposit;
+    getInvoiceStatus: typeof getInvoiceStatus;
+    parseWebhookPayload: typeof parseWebhookPayload;
+    sendWithdrawal: typeof sendCoinRemitterWithdrawal;
+    getWalletBalance: typeof getWalletBalance;
+    config: {
+        configured: boolean;
+        webhookUrl: string;
+    };
+};
+export {};

package/dist/services/payments/coinremitter.js

@@ -0,0 +1,176 @@
+/**
+ * CoinRemitter Payment Service - USDT on TRC-20
+ *
+ * Uses CoinRemitter API for USDT deposits and withdrawals.
+ * Docs: https://github.com/CoinRemitter/nodejs-api
+ * Fee: 0.23%
+ */
+// Configuration
+const COINREMITTER_API_KEY = process.env.COINREMITTER_API_KEY || '';
+const COINREMITTER_PASSWORD = process.env.COINREMITTER_PASSWORD || '';
+const COINREMITTER_WEBHOOK_URL = process.env.COINREMITTER_WEBHOOK_URL || '';
+// API base URL
+const API_BASE = 'https://coinremitter.com/api/v3/USDTTRC20';
+/**
+ * Make API request to CoinRemitter
+ */
+async function apiRequest(endpoint, data) {
+    const response = await fetch(`${API_BASE}/${endpoint}`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            api_key: COINREMITTER_API_KEY,
+            password: COINREMITTER_PASSWORD,
+            ...data,
+        }),
+    });
+    const result = await response.json();
+    if (result.flag !== 1) {
+        throw new Error(result.msg || 'CoinRemitter API error');
+    }
+    return result.data;
+}
+/**
+ * Create a USDT deposit invoice
+ */
+export async function createCoinRemitterDeposit(request) {
+    if (!COINREMITTER_API_KEY || !COINREMITTER_PASSWORD) {
+        return {
+            success: false,
+            error: 'CoinRemitter credentials not configured. Set COINREMITTER_API_KEY and COINREMITTER_PASSWORD environment variables.',
+        };
+    }
+    try {
+        const invoiceData = await apiRequest('create-invoice', {
+            amount: request.amount,
+            currency: 'USD', // Amount is in USD, will convert to USDT
+            name: request.agentId,
+            description: request.description || `Deposit for ${request.agentId}`,
+            notify_url: COINREMITTER_WEBHOOK_URL,
+            expire_time: 30, // 30 minutes
+            custom_data1: request.agentId,
+        });
+        const expiresAt = new Date(invoiceData.expire_time);
+        return {
+            success: true,
+            deposit: {
+                id: `cr_${invoiceData.invoice_id}`,
+                agentId: request.agentId,
+                amount: request.amount,
+                currency: 'USDT',
+                network: 'trc20',
+                status: 'pending',
+                provider: 'coinremitter',
+                externalId: invoiceData.invoice_id,
+                paymentAddress: invoiceData.address,
+                paymentUrl: invoiceData.url,
+                createdAt: new Date(),
+                expiresAt,
+                completedAt: null,
+                txHash: null,
+            },
+            invoice: invoiceData,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to create invoice',
+        };
+    }
+}
+/**
+ * Check invoice status
+ */
+export async function getInvoiceStatus(invoiceId) {
+    if (!COINREMITTER_API_KEY || !COINREMITTER_PASSWORD) {
+        return { success: false, error: 'CoinRemitter credentials not configured' };
+    }
+    try {
+        const data = await apiRequest('get-invoice', { invoice_id: invoiceId });
+        return {
+            success: true,
+            status: data.status,
+            paid: data.status === 'Paid',
+            amount: parseFloat(data.paid_amount?.USD || '0'),
+            txId: data.transaction_id,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to get invoice status',
+        };
+    }
+}
+/**
+ * Process webhook callback from CoinRemitter
+ */
+export function parseWebhookPayload(body) {
+    return {
+        invoiceId: body.invoice_id,
+        status: body.status,
+        amount: parseFloat(body.usd_amount || body.coin_amount || '0'),
+        agentId: body.custom_data1,
+        txId: body.transaction_id || null,
+    };
+}
+/**
+ * Send USDT withdrawal
+ */
+export async function sendCoinRemitterWithdrawal(toAddress, amount) {
+    if (!COINREMITTER_API_KEY || !COINREMITTER_PASSWORD) {
+        return { success: false, error: 'CoinRemitter credentials not configured' };
+    }
+    try {
+        const data = await apiRequest('withdraw', {
+            to_address: toAddress,
+            amount: amount,
+            currency: 'USD', // Will convert to USDT equivalent
+        });
+        return {
+            success: true,
+            txId: data.txn_id || data.id,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to send withdrawal',
+        };
+    }
+}
+/**
+ * Get wallet balance from CoinRemitter
+ */
+export async function getWalletBalance() {
+    if (!COINREMITTER_API_KEY || !COINREMITTER_PASSWORD) {
+        return { success: false, error: 'CoinRemitter credentials not configured' };
+    }
+    try {
+        const data = await apiRequest('get-balance', {});
+        return {
+            success: true,
+            balance: parseFloat(data.balance || '0'),
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to get balance',
+        };
+    }
+}
+export const coinremitterService = {
+    createDeposit: createCoinRemitterDeposit,
+    getInvoiceStatus,
+    parseWebhookPayload,
+    sendWithdrawal: sendCoinRemitterWithdrawal,
+    getWalletBalance,
+    config: {
+        configured: !!(COINREMITTER_API_KEY && COINREMITTER_PASSWORD),
+        webhookUrl: COINREMITTER_WEBHOOK_URL,
+    },
+};