globodai-mcp-payment-manager 1.0.1

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

@@ -0,0 +1,69 @@
+/**
+ * Get wallet balance via blockchain API
+ */
+import { z } from "zod";
+import { getWallet } from "../lib/wallets";
+import { getWalletBalance, getUsdPrice } from "../lib/blockchain";
+export const name = "get_wallet_balance";
+export const description = "Get the current balance of a crypto wallet. Fetches live data from the blockchain.";
+export const parameters = z.object({
+    wallet_id: z.string().optional().describe("Wallet ID (use list_wallets to see available wallets)"),
+    address: z.string().optional().describe("Wallet address (alternative to wallet_id)"),
+    chain: z.enum(["ethereum", "polygon", "arbitrum", "optimism", "base", "avalanche", "bsc", "bitcoin", "solana", "starknet"]).optional()
+        .describe("Blockchain (required if using address)"),
+    include_usd: z.boolean().optional().describe("Include USD value conversion (default: true)"),
+});
+export async function execute(args) {
+    let address;
+    let chain;
+    // Get wallet by ID or use provided address
+    if (args.wallet_id) {
+        const wallet = await getWallet(args.wallet_id);
+        if (!wallet) {
+            return { success: false, error: `Wallet not found: ${args.wallet_id}` };
+        }
+        address = wallet.address;
+        chain = wallet.chain;
+    }
+    else if (args.address && args.chain) {
+        address = args.address;
+        chain = args.chain;
+    }
+    else {
+        return {
+            success: false,
+            error: "Provide either wallet_id or both address and chain"
+        };
+    }
+    try {
+        const balance = await getWalletBalance(address, chain);
+        // Get USD price if requested
+        let usdValue = null;
+        if (args.include_usd !== false) {
+            const price = await getUsdPrice(balance.nativeCurrency);
+            if (price) {
+                usdValue = parseFloat(balance.nativeBalanceFormatted) * price;
+            }
+        }
+        return {
+            success: true,
+            wallet: {
+                address: `${address.slice(0, 10)}...${address.slice(-8)}`,
+                fullAddress: address,
+                chain,
+            },
+            balance: {
+                native: balance.nativeBalanceFormatted,
+                currency: balance.nativeCurrency,
+                raw: balance.nativeBalance,
+                usdValue: usdValue ? `$${usdValue.toFixed(2)}` : null,
+            },
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: `Failed to fetch balance: ${err instanceof Error ? err.message : err}`,
+        };
+    }
+}

package/dist/tools/list-cards.d.ts

@@ -0,0 +1,36 @@
+/**
+ * List saved payment cards (safe view - no full card numbers)
+ */
+import { z } from "zod";
+export declare const name = "list_cards";
+export declare const description = "List all saved payment cards. Shows card type, last 4 digits, nickname, and allowed usage. Does NOT show full card numbers.";
+export declare const parameters: z.ZodObject<{
+    enabled_only: z.ZodOptional<z.ZodBoolean>;
+    usage_type: z.ZodOptional<z.ZodEnum<["flight", "train", "hotel", "general", "all"]>>;
+}, "strip", z.ZodTypeAny, {
+    enabled_only?: boolean | undefined;
+    usage_type?: "flight" | "train" | "hotel" | "general" | "all" | undefined;
+}, {
+    enabled_only?: boolean | undefined;
+    usage_type?: "flight" | "train" | "hotel" | "general" | "all" | undefined;
+}>;
+export declare function execute(args: z.infer<typeof parameters>): Promise<{
+    success: boolean;
+    cards: never[];
+    message: string;
+    count?: undefined;
+} | {
+    success: boolean;
+    count: number;
+    cards: {
+        id: string;
+        nickname: string;
+        type: string;
+        lastFour: string;
+        cardholder: string;
+        usage: string;
+        enabled: boolean;
+        lastUsed: string;
+    }[];
+    message?: undefined;
+}>;

package/dist/tools/list-cards.js

