cronos-agent-wallet 1.2.1 → 1.2.2

package/dist/internal/AgentWallet.d.ts

@@ -7,7 +7,7 @@ import { PaymentExecutor } from "./executors";
  * - Decides whether to pay
  * - Delegates execution to PaymentExecutor
  * - Enforces security + policy
- * - Persists state (Isomorphic: FS or LocalStorage)
+ * - Persists state to MongoDB
  */
 export declare class AgentWallet {
     private readonly address;
@@ -19,7 +19,7 @@ export declare class AgentWallet {
     private allowedMerchants;
     private trustedFacilitatorOrigins;
     private stopped;
-    private persistence;
+    private isInitialized;
     /**
      * Replay protection
      * key -> timestamp
@@ -27,6 +27,7 @@ export declare class AgentWallet {
     private paidRequests;
     constructor(address: string, executor: PaymentExecutor, config?: AgentWalletConfig);
     private getTodayDate;
+    init(): Promise<void>;
     private loadState;
     private saveState;
     getAddress(): string;
@@ -42,9 +43,9 @@ export declare class AgentWallet {
     emergencyStop(): void;
     shouldPay(request: PaymentRequest, context: WalletContext, originalChallenge?: {
         route?: string;
-    }): {
+    }): Promise<{
         allow: boolean;
         reason?: string;
-    };
+    }>;
     executePayment(request: PaymentRequest): Promise<string>;
 }

package/dist/internal/AgentWallet.js

@@ -1,57 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentWallet = void 0;
-class NodePersistence {
-    fs;
-    path;
-    statePath = "";
-    constructor() {
-        // Dynamic require to avoid bundling issues in browser
-        try {
-            this.fs = require("fs");
-            this.path = require("path");
-            this.statePath = this.path.resolve(__dirname, "wallet-state.json");
-        }
-        catch (e) { /* Browser environment */ }
-    }
-    load() {
-        if (!this.fs || !this.fs.existsSync(this.statePath))
-            return null;
-        try {
-            return JSON.parse(this.fs.readFileSync(this.statePath, "utf-8"));
-        }
-        catch (e) {
-            console.warn("[WALLET] Failed to load local state file", e);
-            return null;
-        }
-    }
-    save(data) {
-        if (!this.fs)
-            return;
-        try {
-            const tmpPath = this.statePath + ".tmp";
-            this.fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
-            this.fs.renameSync(tmpPath, this.statePath);
-        }
-        catch (e) {
-            console.error("[WALLET] Failed to save local state file", e);
-        }
-    }
-}
-class BrowserPersistence {
-    key = "cronos_agent_wallet_state";
-    load() {
-        if (typeof localStorage === "undefined")
-            return null;
-        const item = localStorage.getItem(this.key);
-        return item ? JSON.parse(item) : null;
-    }
-    save(data) {
-        if (typeof localStorage === "undefined")
-            return;
-        localStorage.setItem(this.key, JSON.stringify(data));
-    }
-}
+const mongoose_1 = __importDefault(require("mongoose"));
+const models_1 = require("./models");
 /**
  * AgentWallet
  * ------------
@@ -59,7 +13,7 @@ class BrowserPersistence {
  * - Decides whether to pay
  * - Delegates execution to PaymentExecutor
  * - Enforces security + policy
- * - Persists state (Isomorphic: FS or LocalStorage)
+ * - Persists state to MongoDB
  */
 class AgentWallet {
     address;
@@ -78,7 +32,7 @@ class AgentWallet {
         "https://cronos-x-402-production.up.railway.app",
     ]);
     stopped = false;
