globodai-mcp-payment-manager 1.0.1

package/dist/tools/add-wallet.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Add a new crypto wallet
+ */
+import { z } from "zod";
+export declare const name = "add_wallet";
+export declare const description = "Add a new crypto wallet. Supports hot wallets (with private key - encrypted), watch-only (address only), and hardware wallets (address + device info).\n\nFor hot wallets: private key will be encrypted at rest.\nFor watch-only: only the address is stored, no spending capability.\nFor hardware: address is stored, transactions require hardware signing.";
+export declare const parameters: z.ZodObject<{
+    nickname: z.ZodString;
+    address: z.ZodString;
+    chain: z.ZodEnum<["ethereum", "polygon", "arbitrum", "optimism", "base", "avalanche", "bsc", "bitcoin", "solana", "starknet"]>;
+    type: z.ZodEnum<["hot", "watch-only", "hardware"]>;
+    private_key: z.ZodOptional<z.ZodString>;
+    mnemonic: z.ZodOptional<z.ZodString>;
+    hardware_type: z.ZodOptional<z.ZodEnum<["ledger", "trezor", "other"]>>;
+    derivation_path: z.ZodOptional<z.ZodString>;
+    allowed_operations: z.ZodOptional<z.ZodArray<z.ZodEnum<["send", "swap", "approve", "sign"]>, "many">>;
+    per_transaction_limit: z.ZodOptional<z.ZodNumber>;
+    daily_limit: z.ZodOptional<z.ZodNumber>;
+    limit_token: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    nickname: string;
+    type: "hot" | "watch-only" | "hardware";
+    address: string;
+    chain: "ethereum" | "polygon" | "arbitrum" | "optimism" | "base" | "avalanche" | "bsc" | "bitcoin" | "solana" | "starknet";
+    per_transaction_limit?: number | undefined;
+    daily_limit?: number | undefined;
+    mnemonic?: string | undefined;
+    private_key?: string | undefined;
+    hardware_type?: "other" | "ledger" | "trezor" | undefined;
+    derivation_path?: string | undefined;
+    allowed_operations?: ("send" | "swap" | "approve" | "sign")[] | undefined;
+    limit_token?: string | undefined;
+}, {
+    nickname: string;
+    type: "hot" | "watch-only" | "hardware";
+    address: string;
+    chain: "ethereum" | "polygon" | "arbitrum" | "optimism" | "base" | "avalanche" | "bsc" | "bitcoin" | "solana" | "starknet";
+    per_transaction_limit?: number | undefined;
+    daily_limit?: number | undefined;
+    mnemonic?: string | undefined;
+    private_key?: string | undefined;
+    hardware_type?: "other" | "ledger" | "trezor" | undefined;
+    derivation_path?: string | undefined;
+    allowed_operations?: ("send" | "swap" | "approve" | "sign")[] | undefined;
+    limit_token?: string | undefined;
+}>;
+export declare function execute(args: z.infer<typeof parameters>): Promise<{
+    success: boolean;
+    error: string;
+    message?: undefined;
+    wallet_id?: undefined;
+    type?: undefined;
+    chain?: undefined;
+    address?: undefined;
+    security_note?: undefined;
+} | {
+    success: boolean;
+    message: string;
+    wallet_id: `${string}-${string}-${string}-${string}-${string}`;
+    type: "hot" | "watch-only" | "hardware";
+    chain: "ethereum" | "polygon" | "arbitrum" | "optimism" | "base" | "avalanche" | "bsc" | "bitcoin" | "solana" | "starknet";
+    address: string;
+    security_note: string;
+    error?: undefined;
+}>;

package/dist/tools/add-wallet.js

