cronos-agent-wallet 1.2.1 → 1.2.3

package/README.md

@@ -2,6 +2,32 @@
 
 The official SDK for building AI agents that can pay for resources on the Cronos blockchain using the x402 protocol.
 
+## Architecture
+
+This SDK employs a **Hybrid "Exoskeleton" Architecture**:
+- **Off-Chain**: Fast, free logic enforcement and state tracking (MongoDB).
+- **On-Chain**: Immutable security anchors (Registry & Policy) to prevent tampering.
+
+```mermaid
+graph TD
+    subgraph Agent SDK
+      Local[Local Policy Engine]
+      Anchor[On-Chain Policy Anchor (read-only)]
+      Executor[x402 Payment Executor]
+    end
+
+    subgraph Merchant Middleware
+      MRegistry[Merchant Registry (read-only)]
+      Verifier[x402 Verification]
+    end
+
+    Local -->|Checks Hash| Anchor
+    Local -->|Approves| Executor
+    Executor -->|Signed Claim| Verifier
+    Verifier -->|Verifies Identity| MRegistry
+    Verifier -->|Payment Tx| Cronos[Cronos EVM]
+```
+
 ## 🛡️ Security Features (v1.1.1)
 - **Zero Trust Payer:** Derives identity strictly from chain data.
 - **Strong Replay Protection:** Enforces cryptographic binding of `merchantId + route + nonce`.

package/dist/AgentClient.js