@@ -0,0 +1,39 @@
+/**
+ * List saved payment cards (safe view - no full card numbers)
+ */
+import { z } from "zod";
+import { getCardsSafe } from "../lib/cards";
+export const name = "list_cards";
+export const description = "List all saved payment cards. Shows card type, last 4 digits, nickname, and allowed usage. Does NOT show full card numbers.";
+export const parameters = z.object({
+    enabled_only: z.boolean().optional().describe("Only show enabled cards"),
+    usage_type: z.enum(["flight", "train", "hotel", "general", "all"]).optional().describe("Filter by allowed usage type"),
+});
+export async function execute(args) {
+    const cards = await getCardsSafe();
+    let filtered = cards;
+    if (args.enabled_only) {
+        filtered = filtered.filter((c) => c.enabled);
+    }
+    if (args.usage_type) {
+        filtered = filtered.filter((c) => c.allowedUsage.includes(args.usage_type) || c.allowedUsage.includes("all"));
+    }
+    if (filtered.length === 0) {
+        return { success: true, cards: [], message: "No cards found" };
+    }
+    const summary = filtered.map((c) => ({
+        id: c.id,
+        nickname: c.nickname,
+        type: c.cardType.toUpperCase(),
+        lastFour: `****${c.lastFourDigits}`,
+        cardholder: c.cardholderName,
+        usage: c.allowedUsage.join(", "),
+        enabled: c.enabled,
+        lastUsed: c.lastUsedAt ?? "Never",
+    }));
+    return {
+        success: true,
+        count: summary.length,
+        cards: summary,
+    };
+}

package/dist/tools/list-wallet-transactions.d.ts

@@ -0,0 +1,63 @@
+/**
+ * List wallet transactions from blockchain
+ */
+import { z } from "zod";
+import { type Chain } from "../lib/wallets";
+export declare const name = "list_wallet_transactions";
+export declare const description = "List recent transactions for a crypto wallet. Fetches live data from blockchain explorers.";
+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"]>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    address?: string | undefined;
+    chain?: "ethereum" | "polygon" | "arbitrum" | "optimism" | "base" | "avalanche" | "bsc" | "bitcoin" | "solana" | "starknet" | undefined;
+    wallet_id?: string | undefined;
+    limit?: number | undefined;
+}, {
+    address?: string | undefined;
+    chain?: "ethereum" | "polygon" | "arbitrum" | "optimism" | "base" | "avalanche" | "bsc" | "bitcoin" | "solana" | "starknet" | undefined;
+    wallet_id?: string | undefined;
+    limit?: number | undefined;
+}>;
+export declare function execute(args: z.infer<typeof parameters>): Promise<{
+    success: boolean;
+    error: string;
+    wallet?: undefined;
+    transactions?: undefined;
+    message?: undefined;
+    count?: undefined;
+} | {
+    success: boolean;
+    wallet: {
+        address: string;
+        chain: Chain;
+        fullAddress?: undefined;
+    };
+    transactions: never[];
+    message: string;
+    error?: undefined;
+    count?: undefined;
+} | {
+    success: boolean;
+    wallet: {
+        address: string;
+        fullAddress: string;
+        chain: Chain;
+    };
+    count: number;
+    transactions: {
+        hash: string;
+        fullHash: string;
+        type: string;
+        amount: string;
+        from: string;
+        to: string;
+        status: "pending" | "failed" | "success";
+        date: string;
+        fee: string | null;
+    }[];
+    error?: undefined;
+    message?: undefined;
+}>;

package/dist/tools/list-wallet-transactions.js