@@ -0,0 +1,104 @@
+/**
+ * Add a new crypto wallet
+ */
+import { z } from "zod";
+import { randomUUID } from "crypto";
+import { addWallet } from "../lib/wallets";
+export const name = "add_wallet";
+export const description = `Add a new crypto wallet. Supports hot wallets (with private key - encrypted), watch-only (address only), and hardware wallets (address + device info).
+
+For hot wallets: private key will be encrypted at rest.
+For watch-only: only the address is stored, no spending capability.
+For hardware: address is stored, transactions require hardware signing.`;
+export const parameters = z.object({
+    nickname: z.string().describe("Friendly name for the wallet (e.g., 'ETH principal', 'Trading wallet')"),
+    address: z.string().describe("Public wallet address"),
+    chain: z.enum(["ethereum", "polygon", "arbitrum", "optimism", "base", "avalanche", "bsc", "bitcoin", "solana", "starknet"])
+        .describe("Blockchain network"),
+    type: z.enum(["hot", "watch-only", "hardware"]).describe("Wallet type"),
+    private_key: z.string().optional().describe("Private key (for hot wallets only - will be encrypted)"),
+    mnemonic: z.string().optional().describe("Seed phrase (for hot wallets only - will be encrypted)"),
+    hardware_type: z.enum(["ledger", "trezor", "other"]).optional().describe("Hardware wallet type"),
+    derivation_path: z.string().optional().describe("Derivation path (e.g., m/44'/60'/0'/0/0)"),
+    allowed_operations: z.array(z.enum(["send", "swap", "approve", "sign"])).optional()
+        .describe("Allowed operations (default: all for hot, none for watch-only)"),
+    per_transaction_limit: z.number().optional().describe("Max amount per transaction"),
+    daily_limit: z.number().optional().describe("Max daily spending"),
+    limit_token: z.string().optional().describe("Token symbol for limits (e.g., 'ETH', 'USDC')"),
+});
+export async function execute(args) {
+    try {
+        // Validate based on type
+        if (args.type === "hot" && !args.private_key && !args.mnemonic) {
+            return {
+                success: false,
+                error: "Hot wallets require either a private_key or mnemonic",
+            };
+        }
+        if (args.type === "watch-only" && (args.private_key || args.mnemonic)) {
+            return {
+                success: false,
+                error: "Watch-only wallets cannot have private keys",
+            };
+        }
+        if (args.type === "hardware" && !args.hardware_type) {
+            return {
+                success: false,
+                error: "Hardware wallets must specify hardware_type",
+            };
+        }
+        const walletId = randomUUID();
+        // Default operations based on type
+        let operations = args.allowed_operations;
+        if (!operations) {
+            if (args.type === "hot") {
+                operations = ["send", "swap", "approve", "sign"];
+            }
+            else if (args.type === "hardware") {
+                operations = ["send", "swap", "approve", "sign"]; // Requires hardware confirmation
+            }
+            else {
+                operations = []; // Watch-only can't do anything
+            }
+        }
+        await addWallet({
+            id: walletId,
+            nickname: args.nickname,
+            address: args.address,
+            chain: args.chain,
+            type: args.type,
+            privateKey: args.private_key,
+            mnemonic: args.mnemonic,
+            hardwareType: args.hardware_type,
+            derivationPath: args.derivation_path,
+            enabled: true,
+            allowedOperations: operations,
+            limits: args.per_transaction_limit || args.daily_limit ? {
+                perTransaction: args.per_transaction_limit,
+                daily: args.daily_limit,
+                tokenSymbol: args.limit_token ?? "ETH",
+            } : undefined,
+            addedAt: new Date().toISOString(),
+        });
+        const typeInfo = {
+            hot: "Private key encrypted and stored securely",
+            "watch-only": "Address only - no spending capability",
+            hardware: `${args.hardware_type} wallet - requires device for signing`,
+        };
+        return {
+            success: true,
+            message: `Wallet "${args.nickname}" added successfully`,
+            wallet_id: walletId,
+            type: args.type,
+            chain: args.chain,
+            address: `${args.address.slice(0, 10)}...${args.address.slice(-8)}`,
+            security_note: typeInfo[args.type],
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Failed to add wallet",
+        };
+    }
+}