-    persistence;
+    isInitialized = false;
     /**
      * Replay protection
      * key -> timestamp
@@ -97,55 +51,95 @@ class AgentWallet {
             if (config.trustedFacilitators)
                 this.trustedFacilitatorOrigins = new Set(config.trustedFacilitators);
         }
-        // Initialize Persistence based on env
-        if (typeof window === "undefined") {
-            this.persistence = new NodePersistence();
-        }
-        else {
-            this.persistence = new BrowserPersistence();
-        }
-        this.loadState();
+        this.lastResetDate = this.getTodayDate();
     }
     // ---------------- PERSISTENCE ----------------
     getTodayDate() {
         return new Date().toISOString().split("T")[0]; // YYYY-MM-DD
     }
-    loadState() {
-        const state = this.persistence.load();
-        if (state) {
-            // 1. Check if we need to reset for a new day
-            const today = this.getTodayDate();
-            if (state.lastResetDate !== today) {
-                console.log(`[WALLET] New day detected! Resetting limit. (Last: ${state.lastResetDate}, Today: ${today})`);
-                this.spentToday = 0;
-                this.lastResetDate = today;
-                // Cleanup old requests (older than 24h) to prevent memory leak
-                const MAX_AGE_MS = 24 * 60 * 60 * 1000;
-                const now = Date.now();
-                this.paidRequests = new Map(state.paidRequests.filter(([_, ts]) => now - ts < MAX_AGE_MS));
+    async init() {
+        if (this.isInitialized)
+            return;
+        try {
+            // Auto-connect if not connected
+            if (mongoose_1.default.connection.readyState === 0) {
+                if (!process.env.MONGODB_URI) {
+                    console.warn("[WALLET] MONGODB_URI missing. Persistence disabled.");
+                    return;
+                }
+                await mongoose_1.default.connect(process.env.MONGODB_URI);
+                console.log("[WALLET] Connected to MongoDB");
+            }
+            await this.loadState();
+            this.isInitialized = true;
+        }
+        catch (error) {
+            console.error("[WALLET] Initialization failed:", error);
+        }
+    }
+    async loadState() {
+        try {
+            const doc = await models_1.AgentWalletModel.findOne({ address: this.address }).lean();
+            if (doc) {
+                // Helper to normalize DB Map vs POJO
+                const rawObj = doc.paidRequests || {};
+                const rawMap = rawObj instanceof Map
+                    ? rawObj
+                    : new Map(Object.entries(rawObj));
+                // 1. Check if we need to reset for a new day
+                const today = this.getTodayDate();
+                if (doc.lastResetDate !== today) {
+                    console.log(`[WALLET] New day detected! Resetting limit. (Last: ${doc.lastResetDate}, Today: ${today})`);
+                    this.spentToday = 0;
+                    this.lastResetDate = today;
+                    // Cleanup old requests (older than 24h)
+                    const MAX_AGE_MS = 24 * 60 * 60 * 1000;
+                    const now = Date.now();
+                    this.paidRequests = new Map();
+                    for (const [key, val] of rawMap.entries()) {
+                        const ts = Number(val);
+                        if (!isNaN(ts) && (now - ts < MAX_AGE_MS)) {
+                            this.paidRequests.set(key, ts);
+                        }
+                    }
+                    // Save cleanup immediately
+                    await this.saveState();
+                }
+                else {
+                    console.log(`[WALLET] State loaded. Spent today: ${doc.spentToday.toFixed(4)} / ${this.dailyLimit}`);
+                    this.spentToday = doc.spentToday;
+                    this.lastResetDate = doc.lastResetDate;
+                    this.paidRequests = new Map();
+                    for (const [key, val] of rawMap.entries()) {
+                        const ts = Number(val);
+                        if (!isNaN(ts)) {
+                            this.paidRequests.set(key, ts);
+                        }
+                    }
+                }
             }
             else {
-                console.log(`[WALLET] State loaded. Spent today: ${state.spentToday.toFixed(4)} / ${this.dailyLimit}`);
-                this.spentToday = state.spentToday;
-                this.lastResetDate = state.lastResetDate;
-                // Also cleanup on every load to be safe
-                const MAX_AGE_MS = 24 * 60 * 60 * 1000;
-                const now = Date.now();
-                this.paidRequests = new Map(state.paidRequests.filter(([_, ts]) => now - ts < MAX_AGE_MS));
+                // Initialize fresh
+                this.lastResetDate = this.getTodayDate();
+                await this.saveState();
             }
         }
-        else {
-            // Initialize fresh
-            this.lastResetDate = this.getTodayDate();
+        catch (error) {
+            console.warn("[WALLET] Failed to load state from DB", error);
         }
     }
-    saveState() {
-        const state = {
-            lastResetDate: this.lastResetDate,
-            spentToday: this.spentToday,
-            paidRequests: Array.from(this.paidRequests.entries())
-        };
-        this.persistence.save(state);
+    async saveState() {
+        try {
+            await models_1.AgentWalletModel.findOneAndUpdate({ address: this.address }, {
+                address: this.address,
+                lastResetDate: this.lastResetDate,
+                spentToday: this.spentToday,
+                paidRequests: this.paidRequests
+            }, { upsert: true, new: true });
+        }
+        catch (error) {
+            console.error("[WALLET] Failed to save state to DB", error);
+        }
     }
     // ---------------- PUBLIC ----------------
     getAddress() {
@@ -246,7 +240,10 @@ class AgentWallet {
         this.stopped = true;
         console.warn("[WALLET] Emergency stop activated!");
     }
-    shouldPay(request, context, originalChallenge) {
+    async shouldPay(request, context, originalChallenge) {
+        // Ensure initialized
+        if (!this.isInitialized)
+            await this.init();
         // -1. Emergency Stop
         if (this.stopped) {
             return { allow: false, reason: "Emergency stop active" };
@@ -256,8 +253,8 @@ class AgentWallet {
         if (originalChallenge?.route && request.route !== originalChallenge.route) {
             return { allow: false, reason: `Route mismatch: Challenge=${request.route}, Expected=${originalChallenge.route}` };
         }
-        // 0. Currency check [NEW]
-        if (request.currency !== "USDC") {
+        // 0. Currency check [UPDATED]
+        if (request.currency !== "USDC" && request.currency !== "CRO") {
             return { allow: false, reason: `Unsupported currency: ${request.currency}` };
         }
         // 1. Chain verification
@@ -287,6 +284,9 @@ class AgentWallet {
     }
     // ---------------- PAYMENT EXECUTION ----------------
     async executePayment(request) {
+        // Ensure initialized
+        if (!this.isInitialized)
+            await this.init();
         const key = this.paymentKey(request);
         if (this.paidRequests.has(key)) {
             throw new Error("Replay detected: payment already executed");
@@ -297,7 +297,7 @@ class AgentWallet {
         this.spentToday += request.amount;
         this.paidRequests.set(key, Date.now());
         // Persist immediately
-        this.saveState();
+        await this.saveState();
         return proof;
     }
 }

package/dist/internal/CronosUsdcExecutor.js

@@ -52,40 +52,55 @@ class CronosUsdcExecutor {
         throw lastError;
     }
     async execute(request) {
-        const amount = ethers_1.ethers.parseUnits(request.amount.toString(), 6 // USDC decimals
-        );
-        console.log(`[CRONOS] Paying ${request.amount} USDC -> ${request.payTo}
-merchant = ${request.merchantId}
-route = ${request.route}
-nonce = ${request.nonce} `);
         // 0. Connection Check
         if (!this.chainId)
             await this.verifyChain(Number(request.chainId));
+        console.log(`[CRONOS] Paying ${request.amount} ${request.currency} -> ${request.payTo}
+merchant = ${request.merchantId}
+route = ${request.route}
+nonce = ${request.nonce}`);
+        // --- PATH A: Native CRO Payment ---
+        if (request.currency === "CRO" || request.currency === "TCRO") {
+            const amount = ethers_1.ethers.parseEther(request.amount.toString());
+            // 1. Balance Check
+            const balance = await this.withRetry(() => this.provider.getBalance(this.wallet.address));
+            const MIN_GAS = ethers_1.ethers.parseEther("0.05"); // Reserve gas
+            if (balance < (amount + MIN_GAS)) {
+                throw new Error(`Insufficient CRO balance: have ${ethers_1.ethers.formatEther(balance)}, need ${request.amount} + gas`);
+            }
+            // 2. Send Tx
+            const txHandler = await this.withRetry(() => this.wallet.sendTransaction({
+                to: request.payTo,
+                value: amount
+            }));
+            console.log(`[CRONOS] CRO Tx sent: ${txHandler.hash}. Waiting for confirmation...`);
+            // 3. Wait
+            const receipt = await Promise.race([
+                this.withRetry(() => txHandler.wait(CONFIRMATIONS)),
+                new Promise((_, reject) => setTimeout(() => reject(new Error("Transaction confirmation timeout")), TX_TIMEOUT_MS)),
+            ]);
+            if (!receipt || receipt.status !== 1)
+                throw new Error("CRO transfer failed");
+            console.log(`[CRONOS] Payment confirmed: ${receipt.hash}`);
+            return receipt.hash;
+        }
+        // --- PATH B: USDC Payment (Legacy) ---
+        const amount = ethers_1.ethers.parseUnits(request.amount.toString(), 6); // USDC decimals
         // 1. Balance check (Retryable)
-        // Note: balanceOf returns bigint in v6
         const balance = await this.withRetry(() => this.usdc.balanceOf(this.wallet.address));
         if (balance < amount) {
-            throw new Error(`Insufficient USDC balance: have ${ethers_1.ethers.formatUnits(balance, 6)}, need ${request.amount} `);
+            throw new Error(`Insufficient USDC balance: have ${ethers_1.ethers.formatUnits(balance, 6)}, need ${request.amount}`);
         }
-        // ... inside class ...
         // 1.5 Gas Check (CRO Balance)
         const croBalance = await this.withRetry(() => this.provider.getBalance(this.wallet.address));
-        const MIN_GAS = ethers_1.ethers.parseEther("0.1"); // Reserve 0.1 CRO for gas
+        const MIN_GAS = ethers_1.ethers.parseEther("0.1");
         if (croBalance < MIN_GAS) {
             throw new errors_1.AgentError(`Insufficient CRO for gas: have ${ethers_1.ethers.formatEther(croBalance)}, need > 0.1`, "INSUFFICIENT_FUNDS");
         }
-        // 2. Gas Estimation (Safety)
-        try {
-            const gasEstimate = await this.withRetry(() => this.usdc.transfer.estimateGas(request.payTo, amount));
-            // Optional: Cap gas limit if needed, usually estimate is fine
-        }
-        catch (e) {
-            throw new Error(`Gas estimation failed(likely insufficient funds for gas): ${e.message} `);
-        }
-        // 3. Send tx
+        // 2. Send tx
         const tx = await this.withRetry(() => this.usdc.transfer(request.payTo, amount));
         console.log(`[CRONOS] Tx sent: ${tx.hash}. Waiting for confirmation...`);
-        // 4. Wait with timeout + confirmations
+        // 3. Wait
         const receipt = await Promise.race([
             this.withRetry(() => tx.wait(CONFIRMATIONS)),
             new Promise((_, reject) => setTimeout(() => reject(new Error("Transaction confirmation timeout")), TX_TIMEOUT_MS)),
@@ -93,7 +108,7 @@ nonce = ${request.nonce} `);
         if (!receipt || receipt.status !== 1) {
             throw new Error("USDC transfer failed (Reverted)");
         }
-        console.log(`[CRONOS] Payment confirmed: ${receipt.hash} `);
+        console.log(`[CRONOS] Payment confirmed: ${receipt.hash}`);
         return receipt.hash;
     }
     getAddress() {

package/dist/internal/models.d.ts

@@ -0,0 +1,15 @@
+import { Document } from "mongoose";
+interface IAgentWalletState extends Document {
+    address: string;
+    lastResetDate: string;
+    spentToday: number;
+    paidRequests: Map<string, number>;
+}
+export declare const AgentWalletModel: import("mongoose").Model<IAgentWalletState, {}, {}, {}, Document<unknown, {}, IAgentWalletState, {}, import("mongoose").DefaultSchemaOptions> & IAgentWalletState & Required<{
+    _id: import("mongoose").Types.ObjectId;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, IAgentWalletState>;
+export {};

package/dist/internal/models.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentWalletModel = void 0;
+const mongoose_1 = require("mongoose");
+const AgentWalletStateSchema = new mongoose_1.Schema({
+    address: { type: String, required: true, unique: true },
+    lastResetDate: { type: String, required: true },
+    spentToday: { type: Number, required: true, default: 0 },
+    paidRequests: {
+        type: Map,
+        of: Number,
+        default: new Map()
+    }
+});
+exports.AgentWalletModel = (0, mongoose_1.model)("AgentWalletState", AgentWalletStateSchema);

package/dist/internal/x402ToolClient.js

@@ -76,7 +76,7 @@ async function x402Request(url, wallet, context, options = {}) {
                 throw new Error(`Failed to parse 402 challenge from Headers OR Body. Header error: ${headerErr}. Body error: ${bodyErr}`);
             }
         }
-        const decision = wallet.shouldPay(paymentRequest, context, {
+        const decision = await wallet.shouldPay(paymentRequest, context, {
             route: wallet.parse402Header(res.headers).route // Validate against what the server claimed in headers
         });
         const agentAddress = wallet.getAddress();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cronos-agent-wallet",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [