@aspect-warden/mcp-server 0.3.2 → 0.4.1

package/README.md

@@ -51,6 +51,7 @@ npx skills add tetherto/wdk-agent-skills
 | `POLICY_DELEGATE_ADDRESS` | No | — | Deployed PolicyDelegate contract for EIP-7702 |
 | `SEPOLIA_USDT_ADDRESS` | No | `0x7169...BA06` | USDT token address on Sepolia |
 | `ERC8004_IDENTITY_REGISTRY` | No | — | ERC-8004 identity registry address |
+| `WARDEN_STORAGE_KEY` | No | machine-scoped | Passphrase for encrypting persisted wallet state |
 
 ## MCP Tools
 
@@ -123,6 +124,17 @@ Agent: [calls warden_transfer — PolicyEngine blocks it]
        Current daily spend: 5 USDT.
 ```
 
+## Wallet Persistence
+
+Wallet private keys and policy configuration are automatically saved to `~/.warden/wallet-state.enc` using AES-256-CBC encryption. When the MCP server restarts (e.g., Claude Desktop relaunch), it restores the previous wallet — no need to call `warden_create_wallet` again.
+
+- **Storage**: `~/.warden/wallet-state.enc` (encrypted, file permissions `0600`)
+- **Encryption**: AES-256-CBC with key derived from `WARDEN_STORAGE_KEY` env var (or machine-scoped default)
+- **What's persisted**: private key, agent ID, policy configuration
+- **What's NOT persisted**: spending counters, audit logs, session keys (reset on restart)
+
+To use a different wallet, simply call `warden_create_wallet` again — it overwrites the saved state.
+
 ## Architecture
 
 ```

package/dist/index.js

@@ -5,6 +5,10 @@ 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';
+import { createHash, createCipheriv, createDecipheriv, randomBytes } from 'node:crypto';
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
 // ============================================================
 // Configuration from environment
 // ============================================================
@@ -34,6 +38,60 @@ const ERC8004_ABI = parseAbi([
 ]);
 // PolicyEngine and AuditLogger imported from @aspect-warden/policy-engine
 // ============================================================
+// Encrypted Wallet Persistence
+// ============================================================
+const STORAGE_DIR = join(homedir(), '.warden');
+const STATE_FILE = join(STORAGE_DIR, 'wallet-state.enc');
+// Derive a 32-byte AES key from a passphrase
+function deriveKey(passphrase) {
+    return createHash('sha256').update(passphrase).digest();
+}
+function encrypt(data, passphrase) {
+    const key = deriveKey(passphrase);
+    const iv = randomBytes(16);
+    const cipher = createCipheriv('aes-256-cbc', key, iv);
+    let encrypted = cipher.update(data, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+    return iv.toString('hex') + ':' + encrypted;
+}
+function decrypt(payload, passphrase) {
+    const key = deriveKey(passphrase);
+    const [ivHex, encrypted] = payload.split(':');
+    const iv = Buffer.from(ivHex, 'hex');
+    const decipher = createDecipheriv('aes-256-cbc', key, iv);
+    let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+    return decrypted;
+}
+const STORAGE_KEY = process.env.WARDEN_STORAGE_KEY || `warden-${homedir()}`;
+function saveState(state) {
+    try {
+        if (!existsSync(STORAGE_DIR)) {
+            mkdirSync(STORAGE_DIR, { recursive: true, mode: 0o700 });
+        }
+        const json = JSON.stringify(state);
+        const encrypted = encrypt(json, STORAGE_KEY);
+        writeFileSync(STATE_FILE, encrypted, { mode: 0o600 });
+        console.error('[Warden MCP] Wallet state saved to ~/.warden/wallet-state.enc');
+    }
+    catch (err) {
+        console.error('[Warden MCP] Failed to save wallet state:', err);
+    }
+}
+function loadState() {
+    try {
+        if (!existsSync(STATE_FILE))
+            return null;
+        const encrypted = readFileSync(STATE_FILE, 'utf8');
+        const json = decrypt(encrypted, STORAGE_KEY);
+        return JSON.parse(json);
+    }
+    catch (err) {
+        console.error('[Warden MCP] Failed to load wallet state (may be from different key):', err);
+        return null;
+    }
+}
+// ============================================================
 // MCP Server State
 // ============================================================
 let policyEngine = null;
@@ -114,6 +172,22 @@ server.tool('warden_create_wallet', 'Create a new policy-enforced wallet for the
     policyEngine = new PolicyEngine(policy);
     auditLogger = new AuditLogger({ maxEntries: 10000 });
     frozen = false;
+    // Persist wallet state for recovery across restarts
+    saveState({
+        privateKey: storedPrivateKey,
+        agentId,
+        policy: {
+            maxPerTx: policy.maxPerTx.toString(),
+            dailyLimit: policy.dailyLimit.toString(),
+            requireApprovalAbove: policy.requireApprovalAbove.toString(),
+            cooldownMs: policy.cooldownMs,
+            allowedTokens: policy.allowedTokens,
+            blockedTokens: policy.blockedTokens,
+            allowedRecipients: policy.allowedRecipients,
+            blockedRecipients: policy.blockedRecipients,
+            allowedChains: policy.allowedChains,
+        },
+    });
     return {
         content: [{
                 type: 'text',
@@ -248,6 +322,7 @@ server.tool('warden_transfer', 'Send ERC-20 tokens with policy enforcement. Eval
     const decision = policyEngine.evaluate(recipient, valueMicro, tokenAddress, 'ethereum');
     auditLogger.log(decision);
     if (!decision.approved) {
+        const currentPolicy = policyEngine.getPolicy();
         return {
             content: [{
                     type: 'text',
@@ -257,6 +332,10 @@ server.tool('warden_transfer', 'Send ERC-20 tokens with policy enforcement. Eval
                         reason: decision.reason,
                         ruleTriggered: decision.ruleTriggered,
                         riskScore: decision.riskScore,
+                        currentLimits: {
+                            maxPerTx: `${Number(currentPolicy.maxPerTx) / 1e6} USDT`,
+                            dailyLimit: `${Number(currentPolicy.dailyLimit) / 1e6} USDT`,
+                        },
                     }),
                 }],
         };
@@ -412,6 +491,25 @@ server.tool('warden_update_policy', 'Modify policy rules at runtime. Can update
         updatedFields.push('cooldownMs');
     }
     policyEngine.updatePolicy(updates);
+    // Persist updated policy so it survives restarts
+    if (storedPrivateKey) {
+        const p = policyEngine.getPolicy();
+        saveState({
+            privateKey: storedPrivateKey,
+            agentId: p.agentId,
+            policy: {
+                maxPerTx: p.maxPerTx.toString(),
+                dailyLimit: p.dailyLimit.toString(),
+                requireApprovalAbove: p.requireApprovalAbove.toString(),
+                cooldownMs: p.cooldownMs,
+                allowedTokens: p.allowedTokens,
+                blockedTokens: p.blockedTokens,
+                allowedRecipients: p.allowedRecipients,
+                blockedRecipients: p.blockedRecipients,
+                allowedChains: p.allowedChains,
+            },
+        });
+    }
     return {
         content: [{
                 type: 'text',
@@ -1034,6 +1132,37 @@ server.tool('warden_get_permissions', 'Query current permissions granted to an A
 // Main -- stdio transport
 // ============================================================
 async function main() {
+    // Restore wallet state from previous session if available
+    const saved = loadState();
+    if (saved) {
+        try {
+            initializeClients(saved.privateKey);
+            const restoredPolicy = {
+                agentId: saved.agentId,
+                maxPerTx: BigInt(saved.policy.maxPerTx),
+                dailyLimit: BigInt(saved.policy.dailyLimit),
+                requireApprovalAbove: BigInt(saved.policy.requireApprovalAbove),
+                cooldownMs: saved.policy.cooldownMs,
+                allowedTokens: saved.policy.allowedTokens,
+                blockedTokens: saved.policy.blockedTokens,
+                allowedRecipients: saved.policy.allowedRecipients,
+                blockedRecipients: saved.policy.blockedRecipients,
+                allowedChains: saved.policy.allowedChains,
+                anomalyDetection: {
+                    maxTxPerHour: 20,
+                    maxRecipientsPerHour: 5,
+                    largeTransactionPct: 50,
+                },
+            };
+            policyEngine = new PolicyEngine(restoredPolicy);
+            auditLogger = new AuditLogger({ maxEntries: 10000 });
+            frozen = false;
+            console.error(`[Warden MCP] Restored wallet ${walletAddress} (agent: ${saved.agentId})`);
+        }
+        catch (err) {
+            console.error('[Warden MCP] Failed to restore wallet state:', err);
+        }
+    }
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error('[Warden MCP] Server running on stdio');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aspect-warden/mcp-server",
-  "version": "0.3.2",
+  "version": "0.4.1",
   "type": "module",
   "bin": {
     "warden-mcp": "dist/index.js"