package/dist/tools/card-status.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Get card lock status
+ */
+import { z } from "zod";
+export declare const name = "card_status";
+export declare const description = "Check if cards are locked or unlocked, and how many cards are saved.";
+export declare const parameters: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare function execute(_args: z.infer<typeof parameters>): Promise<{
+    success: boolean;
+    pin_configured: boolean;
+    cards_unlocked: boolean;
+    remaining_minutes: number | null;
+    saved_cards: number;
+    cards: {
+        nickname: string;
+        type: string;
+        lastFour: string;
+        enabled: boolean;
+    }[];
+}>;

package/dist/tools/card-status.js

@@ -0,0 +1,26 @@
+/**
+ * Get card lock status
+ */
+import { z } from "zod";
+import { getStatus } from "../lib/pin-manager";
+import { getCardsSafe } from "../lib/cards";
+export const name = "card_status";
+export const description = "Check if cards are locked or unlocked, and how many cards are saved.";
+export const parameters = z.object({});
+export async function execute(_args) {
+    const pinStatus = getStatus();
+    const cards = await getCardsSafe();
+    return {
+        success: true,
+        pin_configured: pinStatus.configured,
+        cards_unlocked: pinStatus.unlocked,
+        remaining_minutes: pinStatus.remainingMinutes ?? null,
+        saved_cards: cards.length,
+        cards: cards.map((c) => ({
+            nickname: c.nickname,
+            type: c.cardType.toUpperCase(),
+            lastFour: `****${c.lastFourDigits}`,
+            enabled: c.enabled,
+        })),
+    };
+}

package/dist/tools/confirm-payment.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Confirm and execute a prepared payment
+ *
+ * This is where the actual charge would happen.
+ * CVV is retrieved from encrypted storage (requires PIN unlock).
+ */
+import { z } from "zod";
+export declare const name = "confirm_payment";
+export declare const description = "Confirm and execute a prepared payment. Cards must be unlocked with your PIN. CVV is retrieved from secure storage.";
+export declare const parameters: z.ZodObject<{
+    transaction_id: z.ZodString;
+    confirm: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    confirm: boolean;
+    transaction_id: string;
+}, {
+    confirm: boolean;
+    transaction_id: string;
+}>;
+export declare function execute(args: z.infer<typeof parameters>): Promise<{
+    success: boolean;
+    error: string;
+    status?: undefined;
+    transaction_id?: undefined;
+    message?: undefined;
+    summary?: undefined;
+    note?: undefined;
+    next_steps?: undefined;
+} | {
+    success: boolean;
+    status: string;
+    transaction_id: string;
+    message: string;
+    summary: {
+        card: string;
+        amount: string;
+        type: "flight" | "train" | "hotel" | "general";
+        description: string;
+        provider: string;
+    };
+    note: string;
+    next_steps: string[];
+    error?: undefined;
+}>;

package/dist/tools/confirm-payment.js

@@ -0,0 +1,88 @@
+/**
+ * Confirm and execute a prepared payment
+ *
+ * This is where the actual charge would happen.
+ * CVV is retrieved from encrypted storage (requires PIN unlock).
+ */
+import { z } from "zod";
+import { getCard, getCardCvv, getTransactions, updateTransaction, updateCardUsage } from "../lib/cards";
+import { isUnlocked } from "../lib/pin-manager";
+export const name = "confirm_payment";
+export const description = "Confirm and execute a prepared payment. Cards must be unlocked with your PIN. CVV is retrieved from secure storage.";
+export const parameters = z.object({
+    transaction_id: z.string().describe("ID of the pending transaction to confirm"),
+    confirm: z.boolean().describe("Must be true to confirm you want to proceed with the charge"),
+});
+export async function execute(args) {
+    if (!args.confirm) {
+        return {
+            success: false,
+            error: "You must set confirm=true to proceed with the payment",
+        };
+    }
+    // Check cards are unlocked
+    if (!isUnlocked()) {
+        return {
+            success: false,
+            error: "Cards are locked. Use unlock_cards with your PIN first.",
+        };
+    }
+    // Find the pending transaction
+    const transactions = await getTransactions(100);
+    const tx = transactions.find((t) => t.id === args.transaction_id);
+    if (!tx) {
+        return {
+            success: false,
+            error: "Transaction not found",
+        };
+    }
+    if (tx.status !== "pending") {
+        return {
+            success: false,
+            error: `Transaction is already ${tx.status}`,
+        };
+    }
+    // Get the card
+    const card = await getCard(tx.cardId);
+    if (!card) {
+        return {
+            success: false,
+            error: "Card no longer exists",
+        };
+    }
+    // Get CVV from encrypted storage
+    const cvv = await getCardCvv(tx.cardId);
+    if (!cvv) {
+        return {
+            success: false,
+            error: "Could not retrieve CVV. Make sure cards are unlocked.",
+        };
+    }
+    // Here we would integrate with actual payment providers
+    // CVV is available in `cvv` variable for the API call
+    // For now, we mark as confirmed and return what would be needed
+    await updateTransaction(tx.id, {
+        status: "confirmed",
+        confirmedAt: new Date().toISOString(),
+    });
+    await updateCardUsage(card.id);
+    return {
+        success: true,
+        status: "confirmed",
+        transaction_id: tx.id,
+        message: `Payment of ${tx.amount} ${tx.currency} confirmed`,
+        summary: {
+            card: `${card.nickname} (****${card.lastFourDigits})`,
+            amount: `${tx.amount} ${tx.currency}`,
+            type: tx.type,
+            description: tx.description,
+            provider: tx.provider,
+        },
+        // In production, this would return actual booking reference
+        note: "Integration with payment provider needed. Transaction marked as confirmed.",
+        next_steps: [
+            "Integrate with Stripe/payment processor for actual charge",
+            "Integrate with booking APIs (Amadeus, Trainline, etc.) for reservations",
+        ],
+    };
+}

package/dist/tools/get-total-balance.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Get consolidated view of all balances
+ */
+import { z } from "zod";
+export declare const name = "get_total_balance";
+export declare const description = "Get a consolidated view of all financial accounts: cards and crypto wallets. Shows individual and total balances.";
+export declare const parameters: z.ZodObject<{
+    include_disabled: z.ZodOptional<z.ZodBoolean>;
+    crypto_only: z.ZodOptional<z.ZodBoolean>;
+    cards_only: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    include_disabled?: boolean | undefined;
+    crypto_only?: boolean | undefined;
+    cards_only?: boolean | undefined;
+}, {
+    include_disabled?: boolean | undefined;
+    crypto_only?: boolean | undefined;
+    cards_only?: boolean | undefined;
+}>;
+export declare function execute(args: z.infer<typeof parameters>): Promise<{
+    success: boolean;
+    summary: {
+        totalAccounts: number;
+        cards: number;
+        wallets: number;
+        errors: number;
+        totalCryptoUsd: string | null;
+        note: string | undefined;
+    };
+    accounts: {
+        error?: string | undefined;
+        id: string;
+        type: "wallet" | "card";
+        name: string;
+        chain: string | undefined;
+        balance: string;
+        currency: string | undefined;
+        usdValue: string | null;
+        status: "error" | "active" | "disabled";
+    }[];
+}>;

package/dist/tools/get-total-balance.js

@@ -0,0 +1,98 @@
+/**
+ * Get consolidated view of all balances
+ */
+import { z } from "zod";
+import { getCardsSafe } from "../lib/cards";
+import { getWalletsSafe } from "../lib/wallets";
+import { getWalletBalance, getUsdPrice } from "../lib/blockchain";
+export const name = "get_total_balance";
+export const description = "Get a consolidated view of all financial accounts: cards and crypto wallets. Shows individual and total balances.";
+export const parameters = z.object({
+    include_disabled: z.boolean().optional().describe("Include disabled accounts (default: false)"),
+    crypto_only: z.boolean().optional().describe("Only show crypto wallets"),
+    cards_only: z.boolean().optional().describe("Only show payment cards"),
+});
+export async function execute(args) {
+    const includeDisabled = args.include_disabled ?? false;
+    const items = [];
+    let totalUsdValue = 0;
+    // Get cards (if not crypto_only)
+    if (!args.crypto_only) {
+        const cards = await getCardsSafe();
+        const filteredCards = includeDisabled ? cards : cards.filter(c => c.enabled);
+        for (const card of filteredCards) {
+            items.push({
+                id: card.id,
+                type: "card",
+                name: `${card.nickname} (****${card.lastFourDigits})`,
+                currency: card.limits?.currency || "EUR",
+                balance: "N/A", // Requires bank integration
+                status: card.enabled ? "active" : "disabled",
+            });
+        }
+    }
+    // Get wallets (if not cards_only)
+    if (!args.cards_only) {
+        const wallets = await getWalletsSafe();
+        const filteredWallets = includeDisabled ? wallets : wallets.filter(w => w.enabled);
+        // Fetch balances in parallel
+        const balancePromises = filteredWallets.map(async (wallet) => {
+            try {
+                const balance = await getWalletBalance(wallet.address, wallet.chain);
+                const price = await getUsdPrice(balance.nativeCurrency);
+                const usdValue = price ? parseFloat(balance.nativeBalanceFormatted) * price : undefined;
+                if (usdValue) {
+                    totalUsdValue += usdValue;
+                }
+                return {
+                    id: wallet.id,
+                    type: "wallet",
+                    name: wallet.nickname,
+                    chain: wallet.chain,
+                    balance: balance.nativeBalanceFormatted,
+                    currency: balance.nativeCurrency,
+                    usdValue,
+                    status: wallet.enabled ? "active" : "disabled",
+                };
+            }
+            catch (err) {
+                return {
+                    id: wallet.id,
+                    type: "wallet",
+                    name: wallet.nickname,
+                    chain: wallet.chain,
+                    status: "error",
+                    error: err instanceof Error ? err.message : "Failed to fetch balance",
+                };
+            }
+        });
+        const walletResults = await Promise.all(balancePromises);
+        items.push(...walletResults);
+    }
+    // Separate by type for summary
+    const cardItems = items.filter(i => i.type === "card");
+    const walletItems = items.filter(i => i.type === "wallet");
+    const errorItems = items.filter(i => i.status === "error");
+    return {
+        success: true,
+        summary: {
+            totalAccounts: items.length,
+            cards: cardItems.length,
+            wallets: walletItems.length,
+            errors: errorItems.length,
+            totalCryptoUsd: totalUsdValue > 0 ? `$${totalUsdValue.toFixed(2)}` : null,
+            note: cardItems.length > 0 ? "Card balances require bank integration (Plaid/Tink)" : undefined,
+        },
+        accounts: items.map(item => ({
+            id: item.id,
+            type: item.type,
+            name: item.name,
+            chain: item.chain,
+            balance: item.balance || "N/A",
+            currency: item.currency,
+            usdValue: item.usdValue ? `$${item.usdValue.toFixed(2)}` : null,
+            status: item.status,
+            ...(item.error && { error: item.error }),
+        })),
+    };
+}

package/dist/tools/get-transactions.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Get transaction history
+ */
+import { z } from "zod";
+export declare const name = "get_transactions";
+export declare const description = "Get payment transaction history. Shows all bookings and payments made through the system.";
+export declare const parameters: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodOptional<z.ZodEnum<["pending", "confirmed", "completed", "failed", "refunded"]>>;
+    type: z.ZodOptional<z.ZodEnum<["flight", "train", "hotel", "other"]>>;
+}, "strip", z.ZodTypeAny, {
+    type?: "other" | "flight" | "train" | "hotel" | undefined;
+    status?: "pending" | "confirmed" | "completed" | "failed" | "refunded" | undefined;
+    limit?: number | undefined;
+}, {
+    type?: "other" | "flight" | "train" | "hotel" | undefined;
+    status?: "pending" | "confirmed" | "completed" | "failed" | "refunded" | undefined;
+    limit?: number | undefined;
+}>;
+export declare function execute(args: z.infer<typeof parameters>): Promise<{
+    success: boolean;
+    transactions: never[];
+    message: string;
+    count?: undefined;
+} | {
+    success: boolean;
+    count: number;
+    transactions: {
+        id: string;
+        type: "flight" | "train" | "hotel" | "general";
+        amount: string;
+        description: string;
+        provider: string;
+        status: "pending" | "confirmed" | "completed" | "failed" | "refunded";
+        reference: string;
+        date: string;
+    }[];
+    message?: undefined;
+}>;