@@ -0,0 +1,76 @@
+/**
+ * List wallet transactions from blockchain
+ */
+import { z } from "zod";
+import { getWallet } from "../lib/wallets";
+import { getWalletTransactions } from "../lib/blockchain";
+export const name = "list_wallet_transactions";
+export const description = "List recent transactions for a crypto wallet. Fetches live data from blockchain explorers.";
+export const parameters = z.object({
+    wallet_id: z.string().optional().describe("Wallet ID (use list_wallets to see available wallets)"),
+    address: z.string().optional().describe("Wallet address (alternative to wallet_id)"),
+    chain: z.enum(["ethereum", "polygon", "arbitrum", "optimism", "base", "avalanche", "bsc", "bitcoin", "solana", "starknet"]).optional()
+        .describe("Blockchain (required if using address)"),
+    limit: z.number().optional().describe("Number of transactions to return (default: 20, max: 50)"),
+});
+export async function execute(args) {
+    let address;
+    let chain;
+    // Get wallet by ID or use provided address
+    if (args.wallet_id) {
+        const wallet = await getWallet(args.wallet_id);
+        if (!wallet) {
+            return { success: false, error: `Wallet not found: ${args.wallet_id}` };
+        }
+        address = wallet.address;
+        chain = wallet.chain;
+    }
+    else if (args.address && args.chain) {
+        address = args.address;
+        chain = args.chain;
+    }
+    else {
+        return {
+            success: false,
+            error: "Provide either wallet_id or both address and chain"
+        };
+    }
+    const limit = Math.min(args.limit ?? 20, 50);
+    try {
+        const transactions = await getWalletTransactions(address, chain, limit);
+        if (transactions.length === 0) {
+            return {
+                success: true,
+                wallet: { address: `${address.slice(0, 10)}...${address.slice(-8)}`, chain },
+                transactions: [],
+                message: "No transactions found",
+            };
+        }
+        return {
+            success: true,
+            wallet: {
+                address: `${address.slice(0, 10)}...${address.slice(-8)}`,
+                fullAddress: address,
+                chain,
+            },
+            count: transactions.length,
+            transactions: transactions.map((tx) => ({
+                hash: `${tx.hash.slice(0, 10)}...${tx.hash.slice(-8)}`,
+                fullHash: tx.hash,
+                type: tx.isIncoming ? "RECEIVED" : "SENT",
+                amount: tx.valueFormatted,
+                from: tx.from ? `${tx.from.slice(0, 8)}...` : "N/A",
+                to: tx.to ? `${tx.to.slice(0, 8)}...` : "N/A",
+                status: tx.status,
+                date: new Date(tx.timestamp).toISOString(),
+                fee: tx.fee || null,
+            })),
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: `Failed to fetch transactions: ${err instanceof Error ? err.message : err}`,
+        };
+    }
+}

package/dist/tools/list-wallets.d.ts

@@ -0,0 +1,41 @@
+/**
+ * List saved crypto wallets (safe view - no private keys)
+ */
+import { z } from "zod";
+export declare const name = "list_wallets";
+export declare const description = "List all saved crypto wallets. Shows address, chain, type, and allowed operations. Does NOT show private keys.";
+export declare const parameters: z.ZodObject<{
+    chain: z.ZodOptional<z.ZodEnum<["ethereum", "polygon", "arbitrum", "optimism", "base", "avalanche", "bsc", "bitcoin", "solana", "starknet"]>>;
+    type: z.ZodOptional<z.ZodEnum<["hot", "watch-only", "hardware"]>>;
+    enabled_only: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type?: "hot" | "watch-only" | "hardware" | undefined;
+    enabled_only?: boolean | undefined;
+    chain?: "ethereum" | "polygon" | "arbitrum" | "optimism" | "base" | "avalanche" | "bsc" | "bitcoin" | "solana" | "starknet" | undefined;
+}, {
+    type?: "hot" | "watch-only" | "hardware" | undefined;
+    enabled_only?: boolean | undefined;
+    chain?: "ethereum" | "polygon" | "arbitrum" | "optimism" | "base" | "avalanche" | "bsc" | "bitcoin" | "solana" | "starknet" | undefined;
+}>;
+export declare function execute(args: z.infer<typeof parameters>): Promise<{
+    success: boolean;
+    wallets: never[];
+    message: string;
+    count?: undefined;
+} | {
+    success: boolean;
+    count: number;
+    wallets: {
+        id: string;
+        nickname: string;
+        chain: string;
+        nativeCurrency: string;
+        address: string;
+        fullAddress: string;
+        type: import("../lib/wallets").WalletType;
+        operations: string;
+        enabled: boolean;
+        lastUsed: string;
+    }[];
+    message?: undefined;
+}>;

package/dist/tools/list-wallets.js

@@ -0,0 +1,50 @@
+/**
+ * List saved crypto wallets (safe view - no private keys)
+ */
+import { z } from "zod";
+import { getWalletsSafe, CHAIN_CONFIG } from "../lib/wallets";
+export const name = "list_wallets";
+export const description = "List all saved crypto wallets. Shows address, chain, type, and allowed operations. Does NOT show private keys.";
+export const parameters = z.object({
+    chain: z.enum(["ethereum", "polygon", "arbitrum", "optimism", "base", "avalanche", "bsc", "bitcoin", "solana", "starknet"]).optional()
+        .describe("Filter by blockchain"),
+    type: z.enum(["hot", "watch-only", "hardware"]).optional()
+        .describe("Filter by wallet type"),
+    enabled_only: z.boolean().optional().describe("Only show enabled wallets"),
+});
+export async function execute(args) {
+    const wallets = await getWalletsSafe();
+    let filtered = wallets;
+    if (args.chain) {
+        filtered = filtered.filter((w) => w.chain === args.chain);
+    }
+    if (args.type) {
+        filtered = filtered.filter((w) => w.type === args.type);
+    }
+    if (args.enabled_only) {
+        filtered = filtered.filter((w) => w.enabled);
+    }
+    if (filtered.length === 0) {
+        return { success: true, wallets: [], message: "No wallets found" };
+    }
+    const summary = filtered.map((w) => {
+        const chainInfo = CHAIN_CONFIG[w.chain];
+        return {
+            id: w.id,
+            nickname: w.nickname,
+            chain: chainInfo?.name ?? w.chain,
+            nativeCurrency: chainInfo?.nativeCurrency ?? "?",
+            address: `${w.address.slice(0, 10)}...${w.address.slice(-8)}`,
+            fullAddress: w.address,
+            type: w.type,
+            operations: w.allowedOperations.join(", "),
+            enabled: w.enabled,
+            lastUsed: w.lastUsedAt ?? "Never",
+        };
+    });
+    return {
+        success: true,
+        count: summary.length,
+        wallets: summary,
+    };
+}

package/dist/tools/lock-cards.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Lock cards (clear PIN from memory)
+ */
+import { z } from "zod";
+export declare const name = "lock_cards";
+export declare const description = "Lock your cards immediately. Clears the PIN from memory. You'll need to unlock again to make payments.";
+export declare const parameters: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare function execute(_args: z.infer<typeof parameters>): Promise<{
+    success: boolean;
+    message: string;
+    note?: undefined;
+} | {
+    success: boolean;
+    message: string;
+    note: string;
+}>;

package/dist/tools/lock-cards.js

@@ -0,0 +1,23 @@
+/**
+ * Lock cards (clear PIN from memory)
+ */
+import { z } from "zod";
+import { lock, getStatus } from "../lib/pin-manager";
+export const name = "lock_cards";
+export const description = "Lock your cards immediately. Clears the PIN from memory. You'll need to unlock again to make payments.";
+export const parameters = z.object({});
+export async function execute(_args) {
+    const status = getStatus();
+    if (!status.unlocked) {
+        return {
+            success: true,
+            message: "Cards are already locked",
+        };
+    }
+    lock();
+    return {
+        success: true,
+        message: "Cards locked. PIN cleared from memory.",
+        note: "Use unlock_cards to unlock again when needed.",
+    };
+}