@@ -28,12 +28,7 @@ class AgentClient {
         // 1. Create executor (chain-specific)
         const executor = new CronosUsdcExecutor_1.CronosUsdcExecutor(config.rpcUrl, config.privateKey, config.usdcAddress, config.chainId);
         // 2. Create wallet (policy + persistence)
-        this.wallet = new AgentWallet_1.AgentWallet(executor.getAddress(), executor, {
-            dailyLimit: config.dailyLimit,
-            maxPerTransaction: config.maxPerTransaction,
-            trustedFacilitators: config.trustedFacilitators,
-            allowedMerchants: config.allowedMerchants,
-        });
+        this.wallet = new AgentWallet_1.AgentWallet(executor.getAddress(), executor, executor.getProvider(), executor.getSigner(), config);
         // 3. Context passed per request
         this.context = {
             chainId: config.chainId,

package/dist/config.d.ts

@@ -1,3 +1,8 @@
+export interface OnChainAnchors {
+    merchantRegistry?: string;
+    agentPolicyRegistry?: string;
+    policyVerifier?: string;
+}
 export interface AgentConfig {
     privateKey: string;
     rpcUrl: string;
@@ -8,5 +13,14 @@ export interface AgentConfig {
     allowedMerchants?: string[];
     trustedFacilitators?: string[];
     analyticsUrl?: string;
+    anchors?: OnChainAnchors;
+    strictPolicy?: boolean;
     merchantId?: string;
 }
+export declare const AGENT_CONFIG_DEFAULTS: {
+    anchors: {
+        merchantRegistry: string;
+        agentPolicyRegistry: string;
+        policyVerifier: string;
+    };
+};

package/dist/config.js

@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_CONFIG_DEFAULTS = void 0;
+exports.AGENT_CONFIG_DEFAULTS = {
+    // Cronos Testnet Anchors
+    anchors: {
+        merchantRegistry: "0x1948175dDB81DA08a4cf17BE4E0C95B97dD11F5c",
+        agentPolicyRegistry: "0xce3b58c9ae8CA4724d6FA8684d2Cb89546FF4E43",
+        policyVerifier: "0xFCb2D2279256B62A1E4E07BCDed26B6546bBc33b"
+    }
+};

package/dist/internal/AgentWallet.d.ts

@@ -1,5 +1,7 @@
-import { PaymentRequest, WalletContext, AgentWalletConfig } from "./types";
+import { PaymentRequest, WalletContext } from "./types";
 import { PaymentExecutor } from "./executors";
+import { AgentConfig } from "../config";
+import { ethers } from "ethers";
 /**
  * AgentWallet
  * ------------
@@ -7,11 +9,14 @@ 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;
     private readonly executor;
+    private readonly provider;
+    private readonly wallet;
+    private readonly config;
     private dailyLimit;
     private maxPerTransaction;
     private spentToday;
@@ -19,16 +24,26 @@ export declare class AgentWallet {
     private allowedMerchants;
     private trustedFacilitatorOrigins;
     private stopped;
-    private persistence;
+    private isInitialized;
+    /**
+     * Replay protection
+     * key -> timestamp
+     */
     /**
      * Replay protection
      * key -> timestamp
      */
     private paidRequests;
-    constructor(address: string, executor: PaymentExecutor, config?: AgentWalletConfig);
+    private policyRegistry?;
+    constructor(address: string, executor: PaymentExecutor, provider: ethers.Provider, wallet: ethers.Wallet, config: AgentConfig);
     private getTodayDate;
+    init(): Promise<void>;
     private loadState;
     private saveState;
+    /**
+     * Checks if the local policy matches the on-chain anchor.
+     */
+    private verifyPolicyAnchor;
     getAddress(): string;
     private getHeader;
     private canonicalOrigin;
@@ -42,9 +57,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,21 @@
 "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 PolicyRegistryAdapter_1 = require("./PolicyRegistryAdapter");
+const ethers_1 = require("ethers");
+// Helper to hash policy config
+function hashPolicy(config) {
+    const policyData = {
+        dailyLimit: config.dailyLimit || 0,
+        maxPerTransaction: config.maxPerTransaction || 0
+    };
+    return ethers_1.ethers.keccak256(ethers_1.ethers.toUtf8Bytes(JSON.stringify(policyData)));
 }
+const mongoose_1 = __importDefault(require("mongoose"));
+const models_1 = require("./models");
 /**
  * AgentWallet
  * ------------
@@ -59,11 +23,14 @@ 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;
     executor;
+    provider;
+    wallet;
+    config;
     // ---------------- CONFIG ----------------
     // Reduced limit for testing persistence (0.5 USDC)
     dailyLimit = 0.5;
@@ -78,15 +45,24 @@ class AgentWallet {
         "https://cronos-x-402-production.up.railway.app",
     ]);
     stopped = false;
-    persistence;
+    isInitialized = false;
+    /**
+     * Replay protection
+     * key -> timestamp
+     */
     /**
      * Replay protection
      * key -> timestamp
      */
     paidRequests = new Map();
-    constructor(address, executor, config) {
+    // On-Chain Adapter
+    policyRegistry;
+    constructor(address, executor, provider, wallet, config) {
         this.address = address;
         this.executor = executor;
+        this.provider = provider;
+        this.wallet = wallet;
+        this.config = config;
         if (config) {
             if (config.dailyLimit !== undefined)
                 this.dailyLimit = config.dailyLimit;
@@ -96,56 +72,143 @@ class AgentWallet {
                 this.allowedMerchants = new Set(config.allowedMerchants);
             if (config.trustedFacilitators)
                 this.trustedFacilitatorOrigins = new Set(config.trustedFacilitators);
+            // Initialize On-Chain Adapter if configured
+            if (config.anchors?.agentPolicyRegistry) {
+                this.policyRegistry = new PolicyRegistryAdapter_1.PolicyRegistryAdapter(config.anchors.agentPolicyRegistry, provider, wallet);
+                // Non-blocking check for setup/warning
+                this.verifyPolicyAnchor().catch(err => {
+                    console.error("[AgentWallet] Policy Anchor Warning:", err.message);
+                    if (config.strictPolicy) {
+                        process.exit(1); // Strict mode: fail fast
+                    }
+                });
+            }
         }
-        // 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);
+        }
+    }
+    /**
+     * Checks if the local policy matches the on-chain anchor.
+     */
+    async verifyPolicyAnchor() {
+        if (!this.policyRegistry)
+            return;
+        try {
+            console.log("[AgentWallet] Verifying policy against on-chain anchor...");
+            const onChain = await this.policyRegistry.getPolicy(this.address);
+            // Check 1: Freeze status
+            if (onChain.isFrozen) {
+                this.stopped = true;
+                throw new Error("Agent policy is FROZEN on-chain. Emergency stop activated.");
+            }
+            // Check 2: Hash mismatch
+            const localHash = hashPolicy(this.config);
+            // Note: We check if on-chain hash is set (non-zero) before enforcing
+            if (onChain.policyHash !== ethers_1.ethers.ZeroHash && onChain.policyHash !== localHash) {
+                const msg = `Policy Hash Mismatch! Local: ${localHash}, Chain: ${onChain.policyHash}`;
+                if (this.config?.strictPolicy) {
+                    throw new Error(msg);
+                }
+                else {
+                    console.warn(`[AgentWallet] WARN: ${msg}. Running in PERMISSIVE mode.`);
+                }
+            }
+            else {
+                console.log("[AgentWallet] ✅ Policy verified on-chain.");
+            }
+        }
+        catch (error) {
+            console.error("[AgentWallet] Anchor check failed:", error.message);
+            if (this.config?.strictPolicy)
+                throw error;
+        }
     }
     // ---------------- PUBLIC ----------------
     getAddress() {
@@ -246,7 +309,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 +322,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 +353,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 +366,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.d.ts

@@ -1,4 +1,5 @@
 import "dotenv/config";
+import { ethers } from "ethers";
 import { PaymentExecutor } from "./executors";
 import { PaymentRequest } from "./types";
 export declare class CronosUsdcExecutor implements PaymentExecutor {
@@ -11,4 +12,6 @@ export declare class CronosUsdcExecutor implements PaymentExecutor {
     private withRetry;
     execute(request: PaymentRequest): Promise<string>;
     getAddress(): string;
+    getProvider(): ethers.JsonRpcProvider;
+    getSigner(): ethers.Wallet;
 }

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,11 +108,17 @@ 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() {
         return this.wallet.address;
     }
+    getProvider() {
+        return this.provider;
+    }
+    getSigner() {
+        return this.wallet;
+    }
 }
 exports.CronosUsdcExecutor = CronosUsdcExecutor;

package/dist/internal/PolicyRegistryAdapter.d.ts

@@ -0,0 +1,32 @@
+import { ethers, Provider, Wallet } from "ethers";
+export interface OnChainPolicy {
+    dailySpendLimit: bigint;
+    maxPerTransaction: bigint;
+    policyHash: string;
+    isFrozen: boolean;
+    lastUpdated: bigint;
+}
+export interface PolicyInput {
+    dailySpendLimit: bigint;
+    maxPerTransaction: bigint;
+    policyHash: string;
+}
+export declare class PolicyRegistryAdapter {
+    private address;
+    private provider;
+    private signer?;
+    private contract;
+    constructor(address: string, provider: Provider, signer?: Wallet | undefined);
+    /**
+     * Reads the policy for the given agent from the blockchain.
+     * @param agentAddress The address to query
+     * @returns The policy struct or null if not found
+     */
+    getPolicy(agentAddress: string): Promise<OnChainPolicy>;
+    /**
+     * Writes the policy to the blockchain.
+     * @warning This is a gas-consuming transaction.
+     * @warning Should strictly be used during SETUP or RECOVERY, not during normal agent operation.
+     */
+    setPolicy(policy: PolicyInput): Promise<ethers.TransactionReceipt>;
+}

package/dist/internal/PolicyRegistryAdapter.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyRegistryAdapter = void 0;
+const ethers_1 = require("ethers");
+const ABI = [
+    "function getPolicy(address agentAddress) external view returns (uint256 dailySpendLimit, uint256 maxPerTransaction, bytes32 policyHash, bool isFrozen, uint256 lastUpdated)",
+    "function setPolicy(uint256 dailySpendLimit, uint256 maxPerTransaction, bytes32 policyHash) external",
+    "event PolicySet(address indexed agent, uint256 dailySpendLimit, uint256 maxPerTransaction, bytes32 policyHash, uint256 timestamp)"
+];
+class PolicyRegistryAdapter {
+    address;
+    provider;
+    signer;
+    contract;
+    constructor(address, provider, signer) {
+        this.address = address;
+        this.provider = provider;
+        this.signer = signer;
+        this.contract = new ethers_1.Contract(address, ABI, signer || provider);
+    }
+    /**
+     * Reads the policy for the given agent from the blockchain.
+     * @param agentAddress The address to query
+     * @returns The policy struct or null if not found
+     */
+    async getPolicy(agentAddress) {
+        return this.contract.getPolicy(agentAddress);
+    }
+    /**
+     * Writes the policy to the blockchain.
+     * @warning This is a gas-consuming transaction.
+     * @warning Should strictly be used during SETUP or RECOVERY, not during normal agent operation.
+     */
+    async setPolicy(policy) {
+        if (!this.signer) {
+            throw new Error("PolicyRegistryAdapter: No signer available for setPolicy");
+        }
+        // Runtime Guard: We add a parameter or check logic to prevent accidental usage.
+        // For now, explicit naming and documentation is the primary guard, plus the requirement of a signer.
+        const tx = await this.contract.setPolicy(policy.dailySpendLimit, policy.maxPerTransaction, policy.policyHash);
+        return tx.wait();
+    }
+}
+exports.PolicyRegistryAdapter = PolicyRegistryAdapter;

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.3",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [