@aspect-warden/mcp-server 0.3.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,1045 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { createPublicClient, createWalletClient, http, parseAbi, encodeFunctionData, formatEther, formatUnits, parseUnits, } from 'viem';
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+import { sepolia } from 'viem/chains';
+// ============================================================
+// Configuration from environment
+// ============================================================
+const PROVIDER_URL = process.env.RPC_URL || 'https://rpc.sepolia.org';
+const POLICY_DELEGATE_ADDRESS = process.env.POLICY_DELEGATE_ADDRESS;
+const SEPOLIA_USDT = (process.env.SEPOLIA_USDT_ADDRESS || '0x7169D38820dfd117C3FA1f22a697dBA58d90BA06');
+const ERC8004_IDENTITY_REGISTRY = process.env.ERC8004_IDENTITY_REGISTRY;
+// ============================================================
+// Import from @aspect-warden/policy-engine
+// ============================================================
+import { PolicyEngine, AuditLogger } from '@aspect-warden/policy-engine';
+// ============================================================
+// Contract ABIs
+// ============================================================
+const ERC20_ABI = parseAbi([
+    'function balanceOf(address) view returns (uint256)',
+    'function transfer(address to, uint256 amount) returns (bool)',
+    'function decimals() view returns (uint8)',
+]);
+const POLICY_DELEGATE_ABI = parseAbi([
+    'function createSessionKey(address eoa, address key, uint256 maxPerTx, uint256 dailyLimit, uint48 validAfter, uint48 validUntil, uint256 cooldownSeconds) external',
+    'function revokeSessionKey(address eoa, address key) external',
+]);
+const ERC8004_ABI = parseAbi([
+    'function registerAgent(string name, string[] capabilities) external returns (uint256)',
+    'event AgentRegistered(uint256 indexed agentId, address indexed owner, string name)',
+]);
+// PolicyEngine and AuditLogger imported from @aspect-warden/policy-engine
+// ============================================================
+// MCP Server State
+// ============================================================
+let policyEngine = null;
+let auditLogger = null;
+let walletAddress = null;
+let frozen = false;
+// Wallet key management (private key never exposed via MCP output)
+let storedPrivateKey = null;
+let publicClient = null;
+let walletClient = null;
+const sessionKeys = new Map();
+const permissionGrants = new Map();
+// ============================================================
+// BigInt-safe JSON serializer
+// ============================================================
+function toJSON(value, indent) {
+    return JSON.stringify(value, (_key, v) => typeof v === 'bigint' ? v.toString() : v, indent);
+}
+// ============================================================
+// Client initialization helper
+// ============================================================
+function initializeClients(privateKey) {
+    const account = privateKeyToAccount(privateKey);
+    publicClient = createPublicClient({
+        chain: sepolia,
+        transport: http(PROVIDER_URL),
+    });
+    walletClient = createWalletClient({
+        account,
+        chain: sepolia,
+        transport: http(PROVIDER_URL),
+    });
+    storedPrivateKey = privateKey;
+    walletAddress = account.address;
+}
+function requireWallet() {
+    if (!publicClient || !walletClient || !walletAddress || !storedPrivateKey) {
+        throw new Error('No wallet created. Call warden_create_wallet first.');
+    }
+    return { publicClient, walletClient, address: walletAddress };
+}
+// ============================================================
+// MCP Server Setup
+// ============================================================
+const server = new McpServer({
+    name: 'warden-wallet',
+    version: '0.3.0',
+});
+// ============================================================
+// Tool 1: Create Wallet
+// ============================================================
+server.tool('warden_create_wallet', 'Create a new policy-enforced wallet for the AI agent. Generates a random Ethereum keypair, initializes viem clients for Sepolia, and sets up policy enforcement with spending limits, anomaly detection, and audit logging.', {
+    agentId: z.string().describe('Unique identifier for this agent'),
+    maxPerTx: z.number().describe('Max spend per transaction in USDT (e.g. 100)'),
+    dailyLimit: z.number().describe('Daily spending cap in USDT (e.g. 500)'),
+    approvalThreshold: z.number().describe('Amount above which human approval is needed (e.g. 200)'),
+    cooldownSeconds: z.number().default(30).describe('Min seconds between transactions'),
+}, async ({ agentId, maxPerTx, dailyLimit, approvalThreshold, cooldownSeconds }) => {
+    const privateKey = generatePrivateKey();
+    initializeClients(privateKey);
+    const policy = {
+        agentId,
+        maxPerTx: BigInt(maxPerTx) * 1000000n,
+        dailyLimit: BigInt(dailyLimit) * 1000000n,
+        requireApprovalAbove: BigInt(approvalThreshold) * 1000000n,
+        allowedTokens: [],
+        blockedTokens: [],
+        allowedRecipients: [],
+        blockedRecipients: [],
+        allowedChains: ['ethereum'],
+        cooldownMs: cooldownSeconds * 1000,
+        anomalyDetection: {
+            maxTxPerHour: 20,
+            maxRecipientsPerHour: 5,
+            largeTransactionPct: 50,
+        },
+    };
+    policyEngine = new PolicyEngine(policy);
+    auditLogger = new AuditLogger({ maxEntries: 10000 });
+    frozen = false;
+    return {
+        content: [{
+                type: 'text',
+                text: toJSON({
+                    success: true,
+                    address: walletAddress,
+                    agentId,
+                    chain: 'sepolia',
+                    rpcUrl: PROVIDER_URL,
+                    policy: {
+                        maxPerTx: `${maxPerTx} USDT`,
+                        dailyLimit: `${dailyLimit} USDT`,
+                        approvalThreshold: `${approvalThreshold} USDT`,
+                        cooldownSeconds,
+                    },
+                    note: 'Wallet created with policy enforcement. Fund with test ETH/USDT on Sepolia before sending transactions.',
+                }, 2),
+            }],
+    };
+});
+// ============================================================
+// Tool 2: Get Balance
+// ============================================================
+server.tool('warden_get_balance', 'Check the wallet balance on Sepolia. Returns native ETH balance, or ERC-20 token balance if a token address is provided.', {
+    tokenAddress: z.string().optional().describe('ERC-20 token address. Omit for native ETH.'),
+}, async ({ tokenAddress }) => {
+    let wallet;
+    try {
+        wallet = requireWallet();
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: 'text', text: toJSON({ error: message }) }],
+            isError: true,
+        };
+    }
+    try {
+        if (tokenAddress) {
+            let decimals;
+            try {
+                decimals = await wallet.publicClient.readContract({
+                    address: tokenAddress,
+                    abi: ERC20_ABI,
+                    functionName: 'decimals',
+                });
+            }
+            catch {
+                // Default to 6 decimals (USDT standard) if decimals() call fails
+                decimals = 6;
+            }
+            const tokenBalance = await wallet.publicClient.readContract({
+                address: tokenAddress,
+                abi: ERC20_ABI,
+                functionName: 'balanceOf',
+                args: [wallet.address],
+            });
+            const formatted = formatUnits(tokenBalance, decimals);
+            return {
+                content: [{
+                        type: 'text',
+                        text: toJSON({
+                            address: wallet.address,
+                            tokenAddress,
+                            balance: formatted,
+                            decimals,
+                            rawBalance: tokenBalance.toString(),
+                        }),
+                    }],
+            };
+        }
+        const ethBalance = await wallet.publicClient.getBalance({ address: wallet.address });
+        const formatted = formatEther(ethBalance);
+        return {
+            content: [{
+                    type: 'text',
+                    text: toJSON({
+                        address: wallet.address,
+                        balance: `${formatted} ETH`,
+                        rawBalance: ethBalance.toString(),
+                    }),
+                }],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: 'text', text: toJSON({ error: `Failed to fetch balance: ${message}` }) }],
+            isError: true,
+        };
+    }
+});
+// ============================================================
+// Tool 3: Transfer
+// ============================================================
+server.tool('warden_transfer', 'Send ERC-20 tokens with policy enforcement. Evaluates the transfer against all 10 policy rules including spending limits, cooldowns, and anomaly detection. Submits the transaction on-chain if approved.', {
+    recipient: z.string().describe('Recipient wallet address (0x...)'),
+    amount: z.number().describe('Amount in USDT (e.g. 50 for 50 USDT)'),
+    tokenAddress: z.string().describe('ERC-20 token contract address'),
+}, async ({ recipient, amount, tokenAddress }) => {
+    if (!policyEngine || !auditLogger) {
+        return {
+            content: [{ type: 'text', text: toJSON({ error: 'No wallet created. Call warden_create_wallet first.' }) }],
+            isError: true,
+        };
+    }
+    let wallet;
+    try {
+        wallet = requireWallet();
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: 'text', text: toJSON({ error: message }) }],
+            isError: true,
+        };
+    }
+    if (frozen) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: toJSON({
+                        success: false,
+                        blocked: true,
+                        reason: 'Wallet is frozen. All operations are suspended.',
+                        ruleTriggered: 'frozen',
+                    }),
+                }],
+        };
+    }
+    const valueMicro = BigInt(Math.round(amount * 1e6));
+    const decision = policyEngine.evaluate(recipient, valueMicro, tokenAddress, 'ethereum');
+    auditLogger.log(decision);
+    if (!decision.approved) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: toJSON({
+                        success: false,
+                        blocked: true,
+                        reason: decision.reason,
+                        ruleTriggered: decision.ruleTriggered,
+                        riskScore: decision.riskScore,
+                    }),
+                }],
+        };
+    }
+    try {
+        // ERC-20 transfer: encode transfer(recipient, amount) calldata
+        const transferAmount = parseUnits(amount.toString(), 6);
+        const data = encodeFunctionData({
+            abi: ERC20_ABI,
+            functionName: 'transfer',
+            args: [recipient, transferAmount],
+        });
+        const account = privateKeyToAccount(storedPrivateKey);
+        const hash = await wallet.walletClient.sendTransaction({
+            account,
+            to: tokenAddress,
+            data,
+            chain: sepolia,
+        });
+        const receipt = await wallet.publicClient.waitForTransactionReceipt({ hash });
+        if (receipt.status === 'reverted') {
+            return {
+                content: [{
+                        type: 'text',
+                        text: toJSON({
+                            success: false,
+                            error: 'Transaction reverted on-chain',
+                            txHash: hash,
+                            blockNumber: Number(receipt.blockNumber),
+                        }),
+                    }],
+                isError: true,
+            };
+        }
+        policyEngine.recordTransaction(valueMicro, recipient);
+        auditLogger.log(decision, {
+            hash,
+            blockNumber: Number(receipt.blockNumber),
+            gasUsed: receipt.gasUsed,
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: toJSON({
+                        success: true,
+                        txHash: hash,
+                        blockNumber: Number(receipt.blockNumber),
+                        gasUsed: receipt.gasUsed.toString(),
+                        amount: `${amount} USDT`,
+                        recipient,
+                        riskScore: decision.riskScore,
+                    }),
+                }],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: 'text', text: toJSON({ error: `Transfer failed: ${message}` }) }],
+            isError: true,
+        };
+    }
+});
+// ============================================================
+// Tool 4: Get Policy Status
+// ============================================================
+server.tool('warden_get_policy_status', 'View current spending limits, remaining budget, window reset time, and audit statistics including approved/blocked counts and top block reasons.', {}, async () => {
+    if (!policyEngine || !auditLogger) {
+        return {
+            content: [{ type: 'text', text: toJSON({ error: 'No wallet created. Call warden_create_wallet first.' }) }],
+            isError: true,
+        };
+    }
+    const status = policyEngine.getSpendingStatus();
+    const stats = auditLogger.getStats();
+    return {
+        content: [{
+                type: 'text',
+                text: toJSON({
+                    frozen,
+                    spending: {
+                        spent: `${Number(status.spent) / 1e6} USDT`,
+                        remaining: `${Number(status.remaining) / 1e6} USDT`,
+                        windowResets: new Date(status.windowResets).toISOString(),
+                    },
+                    stats: {
+                        totalTransactions: stats.total,
+                        approved: stats.approved,
+                        blocked: stats.blocked,
+                        topBlockReasons: stats.topBlockReasons,
+                    },
+                    activeSessionKeys: sessionKeys.size,
+                }, 2),
+            }],
+    };
+});
+// ============================================================
+// Tool 5: Get Audit Log
+// ============================================================
+server.tool('warden_get_audit_log', 'View recent transaction history with approve/block decisions, risk scores, and triggered rules. Supports filtering by approval status.', {
+    limit: z.number().default(10).describe('Number of entries to return'),
+    approvedOnly: z.boolean().optional().describe('Filter: true=approved only, false=blocked only, omit=all'),
+}, async ({ limit, approvedOnly }) => {
+    if (!auditLogger) {
+        return {
+            content: [{ type: 'text', text: toJSON({ error: 'No wallet created. Call warden_create_wallet first.' }) }],
+            isError: true,
+        };
+    }
+    const entries = auditLogger.getEntries({ approved: approvedOnly, limit });
+    return {
+        content: [{
+                type: 'text',
+                text: toJSON(entries.map(e => ({
+                    approved: e.approved,
+                    reason: e.reason,
+                    rule: e.ruleTriggered,
+                    riskScore: e.riskScore,
+                    amount: `${Number(e.transactionDetails.value) / 1e6} USDT`,
+                    to: e.transactionDetails.to,
+                    time: new Date(e.timestamp).toISOString(),
+                    txHash: e.txHash,
+                })), 2),
+            }],
+    };
+});
+// ============================================================
+// Tool 6: Update Policy
+// ============================================================
+server.tool('warden_update_policy', 'Modify policy rules at runtime. Can update per-transaction limits, daily limits, and cooldown periods without recreating the wallet.', {
+    maxPerTx: z.number().optional().describe('New max per transaction in USDT'),
+    dailyLimit: z.number().optional().describe('New daily limit in USDT'),
+    cooldownSeconds: z.number().optional().describe('New cooldown in seconds'),
+}, async ({ maxPerTx, dailyLimit, cooldownSeconds }) => {
+    if (!policyEngine) {
+        return {
+            content: [{ type: 'text', text: toJSON({ error: 'No wallet created. Call warden_create_wallet first.' }) }],
+            isError: true,
+        };
+    }
+    const updates = {};
+    const updatedFields = [];
+    if (maxPerTx !== undefined) {
+        updates.maxPerTx = BigInt(maxPerTx) * 1000000n;
+        updatedFields.push('maxPerTx');
+    }
+    if (dailyLimit !== undefined) {
+        updates.dailyLimit = BigInt(dailyLimit) * 1000000n;
+        updatedFields.push('dailyLimit');
+    }
+    if (cooldownSeconds !== undefined) {
+        updates.cooldownMs = cooldownSeconds * 1000;
+        updatedFields.push('cooldownMs');
+    }
+    policyEngine.updatePolicy(updates);
+    return {
+        content: [{
+                type: 'text',
+                text: toJSON({ success: true, updatedFields }),
+            }],
+    };
+});
+// ============================================================
+// Tool 7: Freeze
+// ============================================================
+server.tool('warden_freeze', 'EMERGENCY: Freeze all wallet operations immediately. No transfers will be allowed until unfrozen.', {}, async () => {
+    frozen = true;
+    return {
+        content: [{
+                type: 'text',
+                text: toJSON({
+                    success: true,
+                    frozen: true,
+                    message: 'All wallet operations are now frozen.',
+                }),
+            }],
+    };
+});
+// ============================================================
+// Tool 8: Unfreeze
+// ============================================================
+server.tool('warden_unfreeze', 'Resume wallet operations after an emergency freeze.', {}, async () => {
+    frozen = false;
+    return {
+        content: [{
+                type: 'text',
+                text: toJSON({
+                    success: true,
+                    frozen: false,
+                    message: 'Wallet operations have been resumed.',
+                }),
+            }],
+    };
+});
+// ============================================================
+// Tool 9: Create Session Key (on-chain via PolicyDelegate)
+// ============================================================
+server.tool('warden_create_session_key', 'Create a scoped session key for a sub-agent with its own spending limits and validity period. Requires POLICY_DELEGATE_ADDRESS env var for on-chain EIP-7702 session key creation.', {
+    agentAddress: z.string().describe('Sub-agent wallet address to grant session key to'),
+    maxPerTx: z.number().describe('Max spend per transaction in USDT for this session key'),
+    dailyLimit: z.number().describe('Daily spending cap in USDT for this session key'),
+    validForSeconds: z.number().describe('How long this session key is valid (seconds)'),
+    cooldownSeconds: z.number().describe('Min seconds between transactions for this session key'),
+}, async ({ agentAddress, maxPerTx, dailyLimit, validForSeconds, cooldownSeconds }) => {
+    if (!POLICY_DELEGATE_ADDRESS) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: toJSON({ error: 'On-chain session key creation requires POLICY_DELEGATE_ADDRESS env var to be set.' }),
+                }],
+            isError: true,
+        };
+    }
+    let wallet;
+    try {
+        wallet = requireWallet();
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: 'text', text: toJSON({ error: message }) }],
+            isError: true,
+        };
+    }
+    try {
+        const now = Math.floor(Date.now() / 1000);
+        const maxPerTxWei = BigInt(maxPerTx) * 1000000n;
+        const dailyLimitWei = BigInt(dailyLimit) * 1000000n;
+        const data = encodeFunctionData({
+            abi: POLICY_DELEGATE_ABI,
+            functionName: 'createSessionKey',
+            args: [
+                wallet.address,
+                agentAddress,
+                maxPerTxWei,
+                dailyLimitWei,
+                now,
+                now + validForSeconds,
+                BigInt(cooldownSeconds),
+            ],
+        });
+        const account = privateKeyToAccount(storedPrivateKey);
+        const hash = await wallet.walletClient.sendTransaction({
+            account,
+            to: wallet.address,
+            data,
+            chain: sepolia,
+        });
+        const receipt = await wallet.publicClient.waitForTransactionReceipt({ hash });
+        if (receipt.status === 'reverted') {
+            return {
+                content: [{
+                        type: 'text',
+                        text: toJSON({
+                            success: false,
+                            error: 'Session key creation transaction reverted',
+                            txHash: hash,
+                        }),
+                    }],
+                isError: true,
+            };
+        }
+        const sessionData = {
+            agentAddress,
+            maxPerTx: maxPerTxWei,
+            dailyLimit: dailyLimitWei,
+            validUntil: (now + validForSeconds) * 1000,
+            cooldownSeconds,
+            createdAt: Date.now(),
+            revoked: false,
+            txHash: hash,
+        };
+        sessionKeys.set(agentAddress.toLowerCase(), sessionData);
+        return {
+            content: [{
+                    type: 'text',
+                    text: toJSON({
+                        success: true,
+                        sessionKeyAddress: agentAddress,
+                        grantedTo: agentAddress,
+                        txHash: hash,
+                        blockNumber: Number(receipt.blockNumber),
+                        permissions: {
+                            maxPerTx: `${maxPerTx} USDT`,
+                            dailyLimit: `${dailyLimit} USDT`,
+                            cooldownSeconds,
+                        },
+                        validUntil: new Date(sessionData.validUntil).toISOString(),
+                    }, 2),
+                }],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: 'text', text: toJSON({ error: `Session key creation failed: ${message}` }) }],
+            isError: true,
+        };
+    }
+});
+// ============================================================
+// Tool 10: Revoke Session Key
+// ============================================================
+server.tool('warden_revoke_session_key', 'Revoke a previously created session key, immediately disabling its access. If POLICY_DELEGATE_ADDRESS is set, also revokes on-chain.', {
+    sessionKeyAddress: z.string().describe('Address of the session key to revoke'),
+}, async ({ sessionKeyAddress }) => {
+    const key = sessionKeyAddress.toLowerCase();
+    const session = sessionKeys.get(key);
+    if (!session) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: toJSON({
+                        success: false,
+                        error: `Session key ${sessionKeyAddress} not found.`,
+                    }),
+                }],
+            isError: true,
+        };
+    }
+    if (POLICY_DELEGATE_ADDRESS && publicClient && walletClient && storedPrivateKey) {
+        try {
+            const wallet = requireWallet();
+            const account = privateKeyToAccount(storedPrivateKey);
+            const data = encodeFunctionData({
+                abi: POLICY_DELEGATE_ABI,
+                functionName: 'revokeSessionKey',
+                args: [wallet.address, sessionKeyAddress],
+            });
+            const hash = await wallet.walletClient.sendTransaction({
+                account,
+                to: wallet.address,
+                data,
+                chain: sepolia,
+            });
+            const receipt = await wallet.publicClient.waitForTransactionReceipt({ hash });
+            if (receipt.status === 'reverted') {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: toJSON({
+                                success: false,
+                                error: 'Revoke session key transaction reverted',
+                                txHash: hash,
+                            }),
+                        }],
+                    isError: true,
+                };
+            }
+            session.revoked = true;
+            return {
+                content: [{
+                        type: 'text',
+                        text: toJSON({
+                            success: true,
+                            sessionKeyAddress,
+                            revoked: true,
+                            txHash: hash,
+                            blockNumber: Number(receipt.blockNumber),
+                            message: 'Session key has been revoked on-chain.',
+                        }),
+                    }],
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: 'text', text: toJSON({ error: `Revoke session key failed: ${message}` }) }],
+                isError: true,
+            };
+        }
+    }
+    session.revoked = true;
+    return {
+        content: [{
+                type: 'text',
+                text: toJSON({
+                    success: true,
+                    sessionKeyAddress,
+                    revoked: true,
+                    message: 'Session key has been revoked locally. Set POLICY_DELEGATE_ADDRESS to also revoke on-chain.',
+                }),
+            }],
+    };
+});
+// ============================================================
+// Tool 11: Register Identity (ERC-8004)
+// ============================================================
+server.tool('warden_register_identity', 'Register the agent on the ERC-8004 Agent Identity Registry. Requires ERC8004_IDENTITY_REGISTRY env var for the on-chain registry contract address.', {
+    agentName: z.string().describe('Human-readable name for this agent'),
+    capabilities: z.array(z.string()).describe('List of agent capabilities (e.g. ["transfer", "swap", "bridge"])'),
+}, async ({ agentName, capabilities }) => {
+    if (!ERC8004_IDENTITY_REGISTRY) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: toJSON({ error: 'ERC-8004 registry address not configured. Set ERC8004_IDENTITY_REGISTRY env var.' }),
+                }],
+            isError: true,
+        };
+    }
+    let wallet;
+    try {
+        wallet = requireWallet();
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: 'text', text: toJSON({ error: message }) }],
+            isError: true,
+        };
+    }
+    try {
+        const account = privateKeyToAccount(storedPrivateKey);
+        const data = encodeFunctionData({
+            abi: ERC8004_ABI,
+            functionName: 'registerAgent',
+            args: [agentName, capabilities],
+        });
+        const hash = await wallet.walletClient.sendTransaction({
+            account,
+            to: ERC8004_IDENTITY_REGISTRY,
+            data,
+            chain: sepolia,
+        });
+        const receipt = await wallet.publicClient.waitForTransactionReceipt({ hash });
+        if (receipt.status === 'reverted') {
+            return {
+                content: [{
+                        type: 'text',
+                        text: toJSON({
+                            success: false,
+                            error: 'Identity registration transaction reverted',
+                            txHash: hash,
+                        }),
+                    }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: toJSON({
+                        success: true,
+                        registry: 'ERC-8004 Agent Identity Registry',
+                        registryAddress: ERC8004_IDENTITY_REGISTRY,
+                        agentName,
+                        capabilities,
+                        owner: wallet.address,
+                        txHash: hash,
+                        blockNumber: Number(receipt.blockNumber),
+                    }, 2),
+                }],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: 'text', text: toJSON({ error: `Identity registration failed: ${message}` }) }],
+            isError: true,
+        };
+    }
+});
+// ============================================================
+// Tool 12: Grant Permissions (ERC-7715)
+// ============================================================
+server.tool('warden_grant_permissions', 'Grant scoped permissions to an AI agent following ERC-7715 standard. Updates policy engine limits and optionally creates an on-chain session key.', {
+    agentId: z.string().describe('Agent identifier to grant permissions to'),
+    permissions: z.array(z.object({
+        type: z.enum(['token-transfer', 'contract-call', 'native-transfer']).describe('Permission type'),
+        token: z.string().optional().describe('Token address for token-transfer type'),
+        maxPerTx: z.number().optional().describe('Max per transaction in USDT'),
+        dailyLimit: z.number().optional().describe('Daily spending limit in USDT'),
+        allowedRecipients: z.array(z.string()).optional().describe('Allowed recipient addresses'),
+        allowedContracts: z.array(z.string()).optional().describe('Allowed contract addresses for contract-call type'),
+    })).describe('Scoped permissions to grant'),
+    expiry: z.number().describe('Unix timestamp (seconds) when permissions expire'),
+    cooldownSeconds: z.number().default(30).describe('Min seconds between transactions'),
+}, async ({ agentId, permissions, expiry, cooldownSeconds }) => {
+    if (!policyEngine || !auditLogger) {
+        return {
+            content: [{ type: 'text', text: toJSON({ error: 'No wallet created. Call warden_create_wallet first.' }) }],
+            isError: true,
+        };
+    }
+    if (permissions.length === 0) {
+        return {
+            content: [{ type: 'text', text: toJSON({ error: 'At least one permission must be specified.' }) }],
+            isError: true,
+        };
+    }
+    const now = Math.floor(Date.now() / 1000);
+    if (expiry <= now) {
+        return {
+            content: [{ type: 'text', text: toJSON({ error: `Expiry ${expiry} is in the past. Current time: ${now}` }) }],
+            isError: true,
+        };
+    }
+    // Derive aggregate limits from permissions: take the highest maxPerTx and dailyLimit across all scopes
+    let aggregateMaxPerTx = 0;
+    let aggregateDailyLimit = 0;
+    const allowedTokens = [];
+    const allowedRecipients = [];
+    for (const perm of permissions) {
+        if (perm.maxPerTx !== undefined && perm.maxPerTx > aggregateMaxPerTx) {
+            aggregateMaxPerTx = perm.maxPerTx;
+        }
+        if (perm.dailyLimit !== undefined && perm.dailyLimit > aggregateDailyLimit) {
+            aggregateDailyLimit = perm.dailyLimit;
+        }
+        if (perm.type === 'token-transfer' && perm.token) {
+            allowedTokens.push(perm.token.toLowerCase());
+        }
+        if (perm.allowedRecipients) {
+            for (const r of perm.allowedRecipients) {
+                if (!allowedRecipients.includes(r.toLowerCase())) {
+                    allowedRecipients.push(r.toLowerCase());
+                }
+            }
+        }
+    }
+    const policyUpdates = {
+        cooldownMs: cooldownSeconds * 1000,
+        sessionKey: {
+            address: agentId,
+            validUntil: expiry * 1000,
+        },
+    };
+    if (aggregateMaxPerTx > 0) {
+        policyUpdates.maxPerTx = BigInt(aggregateMaxPerTx) * 1000000n;
+    }
+    if (aggregateDailyLimit > 0) {
+        policyUpdates.dailyLimit = BigInt(aggregateDailyLimit) * 1000000n;
+    }
+    if (allowedTokens.length > 0) {
+        policyUpdates.allowedTokens = allowedTokens;
+    }
+    if (allowedRecipients.length > 0) {
+        policyUpdates.allowedRecipients = allowedRecipients;
+    }
+    // On-chain session key if delegate is configured
+    let txHash;
+    if (POLICY_DELEGATE_ADDRESS && publicClient && walletClient && storedPrivateKey) {
+        try {
+            const wallet = requireWallet();
+            const account = privateKeyToAccount(storedPrivateKey);
+            const maxPerTxWei = BigInt(aggregateMaxPerTx) * 1000000n;
+            const dailyLimitWei = BigInt(aggregateDailyLimit) * 1000000n;
+            const data = encodeFunctionData({
+                abi: POLICY_DELEGATE_ABI,
+                functionName: 'createSessionKey',
+                args: [
+                    wallet.address,
+                    agentId,
+                    maxPerTxWei,
+                    dailyLimitWei,
+                    now,
+                    expiry,
+                    BigInt(cooldownSeconds),
+                ],
+            });
+            const hash = await wallet.walletClient.sendTransaction({
+                account,
+                to: wallet.address,
+                data,
+                chain: sepolia,
+            });
+            const receipt = await wallet.publicClient.waitForTransactionReceipt({ hash });
+            if (receipt.status === 'reverted') {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: toJSON({
+                                success: false,
+                                error: 'On-chain session key creation reverted',
+                                txHash: hash,
+                            }),
+                        }],
+                    isError: true,
+                };
+            }
+            txHash = hash;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: 'text', text: toJSON({ error: `On-chain permission grant failed: ${message}` }) }],
+                isError: true,
+            };
+        }
+    }
+    // Commit local state only after on-chain succeeds (or if no on-chain needed)
+    policyEngine.updatePolicy(policyUpdates);
+    frozen = false;
+    const grant = {
+        agentId,
+        permissions,
+        expiry,
+        cooldownSeconds,
+        grantedAt: Date.now(),
+        txHash,
+    };
+    permissionGrants.set(agentId, grant);
+    return {
+        content: [{
+                type: 'text',
+                text: toJSON({
+                    success: true,
+                    standard: 'ERC-7715',
+                    agentId,
+                    permissions: permissions.map(p => ({
+                        type: p.type,
+                        token: p.token,
+                        maxPerTx: p.maxPerTx !== undefined ? `${p.maxPerTx} USDT` : undefined,
+                        dailyLimit: p.dailyLimit !== undefined ? `${p.dailyLimit} USDT` : undefined,
+                        allowedRecipients: p.allowedRecipients,
+                        allowedContracts: p.allowedContracts,
+                    })),
+                    expiry: new Date(expiry * 1000).toISOString(),
+                    cooldownSeconds,
+                    txHash: txHash ?? null,
+                }, 2),
+            }],
+    };
+});
+// ============================================================
+// Tool 13: Revoke Permissions (ERC-7715)
+// ============================================================
+server.tool('warden_revoke_permissions', 'Revoke all permissions from an AI agent following ERC-7715 standard. Zeros out policy limits, freezes the agent, and optionally revokes the on-chain session key.', {
+    agentId: z.string().describe('Agent identifier to revoke permissions from'),
+}, async ({ agentId }) => {
+    if (!policyEngine) {
+        return {
+            content: [{ type: 'text', text: toJSON({ error: 'No wallet created. Call warden_create_wallet first.' }) }],
+            isError: true,
+        };
+    }
+    const grant = permissionGrants.get(agentId);
+    if (!grant) {
+        return {
+            content: [{ type: 'text', text: toJSON({ error: `No ERC-7715 permissions found for agent: ${agentId}` }) }],
+            isError: true,
+        };
+    }
+    // On-chain revocation if delegate is configured
+    let txHash;
+    if (POLICY_DELEGATE_ADDRESS && publicClient && walletClient && storedPrivateKey) {
+        try {
+            const wallet = requireWallet();
+            const account = privateKeyToAccount(storedPrivateKey);
+            const data = encodeFunctionData({
+                abi: POLICY_DELEGATE_ABI,
+                functionName: 'revokeSessionKey',
+                args: [wallet.address, agentId],
+            });
+            const hash = await wallet.walletClient.sendTransaction({
+                account,
+                to: wallet.address,
+                data,
+                chain: sepolia,
+            });
+            const receipt = await wallet.publicClient.waitForTransactionReceipt({ hash });
+            if (receipt.status === 'reverted') {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: toJSON({
+                                success: false,
+                                error: 'On-chain session key revocation reverted',
+                                txHash: hash,
+                            }),
+                        }],
+                    isError: true,
+                };
+            }
+            txHash = hash;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: 'text', text: toJSON({ error: `On-chain permission revocation failed: ${message}` }) }],
+                isError: true,
+            };
+        }
+    }
+    // Zero out policy limits and freeze
+    policyEngine.updatePolicy({
+        maxPerTx: 0n,
+        dailyLimit: 0n,
+        allowedTokens: [],
+        allowedRecipients: [],
+        sessionKey: undefined,
+    });
+    frozen = true;
+    permissionGrants.delete(agentId);
+    return {
+        content: [{
+                type: 'text',
+                text: toJSON({
+                    success: true,
+                    standard: 'ERC-7715',
+                    agentId,
+                    revoked: true,
+                    frozen: true,
+                    txHash: txHash ?? null,
+                    message: 'All permissions revoked. Wallet is frozen.',
+                }, 2),
+            }],
+    };
+});
+// ============================================================
+// Tool 14: Get Permissions (ERC-7715)
+// ============================================================
+server.tool('warden_get_permissions', 'Query current permissions granted to an AI agent following ERC-7715 standard. Returns policy limits, expiry, spending status, and compliance info.', {
+    agentId: z.string().describe('Agent identifier to query permissions for'),
+}, async ({ agentId }) => {
+    if (!policyEngine) {
+        return {
+            content: [{ type: 'text', text: toJSON({ error: 'No wallet created. Call warden_create_wallet first.' }) }],
+            isError: true,
+        };
+    }
+    const grant = permissionGrants.get(agentId);
+    if (!grant) {
+        return {
+            content: [{ type: 'text', text: toJSON({ error: `No ERC-7715 permissions found for agent: ${agentId}` }) }],
+            isError: true,
+        };
+    }
+    const policy = policyEngine.getPolicy();
+    const spending = policyEngine.getSpendingStatus();
+    const now = Math.floor(Date.now() / 1000);
+    const isExpired = grant.expiry <= now;
+    return {
+        content: [{
+                type: 'text',
+                text: toJSON({
+                    standard: 'ERC-7715',
+                    agentId,
+                    policy: {
+                        maxPerTx: `${Number(policy.maxPerTx) / 1e6} USDT`,
+                        dailyLimit: `${Number(policy.dailyLimit) / 1e6} USDT`,
+                        cooldownMs: policy.cooldownMs,
+                        allowedTokens: policy.allowedTokens,
+                        allowedRecipients: policy.allowedRecipients,
+                    },
+                    permissions: grant.permissions.map(p => ({
+                        type: p.type,
+                        token: p.token,
+                        maxPerTx: p.maxPerTx !== undefined ? `${p.maxPerTx} USDT` : undefined,
+                        dailyLimit: p.dailyLimit !== undefined ? `${p.dailyLimit} USDT` : undefined,
+                        allowedRecipients: p.allowedRecipients,
+                        allowedContracts: p.allowedContracts,
+                    })),
+                    expiry: {
+                        timestamp: grant.expiry,
+                        iso: new Date(grant.expiry * 1000).toISOString(),
+                        expired: isExpired,
+                        remainingSeconds: isExpired ? 0 : grant.expiry - now,
+                    },
+                    spending: {
+                        spent: `${Number(spending.spent) / 1e6} USDT`,
+                        remaining: `${Number(spending.remaining) / 1e6} USDT`,
+                        windowResets: new Date(spending.windowResets).toISOString(),
+                    },
+                    frozen,
+                    grantedAt: new Date(grant.grantedAt).toISOString(),
+                    txHash: grant.txHash ?? null,
+                    erc7715Compliant: true,
+                }, 2),
+            }],
+    };
+});
+// ============================================================
+// Main -- stdio transport
+// ============================================================
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('[Warden MCP] Server running on stdio');
+    console.error(`[Warden MCP] RPC: ${PROVIDER_URL}`);
+    console.error(`[Warden MCP] PolicyDelegate: ${POLICY_DELEGATE_ADDRESS ?? 'not configured'}`);
+    console.error(`[Warden MCP] ERC-8004 Registry: ${ERC8004_IDENTITY_REGISTRY ?? 'not configured'}`);
+    console.error(`[Warden MCP] Default USDT: ${SEPOLIA_USDT}`);
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@aspect-warden/mcp-server",
+  "version": "0.3.0",
+  "type": "module",
+  "bin": {
+    "warden-mcp": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@aspect-warden/policy-engine": "^0.3.0",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.22.0",
+    "viem": "^2.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "@types/node": "^20.0.0"
+  }
+}