package/dist/tools/prepare-crypto-tx.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Prepare a crypto transaction for confirmation
+ *
+ * Creates a pending transaction that must be signed and broadcast.
+ * For hardware wallets, signing happens on the device.
+ */
+import { z } from "zod";
+export declare const name = "prepare_crypto_tx";
+export declare const description = "Prepare a crypto transaction for signing. This creates a PENDING transaction that must be confirmed with sign_crypto_tx before broadcast.\n\nSupports:\n- Native token transfers (ETH, MATIC, etc.)\n- ERC20/token transfers\n- Contract interactions";
+export declare const parameters: z.ZodObject<{
+    wallet_id: z.ZodString;
+    to: z.ZodString;
+    amount: z.ZodOptional<z.ZodString>;
+    token_address: z.ZodOptional<z.ZodString>;
+    token_symbol: z.ZodOptional<z.ZodString>;
+    data: z.ZodOptional<z.ZodString>;
+    gas_limit: z.ZodOptional<z.ZodString>;
+    max_fee_per_gas: z.ZodOptional<z.ZodString>;
+    max_priority_fee: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    to: string;
+    wallet_id: string;
+    amount?: string | undefined;
+    token_address?: string | undefined;
+    token_symbol?: string | undefined;
+    data?: string | undefined;
+    gas_limit?: string | undefined;
+    max_fee_per_gas?: string | undefined;
+    max_priority_fee?: string | undefined;
+}, {
+    description: string;
+    to: string;
+    wallet_id: string;
+    amount?: string | undefined;
+    token_address?: string | undefined;
+    token_symbol?: string | undefined;
+    data?: string | undefined;
+    gas_limit?: string | undefined;
+    max_fee_per_gas?: string | undefined;
+    max_priority_fee?: string | undefined;
+}>;
+export declare function execute(args: z.infer<typeof parameters>): Promise<{
+    success: boolean;
+    error: string;
+    transaction_id?: undefined;
+    status?: undefined;
+    summary?: undefined;
+    wallet_type?: undefined;
+    next_step?: undefined;
+    warning?: undefined;
+} | {
+    success: boolean;
+    transaction_id: `${string}-${string}-${string}-${string}-${string}`;
+    status: string;
+    summary: {
+        from: string;
+        to: string;
+        amount: string;
+        chain: string;
+        type: "send" | "contract";
+        description: string;
+    };
+    wallet_type: import("../lib/wallets").WalletType;
+    next_step: string;
+    warning: string;
+    error?: undefined;
+}>;

package/dist/tools/prepare-crypto-tx.js