package/dist/tools/get-transactions.js

@@ -0,0 +1,40 @@
+/**
+ * Get transaction history
+ */
+import { z } from "zod";
+import { getTransactions } from "../lib/cards";
+export const name = "get_transactions";
+export const description = "Get payment transaction history. Shows all bookings and payments made through the system.";
+export const parameters = z.object({
+    limit: z.number().optional().describe("Number of transactions to return (default: 20)"),
+    status: z.enum(["pending", "confirmed", "completed", "failed", "refunded"]).optional()
+        .describe("Filter by transaction status"),
+    type: z.enum(["flight", "train", "hotel", "other"]).optional()
+        .describe("Filter by transaction type"),
+});
+export async function execute(args) {
+    let transactions = await getTransactions(args.limit ?? 20);
+    if (args.status) {
+        transactions = transactions.filter((t) => t.status === args.status);
+    }
+    if (args.type) {
+        transactions = transactions.filter((t) => t.type === args.type);
+    }
+    if (transactions.length === 0) {
+        return { success: true, transactions: [], message: "No transactions found" };
+    }
+    return {
+        success: true,
+        count: transactions.length,
+        transactions: transactions.map((t) => ({
+            id: t.id,
+            type: t.type,
+            amount: `${t.amount} ${t.currency}`,
+            description: t.description,
+            provider: t.provider,
+            status: t.status,
+            reference: t.reference ?? "N/A",
+            date: t.createdAt,
+        })),
+    };
+}

package/dist/tools/get-wallet-balance.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Get wallet balance via blockchain API
+ */
+import { z } from "zod";
+import { type Chain } from "../lib/wallets";
+export declare const name = "get_wallet_balance";
+export declare const description = "Get the current balance of a crypto wallet. Fetches live data from the blockchain.";
+export declare const parameters: z.ZodObject<{
+    wallet_id: z.ZodOptional<z.ZodString>;
+    address: z.ZodOptional<z.ZodString>;
+    chain: z.ZodOptional<z.ZodEnum<["ethereum", "polygon", "arbitrum", "optimism", "base", "avalanche", "bsc", "bitcoin", "solana", "starknet"]>>;
+    include_usd: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    address?: string | undefined;
+    chain?: "ethereum" | "polygon" | "arbitrum" | "optimism" | "base" | "avalanche" | "bsc" | "bitcoin" | "solana" | "starknet" | undefined;
+    wallet_id?: string | undefined;
+    include_usd?: boolean | undefined;
+}, {
+    address?: string | undefined;
+    chain?: "ethereum" | "polygon" | "arbitrum" | "optimism" | "base" | "avalanche" | "bsc" | "bitcoin" | "solana" | "starknet" | undefined;
+    wallet_id?: string | undefined;
+    include_usd?: boolean | undefined;
+}>;
+export declare function execute(args: z.infer<typeof parameters>): Promise<{
+    success: boolean;
+    error: string;
+    wallet?: undefined;
+    balance?: undefined;
+} | {
+    success: boolean;
+    wallet: {
+        address: string;
+        fullAddress: string;
+        chain: Chain;
+    };
+    balance: {
+        native: string;
+        currency: string;
+        raw: string;
+        usdValue: string | null;
+    };
+    error?: undefined;
+}>;