@@ -0,0 +1,93 @@
+/**
+ * Prepare a crypto transaction for confirmation
+ *
+ * Creates a pending transaction that must be signed and broadcast.
+ * For hardware wallets, signing happens on the device.
+ */
+import { z } from "zod";
+import { randomUUID } from "crypto";
+import { getWallet, logCryptoTransaction, CHAIN_CONFIG } from "../lib/wallets";
+export const name = "prepare_crypto_tx";
+export const description = `Prepare a crypto transaction for signing. This creates a PENDING transaction that must be confirmed with sign_crypto_tx before broadcast.
+
+Supports:
+- Native token transfers (ETH, MATIC, etc.)
+- ERC20/token transfers
+- Contract interactions`;
+export const parameters = z.object({
+    wallet_id: z.string().describe("ID of the wallet to send from"),
+    to: z.string().describe("Recipient address"),
+    // Native or token
+    amount: z.string().optional().describe("Amount to send (in human readable units, e.g., '0.5' for 0.5 ETH)"),
+    token_address: z.string().optional().describe("Token contract address (omit for native currency)"),
+    token_symbol: z.string().optional().describe("Token symbol (e.g., 'USDC')"),
+    // Or raw contract call
+    data: z.string().optional().describe("Raw transaction data (hex) for contract calls"),
+    // Gas settings
+    gas_limit: z.string().optional().describe("Gas limit (default: estimated)"),
+    max_fee_per_gas: z.string().optional().describe("Max fee per gas in gwei"),
+    max_priority_fee: z.string().optional().describe("Max priority fee in gwei"),
+    // Description
+    description: z.string().describe("What this transaction is for"),
+});
+export async function execute(args) {
+    // Get wallet
+    const wallet = await getWallet(args.wallet_id);
+    if (!wallet) {
+        return { success: false, error: "Wallet not found" };
+    }
+    if (!wallet.enabled) {
+        return { success: false, error: "Wallet is disabled" };
+    }
+    if (!wallet.allowedOperations.includes("send")) {
+        return { success: false, error: "This wallet is not allowed to send transactions" };
+    }
+    // Validate recipient address (basic check)
+    const chainConfig = CHAIN_CONFIG[wallet.chain];
+    // Determine transaction type
+    let txType = "send";
+    if (args.data) {
+        txType = "contract";
+    }
+    // Create pending transaction
+    const txId = randomUUID();
+    const transaction = {
+        id: txId,
+        walletId: wallet.id,
+        chain: wallet.chain,
+        type: txType,
+        status: "pending",
+        from: wallet.address,
+        to: args.to,
+        value: args.amount,
+        tokenAddress: args.token_address,
+        tokenSymbol: args.token_symbol,
+        gasLimit: args.gas_limit,
+        maxFeePerGas: args.max_fee_per_gas,
+        maxPriorityFeePerGas: args.max_priority_fee,
+        description: args.description,
+        createdAt: new Date().toISOString(),
+    };
+    await logCryptoTransaction(transaction);
+    const amountDisplay = args.token_symbol
+        ? `${args.amount} ${args.token_symbol}`
+        : `${args.amount} ${chainConfig?.nativeCurrency ?? "tokens"}`;
+    return {
+        success: true,
+        transaction_id: txId,
+        status: "pending",
+        summary: {
+            from: `${wallet.nickname} (${wallet.address.slice(0, 10)}...)`,
+            to: `${args.to.slice(0, 10)}...${args.to.slice(-8)}`,
+            amount: amountDisplay,
+            chain: chainConfig?.name ?? wallet.chain,
+            type: txType,
+            description: args.description,
+        },
+        wallet_type: wallet.type,
+        next_step: wallet.type === "hardware"
+            ? "Connect your hardware wallet and call sign_crypto_tx to sign on device"
+            : "Call sign_crypto_tx to sign and broadcast the transaction",
+        warning: "NO TRANSACTION has been broadcast yet. You must sign to proceed.",
+    };
+}

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

@@ -0,0 +1,57 @@
+/**
+ * Prepare a payment for confirmation
+ *
+ * This creates a pending transaction that must be confirmed before execution.
+ * Security: User must explicitly confirm with CVV before any charge.
+ */
+import { z } from "zod";
+export declare const name = "prepare_payment";
+export declare const description = "Prepare a payment for a booking (flight, train, hotel, etc.). This creates a PENDING transaction that must be confirmed with confirm_payment before any charge is made.";
+export declare const parameters: z.ZodObject<{
+    card_id: z.ZodString;
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+    type: z.ZodEnum<["flight", "train", "hotel", "general"]>;
+    description: z.ZodString;
+    provider: z.ZodString;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type: "flight" | "train" | "hotel" | "general";
+    amount: number;
+    currency: string;
+    description: string;
+    provider: string;
+    card_id: string;
+    details?: Record<string, unknown> | undefined;
+}, {
+    type: "flight" | "train" | "hotel" | "general";
+    amount: number;
+    currency: string;
+    description: string;
+    provider: string;
+    card_id: string;
+    details?: Record<string, unknown> | undefined;
+}>;
+export declare function execute(args: z.infer<typeof parameters>): Promise<{
+    success: boolean;
+    error: string;
+    transaction_id?: undefined;
+    status?: undefined;
+    summary?: undefined;
+    next_step?: undefined;
+    warning?: undefined;
+} | {
+    success: boolean;
+    transaction_id: `${string}-${string}-${string}-${string}-${string}`;
+    status: string;
+    summary: {
+        card: string;
+        amount: string;
+        type: "flight" | "train" | "hotel" | "general";
+        description: string;
+        provider: string;
+    };
+    next_step: string;
+    warning: string;
+    error?: undefined;
+}>;