cronos-agent-wallet 1.2.0

package/README.md

@@ -0,0 +1,102 @@
+# Cronos Merchant SDK
+
+The official SDK for building AI agents that can pay for resources on the Cronos blockchain using the x402 protocol.
+
+## 🛡️ Security Features (v1.1.1)
+- **Zero Trust Payer:** Derives identity strictly from chain data.
+- **Strong Replay Protection:** Enforces cryptographic binding of `merchantId + route + nonce`.
+- **Anti-Spoofing:** Validates payment challenges against requested routes before paying.
+- **Fail-Safe:** Supports "Fail Closed" mode for maximum security.
+
+Key features:
+*   **Automatic 402 Payments**: Handles "Payment Required" challenges seamlessly.
+*   **Multi-Chain**: Auto-negotiates with backends (EVM/Solana support).
+*   **Safe**: Built-in daily spending limits and policy controls.
+*   **Type-Safe**: Generic `fetch` and structured `AgentError` handling.
+
+## Installation
+
+```bash
+npm install @cronos-merchant/sdk ethers
+```
+
+## Quick Start
+
+```typescript
+import { AgentClient, AgentError } from "@cronos-merchant/sdk";
+
+// 1. Initialize
+const agent = new AgentClient({
+  privateKey: process.env.AGENT_KEY,
+  rpcUrl: "https://evm-t3.cronos.org", // Cronos Testnet
+  chainId: 338,
+  usdcAddress: "0xc01..." // Your payment token
+});
+
+async function main() {
+  try {
+    // 2. Fetch paid resources (just like axios/fetch)
+    const response = await agent.fetch<{ answer: string }>("http://localhost:3000/premium", {
+        method: "POST",
+        body: { prompt: "Hello World" }
+    });
+    
+    console.log("Success:", response.answer);
+
+  } catch (err: any) {
+    // 3. Handle Errors
+    if (err instanceof AgentError) {
+        console.error(`Status: ${err.status}`); // 402, 500
+        console.error(`Code: ${err.code}`);     // POLICY_REJECTED, NETWORK_ERROR
+    }
+  }
+}
+```
+
+## Configuration
+
+`new AgentClient(config)`
+
+| Option | Type | Required | Description |
+| :--- | :--- | :--- | :--- |
+| `privateKey` | `string` | Yes | EVM private key for the agent wallet. |
+| `rpcUrl` | `string` | Yes | RPC Endpoint (e.g., Cronos Testnet). |
+| `chainId` | `number` | Yes | Chain ID (e.g., 338). Sent to backend for negotiation. |
+| `usdcAddress` | `string` | Yes | ERC20 Token Address used for payment. |
+| `dailyLimit` | `number` | No | Max USDC allowed to spend per 24h. Default: 1.0 |
+| `allowedMerchants` | `string[]` | No | List of Merchant IDs to trust. If empty, allows all. |
+| `trustedFacilitators` | `string[]` | No | List of Gateway URLs to trust (e.g., localhost). |
+
+## API Reference
+
+### `agent.fetch<T>(url, options): Promise<T>`
+
+Performs an HTTP request. If the server responds with **402 Payment Required**:
+1.  SDK parses the payment request (from Headers or Body).
+2.  Checks spending policies (Daily Limit, Whitelist).
+3.  Executes the payment on-chain.
+4.  Retries the original request with the Payment Proof.
+
+**Generics**:
+Pass the expected response type `<T>` for TypeScript autocomplete.
+
+**Options**:
+*   `method`: "GET" | "POST"
+*   `headers`: Dictionary of headers.
+*   `body`: JSON object or string.
+*   `allowBodyFallback`: `boolean`. Defaults to `false`. Set to `true` to allow parsing 402 details from the response body if headers are missing. DANGEROUS: Only use with trusted facilitators.
+
+### `AgentError`
+
+Thrown when a request fails or is blocked by policy.
+
+*   `err.status`: The HTTP status code (e.g., 400, 402, 500).
+*   `err.code`: A machine-readable string:
+    *   `POLICY_REJECTED`: Blocked by daily limit or whitelist.
+    *   `INSUFFICIENT_FUNDS`: Not enough USDC/Gas.
+    *   `HTTP_ERROR`: Server returned an error (details in `err.details`).
+*   `err.details`: The raw response body from the server.
+
+## License
+
+MIT

package/dist/AgentClient.d.ts

@@ -0,0 +1,46 @@
+import { AgentConfig } from "./config";
+/**
+ * AgentClient
+ * -----------
+ * Public SDK entry.
+ * - One instance per user/session
+ * - Wraps wallet + executor + x402 flow
+ */
+export declare class AgentClient {
+    private wallet;
+    private context;
+    constructor(config: AgentConfig);
+    /**
+     * agent.fetch()
+     * --------------
+     * Drop-in replacement for fetch/axios
+     * Handles:
+     * - free APIs
+     * - x402 paid APIs
+     * - auto-pay + retry
+     */
+    fetch<T>(url: string, options?: {
+        method?: "GET" | "POST";
+        headers?: Record<string, string>;
+        body?: any;
+        allowBodyFallback?: boolean;
+    }): Promise<T>;
+    fetchWithDetails<T>(url: string, options?: {
+        method?: "GET" | "POST";
+        headers?: Record<string, string>;
+        body?: any;
+        timeoutMs?: number;
+        allowBodyFallback?: boolean;
+    }): Promise<{
+        data: T;
+        payment: any;
+    }>;
+    /**
+     * Emergency stop
+     */
+    stop(): void;
+    /**
+     * Wallet address (agent wallet)
+     */
+    getAddress(): string;
+}

package/dist/AgentClient.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentClient = void 0;
+// AgentClient.ts
+const AgentWallet_1 = require("./internal/AgentWallet");
+const CronosUsdcExecutor_1 = require("./internal/CronosUsdcExecutor");
+const x402ToolClient_1 = require("./internal/x402ToolClient");
+/**
+ * AgentClient
+ * -----------
+ * Public SDK entry.
+ * - One instance per user/session
+ * - Wraps wallet + executor + x402 flow
+ */
+class AgentClient {
+    wallet;
+    context;
+    constructor(config) {
+        if (!config.privateKey) {
+            throw new Error("AgentClient: privateKey is required");
+        }
+        if (!config.rpcUrl) {
+            throw new Error("AgentClient: rpcUrl is required");
+        }
+        if (!config.chainId) {
+            throw new Error("AgentClient: chainId is required");
+        }
+        // 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,
+        });
+        // 3. Context passed per request
+        this.context = {
+            chainId: config.chainId,
+            merchantId: config.merchantId,
+            analyticsUrl: config.analyticsUrl
+        };
+    }
+    /**
+     * agent.fetch()
+     * --------------
+     * Drop-in replacement for fetch/axios
+     * Handles:
+     * - free APIs
+     * - x402 paid APIs
+     * - auto-pay + retry
+     */
+    async fetch(url, options) {
+        const res = await this.fetchWithDetails(url, options);
+        return res.data;
+    }
+    async fetchWithDetails(url, options) {
+        console.log("[SDK] AgentClient.fetch called");
+        console.log(`[SDK] URL: ${url}`);
+        console.log(`[SDK] Options:`, options);
+        return (0, x402ToolClient_1.x402Request)(url, this.wallet, this.context, options);
+    }
+    /**
+     * Emergency stop
+     */
+    stop() {
+        this.wallet.emergencyStop();
+    }
+    /**
+     * Wallet address (agent wallet)
+     */
+    getAddress() {
+        return this.wallet.getAddress();
+    }
+}
+exports.AgentClient = AgentClient;

package/dist/check_autovvs.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/check_autovvs.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const RPC = "https://evm.cronos.org";
+const ADDR = "0xA6fF77fC8E839679D4F7408E8988B564dE1A2dcD";
+const USER = "0x2149AbA8305029f8Db6dBC858dadf4112832D0ff";
+async function check() {
+    const provider = new ethers_1.ethers.JsonRpcProvider(RPC);
+    // Probe userInfo structure and balanceOf (no args)
+    const abi = [
+        "function userInfo(address) view returns (uint256 shares, uint256 lastDepositedTime, uint256 cakeAtLastUserAction, uint256 lastUserActionTime)", // Standard VVS Vault pattern guess
+        "function balanceOf() view returns (uint256)",
+        "function getPricePerFullShare() view returns (uint256)"
+    ];
+    const contract = new ethers_1.ethers.Contract(ADDR, abi, provider);
+    try {
+        console.log("Calling balanceOf()..."); // Total vault balance
+        const bal = await contract.balanceOf();
+        console.log("✅ Total Vault Balance:", bal.toString());
+    }
+    catch (e) {
+        console.log("⚠️ balanceOf() failed:", e.reason || e.message);
+    }
+    try {
+        console.log(`Calling userInfo(${USER})...`);
+        // We try to fetch it as an array/object to see what comes back
+        const info = await contract.userInfo(USER);
+        console.log("✅ userInfo result:", info);
+    }
+    catch (e) {
+        console.log("⚠️ userInfo failed:", e.reason || e.message);
+        // Fallback: try simpler ABI if the struct guess failed
+        try {
+            const abiSimple = ["function userInfo(address) view returns (uint256, uint256, uint256, uint256)"];
+            const c2 = new ethers_1.ethers.Contract(ADDR, abiSimple, provider);
+            const info2 = await c2.userInfo(USER);
+            console.log("✅ userInfo (generic) result:", info2);
+        }
+        catch (ex) {
+            console.log("❌ userInfo generic failed:", ex.reason || ex.message);
+        }
+    }
+}
+check();

package/dist/check_contract.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/check_contract.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const RPC = "https://evm.cronos.org";
+const ADDR = "0xA6fF77fC8E839679D4F7408E8988B564dE1A2dcD";
+async function check() {
+    const provider = new ethers_1.ethers.JsonRpcProvider(RPC);
+    console.log(`Checking code at ${ADDR} on ${RPC}...`);
+    const code = await provider.getCode(ADDR);
+    console.log(`Code length: ${code.length}`);
+    if (code === "0x") {
+        console.log("❌ No code found (EOA or empty).");
+        return;
+    }
+    console.log("✅ Contract code found.");
+    const abi = [
+        "function name() view returns (string)",
+        "function symbol() view returns (string)",
+        "function poolLength() view returns (uint256)",
+        "function balanceOf(address) view returns (uint256)"
+    ];
+    const contract = new ethers_1.ethers.Contract(ADDR, abi, provider);
+    try {
+        console.log("Probing name()...");
+        const name = await contract.name();
+        console.log("✅ Name:", name);
+    }
+    catch (e) {
+        console.log("⚠️ name() failed");
+    }
+    try {
+        console.log("Probing poolLength()...");
+        const len = await contract.poolLength();
+        console.log("✅ poolLength:", len.toString());
+    }
+    catch (e) {
+        console.log("⚠️ poolLength() failed");
+    }
+    try {
+        console.log("Probing balanceOf(random)...");
+        const bal = await contract.balanceOf("0x000000000000000000000000000000000000dead");
+        console.log("✅ balanceOf:", bal.toString());
+    }
+    catch (e) {
+        console.log("⚠️ balanceOf() failed");
+    }
+}
+check();

package/dist/config.d.ts

@@ -0,0 +1,12 @@
+export interface AgentConfig {
+    privateKey: string;
+    rpcUrl: string;
+    chainId: number;
+    usdcAddress: string;
+    dailyLimit?: number;
+    maxPerTransaction?: number;
+    allowedMerchants?: string[];
+    trustedFacilitators?: string[];
+    analyticsUrl?: string;
+    merchantId?: string;
+}

package/dist/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/demo.d.ts

@@ -0,0 +1 @@
+import "dotenv/config";

package/dist/demo.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// demo.ts
+require("dotenv/config");
+const AgentWallet_1 = require("./internal/AgentWallet");
+const CronosUsdcExecutor_1 = require("./internal/CronosUsdcExecutor");
+const x402ToolClient_1 = require("./internal/x402ToolClient");
+const ethers_1 = require("ethers");
+const VvsYieldExecutor_1 = require("./internal/VvsYieldExecutor");
+async function run() {
+    // --------------------------------------------------
+    // 1. Merchant API
+    // --------------------------------------------------
+    const MERCHANT_API_URL = "http://localhost:3001";
+    const TARGET_PATH = "/photos";
+    const FULL_URL = `${MERCHANT_API_URL}${TARGET_PATH}`;
+    // --------------------------------------------------
+    // 2. RPCs
+    // --------------------------------------------------
+    const MAINNET_RPC = "https://evm.cronos.org";
+    const TESTNET_RPC = process.env.CRONOS_RPC_URL || "https://evm-t3.cronos.org";
+    const USDC_ADDR = process.env.USDC_CONTRACT_ADDRESS ||
+        "0xc01efAaF7C5C61bEbFAeb358E1161b537b8bC0e0";
+    const PRIVATE_KEY = process.env.AGENT_WALLET_PRIVATE_KEY;
+    if (!PRIVATE_KEY)
+        throw new Error("Missing AGENT_WALLET_PRIVATE_KEY");
+    // --------------------------------------------------
+    // 3. Agent (payments)
+    // --------------------------------------------------
+    const paymentExecutor = new CronosUsdcExecutor_1.CronosUsdcExecutor(TESTNET_RPC, PRIVATE_KEY, USDC_ADDR, 338);
+    const wallet = new AgentWallet_1.AgentWallet(new ethers_1.ethers.Wallet(PRIVATE_KEY).address, paymentExecutor);
+    // --------------------------------------------------
+    // 4. AutoVVS Yield Sensor (Mainnet)
+    // --------------------------------------------------
+    const provider = new ethers_1.ethers.JsonRpcProvider(MAINNET_RPC);
+    const ethersWallet = new ethers_1.ethers.Wallet(PRIVATE_KEY, provider);
+    const yieldExec = new VvsYieldExecutor_1.VvsYieldExecutor(provider, ethersWallet);
+    console.log("--------------------------------------------------");
+    console.log(`🤖 AGENT: ${ethersWallet.address}`);
+    console.log("🌱 AutoVVS Vault: read-only position");
+    console.log("--------------------------------------------------");
+    try {
+        const pos = await yieldExec.getVaultPosition();
+        console.log("📊 Vault Position (RAW):", {
+            shares: pos.shares.toString(),
+            pricePerShare: pos.pricePerShare.toString(),
+            underlyingValue: pos.underlyingValue.toString()
+        });
+        console.log("📊 Underlying (formatted, 18d):", ethers_1.ethers.formatUnits(pos.underlyingValue, 18));
+    }
+    catch (err) {
+        console.error("❌ AutoVVS sensor error:", err.message);
+    }
+    // --------------------------------------------------
+    // 5. x402 flow (unchanged)
+    // --------------------------------------------------
+    console.log(`[x402] Negotiating access for: ${TARGET_PATH}...`);
+    try {
+        const result = await (0, x402ToolClient_1.x402Request)(FULL_URL, wallet, {
+            chainId: 338,
+            merchantId: "b9805b9e-fa6c-4640-8470-f5b230dee6d4"
+        }, {});
+        console.log("✅ Success! Data Received:");
+        console.dir(result, { depth: null });
+    }
+    catch (error) {
+        console.error(`❌ Failed: ${error.message}`);
+    }
+}
+run();

package/dist/errors.d.ts

@@ -0,0 +1,9 @@
+export type AgentErrorCode = "POLICY_REJECTED" | "INSUFFICIENT_FUNDS" | "UNTRUSTED_FACILITATOR" | "DAILY_LIMIT_EXCEEDED" | "NETWORK_ERROR" | "HTTP_ERROR" | "PROTOCOL_ERROR" | "UNKNOWN_ERROR";
+export declare class AgentError extends Error {
+    message: string;
+    code: AgentErrorCode;
+    status?: number | undefined;
+    details?: any | undefined;
+    constructor(message: string, code?: AgentErrorCode, status?: number | undefined, // HTTP Status (400, 402, 500)
+    details?: any | undefined);
+}

package/dist/errors.js

@@ -0,0 +1,21 @@
+"use strict";
+// errors.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentError = void 0;
+class AgentError extends Error {
+    message;
+    code;
+    status;
+    details;
+    constructor(message, code = "UNKNOWN_ERROR", status, // HTTP Status (400, 402, 500)
+    details // Full response body or context
+    ) {
+        super(message);
+        this.message = message;
+        this.code = code;
+        this.status = status;
+        this.details = details;
+        this.name = "AgentError";
+    }
+}
+exports.AgentError = AgentError;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { AgentClient } from "./AgentClient";
+export type { AgentConfig } from "./config";
+export { AgentError } from "./errors";

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentError = exports.AgentClient = void 0;
+var AgentClient_1 = require("./AgentClient");
+Object.defineProperty(exports, "AgentClient", { enumerable: true, get: function () { return AgentClient_1.AgentClient; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "AgentError", { enumerable: true, get: function () { return errors_1.AgentError; } });

package/dist/internal/AgentWallet.d.ts

@@ -0,0 +1,50 @@
+import { PaymentRequest, WalletContext, AgentWalletConfig } from "./types";
+import { PaymentExecutor } from "./executors";
+/**
+ * AgentWallet
+ * ------------
+ * - Owns identity (address)
+ * - Decides whether to pay
+ * - Delegates execution to PaymentExecutor
+ * - Enforces security + policy
+ * - Persists state (Isomorphic: FS or LocalStorage)
+ */
+export declare class AgentWallet {
+    private readonly address;
+    private readonly executor;
+    private dailyLimit;
+    private maxPerTransaction;
+    private spentToday;
+    private lastResetDate;
+    private allowedMerchants;
+    private trustedFacilitatorOrigins;
+    private stopped;
+    private persistence;
+    /**
+     * Replay protection
+     * key -> timestamp
+     */
+    private paidRequests;
+    constructor(address: string, executor: PaymentExecutor, config?: AgentWalletConfig);
+    private getTodayDate;
+    private loadState;
+    private saveState;
+    getAddress(): string;
+    private getHeader;
+    private canonicalOrigin;
+    /**
+     * Strong uniqueness:
+     * merchant + route + nonce
+     */
+    private paymentKey;
+    parse402Header(headers: any): PaymentRequest;
+    parse402Body(body: any, defaultMerchantId: string, requestUrl: string): PaymentRequest;
+    emergencyStop(): void;
+    shouldPay(request: PaymentRequest, context: WalletContext, originalChallenge?: {
+        route?: string;
+    }): {
+        allow: boolean;
+        reason?: string;
+    };
+    executePayment(request: PaymentRequest): Promise<string>;
+}

package/dist/internal/AgentWallet.js

@@ -0,0 +1,304 @@
+"use strict";
+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));
+    }
+}
+/**
+ * AgentWallet
+ * ------------
+ * - Owns identity (address)
+ * - Decides whether to pay
+ * - Delegates execution to PaymentExecutor
+ * - Enforces security + policy
+ * - Persists state (Isomorphic: FS or LocalStorage)
+ */
+class AgentWallet {
+    address;
+    executor;
+    // ---------------- CONFIG ----------------
+    // Reduced limit for testing persistence (0.5 USDC)
+    dailyLimit = 0.5;
+    maxPerTransaction = 0.5; // Default safe limit
+    spentToday = 0.0;
+    lastResetDate = "";
+    allowedMerchants = new Set([]);
+    trustedFacilitatorOrigins = new Set([
+        "http://localhost:5000",
+        "http://localhost:3000",
+        "https://agentx402.onrender.com",
+        "https://cronos-x-402-production.up.railway.app",
+    ]);
+    stopped = false;
+    persistence;
+    /**
+     * Replay protection
+     * key -> timestamp
+     */
+    paidRequests = new Map();
+    constructor(address, executor, config) {
+        this.address = address;
+        this.executor = executor;
+        if (config) {
+            if (config.dailyLimit !== undefined)
+                this.dailyLimit = config.dailyLimit;
+            if (config.maxPerTransaction !== undefined)
+                this.maxPerTransaction = config.maxPerTransaction;
+            if (config.allowedMerchants)
+                this.allowedMerchants = new Set(config.allowedMerchants);
+            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();
+    }
+    // ---------------- 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));
+            }
+            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));
+            }
+        }
+        else {
+            // Initialize fresh
+            this.lastResetDate = this.getTodayDate();
+        }
+    }
+    saveState() {
+        const state = {
+            lastResetDate: this.lastResetDate,
+            spentToday: this.spentToday,
+            paidRequests: Array.from(this.paidRequests.entries())
+        };
+        this.persistence.save(state);
+    }
+    // ---------------- PUBLIC ----------------
+    getAddress() {
+        return this.address;
+    }
+    // ---------------- HELPERS ----------------
+    getHeader(headers, key) {
+        return headers[key] ?? headers[key.toLowerCase()];
+    }
+    canonicalOrigin(url) {
+        try {
+            return new URL(url).origin;
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Strong uniqueness:
+     * merchant + route + nonce
+     */
+    paymentKey(req) {
+        return `${req.merchantId}:${req.route}:${req.nonce}`;
+    }
+    // ---------------- x402 PARSER ----------------
+    parse402Header(headers) {
+        const amount = this.getHeader(headers, "x-payment-amount");
+        const currency = this.getHeader(headers, "x-payment-currency");
+        const payTo = this.getHeader(headers, "x-payment-payto");
+        const merchantId = this.getHeader(headers, "x-merchant-id");
+        const facilitatorUrl = this.getHeader(headers, "x-facilitator-url");
+        const chainId = this.getHeader(headers, "x-chain-id");
+        const route = this.getHeader(headers, "x-route");
+        const nonce = this.getHeader(headers, "x-nonce");
+        if (!amount ||
+            !currency ||
+            !payTo ||
+            !merchantId ||
+            !facilitatorUrl ||
+            !chainId ||
+            !route ||
+            !nonce) {
+            throw new Error("Malformed x402 payment headers");
+        }
+        return {
+            amount: Number(amount),
+            currency,
+            payTo,
+            merchantId,
+            facilitatorUrl,
+            chainId: Number(chainId),
+            route,
+            nonce,
+        };
+    }
+    parse402Body(body, defaultMerchantId, requestUrl) {
+        // Expecting body structure:
+        // { paymentRequest: { chainId, currency, receiver, amount, token ... } }
+        // Support both wrapped { paymentRequest: ... } and raw { ... } structures
+        // Robust strategy: Check if 'paymentRequest' key exists, otherwise assume body IS the request if it has 'amount'
+        let req = body?.paymentRequest || body;
+        // Double check deep nesting (some frameworks might wrap twice)
+        if (req?.paymentRequest)
+            req = req.paymentRequest;
+        if (!req) {
+            throw new Error("Missing 'paymentRequest' in response body");
+        }
+        const amount = req.amount;
+        const currency = req.currency;
+        const payTo = req.receiver;
+        // Body usually doesn't repeat merchantId
+        const merchantId = defaultMerchantId;
+        const facilitatorUrl = requestUrl;
+        const chainId = req.chainId;
+        const route = "premium";
+        // [SECURITY] NONCE AUTHORITY
+        // Server MUST provide nonce. No fallbacks allowed.
+        const nonce = req.nonce;
+        if (!nonce) {
+            throw new Error("Missing 'nonce' in 402 body - Server is the sole nonce authority.");
+        }
+        if (!amount || !currency || !payTo || !chainId) {
+            throw new Error(`Incomplete 402 body: ${JSON.stringify(req)}`);
+        }
+        return {
+            amount: Number(amount),
+            currency,
+            payTo,
+            merchantId,
+            facilitatorUrl, // Contextual
+            chainId: Number(chainId),
+            route,
+            nonce,
+        };
+    }
+    // ---------------- RULES ENGINE ----------------
+    emergencyStop() {
+        this.stopped = true;
+        console.warn("[WALLET] Emergency stop activated!");
+    }
+    shouldPay(request, context, originalChallenge) {
+        // -1. Emergency Stop
+        if (this.stopped) {
+            return { allow: false, reason: "Emergency stop active" };
+        }
+        // [SECURITY] Spoofing Check
+        // Ensure the route we are paying for matches the invalid route (if known)
+        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") {
+            return { allow: false, reason: `Unsupported currency: ${request.currency}` };
+        }
+        // 1. Chain verification
+        if (request.chainId !== context.chainId) {
+            return { allow: false, reason: "ChainId mismatch" };
+        }
+        // 2. Facilitator trust
+        const origin = this.canonicalOrigin(request.facilitatorUrl);
+        if (!this.trustedFacilitatorOrigins.has(origin)) {
+            return { allow: false, reason: "Untrusted facilitator" };
+        }
+        // 3. Merchant allowlist
+        // Enabled for safety test
+        if (this.allowedMerchants.size > 0 && !this.allowedMerchants.has(request.merchantId)) {
+            return { allow: false, reason: `Merchant not allowlisted: ${request.merchantId}` };
+        }
+        // 4. Daily spend limit
+        // Floating point fix: Use a small epsilon or round
+        if ((this.spentToday + request.amount) > (this.dailyLimit + 0.0001)) {
+            return { allow: false, reason: `Daily limit exceeded (${this.spentToday.toFixed(2)} + ${request.amount} > ${this.dailyLimit})` };
+        }
+        // 5. Max Per Transaction Check
+        if (request.amount > (this.maxPerTransaction + 0.0001)) {
+            return { allow: false, reason: `Transaction limit exceeded (${request.amount} > ${this.maxPerTransaction})` };
+        }
+        return { allow: true };
+    }
+    // ---------------- PAYMENT EXECUTION ----------------
+    async executePayment(request) {
+        const key = this.paymentKey(request);
+        if (this.paidRequests.has(key)) {
+            throw new Error("Replay detected: payment already executed");
+        }
+        // Execute chain tx
+        const proof = await this.executor.execute(request);
+        // Update state
+        this.spentToday += request.amount;
+        this.paidRequests.set(key, Date.now());
+        // Persist immediately
+        this.saveState();
+        return proof;
+    }
+}
+exports.AgentWallet = AgentWallet;

package/dist/internal/CronosUsdcExecutor.d.ts

@@ -0,0 +1,14 @@
+import "dotenv/config";
+import { PaymentExecutor } from "./executors";
+import { PaymentRequest } from "./types";
+export declare class CronosUsdcExecutor implements PaymentExecutor {
+    private provider;
+    private wallet;
+    private usdc;
+    private chainId;
+    constructor(rpcUrl: string, privateKey: string, usdcAddress: string, expectedChainId?: number);
+    private verifyChain;
+    private withRetry;
+    execute(request: PaymentRequest): Promise<string>;
+    getAddress(): string;
+}

package/dist/internal/CronosUsdcExecutor.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronosUsdcExecutor = void 0;
+require("dotenv/config");
+const ethers_1 = require("ethers");
+const errors_1 = require("../errors");
+const ERC20_ABI = [
+    "function transfer(address to, uint256 amount) returns (bool)",
+    "function balanceOf(address owner) view returns (uint256)",
+];
+const CONFIRMATIONS = 1; // safe for Cronos testnet
+const TX_TIMEOUT_MS = 60_000; // 60s timeout
+class CronosUsdcExecutor {
+    provider;
+    wallet;
+    usdc;
+    chainId;
+    constructor(rpcUrl, privateKey, usdcAddress, expectedChainId) {
+        this.provider = new ethers_1.ethers.JsonRpcProvider(rpcUrl);
+        const signingKey = new ethers_1.ethers.SigningKey(privateKey);
+        this.wallet = new ethers_1.ethers.Wallet(signingKey, this.provider);
+        this.usdc = new ethers_1.ethers.Contract(usdcAddress, ERC20_ABI, this.wallet);
+        // Optional but recommended
+        if (expectedChainId) {
+            this.verifyChain(expectedChainId);
+        }
+    }
+    // ---------------- SAFETY ----------------
+    async verifyChain(expectedChainId) {
+        const network = await this.provider.getNetwork();
+        this.chainId = Number(network.chainId);
+        if (this.chainId !== expectedChainId) {
+            throw new Error(`ChainId mismatch: expected ${expectedChainId}, got ${this.chainId} `);
+        }
+        console.log(`[CRONOS] Connected to chainId ${this.chainId} `);
+    }
+    // ---------------- EXECUTION ----------------
+    async withRetry(fn, retries = 3) {
+        let lastError;
+        for (let i = 0; i < retries; i++) {
+            try {
+                return await fn();
+            }
+            catch (e) {
+                lastError = e;
+                // Don't retry revert errors
+                if (e.code === 'CALL_EXCEPTION' || e.code === 'INSUFFICIENT_FUNDS')
+                    throw e;
+                await new Promise(r => setTimeout(r, 1000 * Math.pow(2, i)));
+            }
+        }
+        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));
+        // 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} `);
+        }
+        // ... 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
+        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
+        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
+        const receipt = await Promise.race([
+            this.withRetry(() => tx.wait(CONFIRMATIONS)),
+            new Promise((_, reject) => setTimeout(() => reject(new Error("Transaction confirmation timeout")), TX_TIMEOUT_MS)),
+        ]);
+        if (!receipt || receipt.status !== 1) {
+            throw new Error("USDC transfer failed (Reverted)");
+        }
+        console.log(`[CRONOS] Payment confirmed: ${receipt.hash} `);
+        return receipt.hash;
+    }
+    getAddress() {
+        return this.wallet.address;
+    }
+}
+exports.CronosUsdcExecutor = CronosUsdcExecutor;

package/dist/internal/VvsYieldExecutor.d.ts

@@ -0,0 +1,18 @@
+import { ethers } from "ethers";
+import { YieldExecutor } from "./YieldExecutor";
+export declare class VvsYieldExecutor implements YieldExecutor {
+    private readonly provider;
+    private readonly wallet;
+    private vault;
+    constructor(provider: ethers.JsonRpcProvider, wallet: ethers.Wallet, vaultAddress?: string);
+    /**
+     * READ-ONLY SENSOR (Phase 5A)
+     * All values are RAW bigint
+     */
+    getVaultPosition(): Promise<{
+        shares: bigint;
+        pricePerShare: bigint;
+        underlyingValue: bigint;
+    }>;
+    harvest(): Promise<number>;
+}

package/dist/internal/VvsYieldExecutor.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VvsYieldExecutor = void 0;
+// internal/VvsYieldExecutor.ts
+const ethers_1 = require("ethers");
+// Minimal AutoVVS vault ABI (verified)
+const AUTO_VVS_VAULT_ABI = [
+    "function userInfo(address) view returns (uint256 shares, uint256 lastDepositedTime, uint256 cakeAtLastUserAction, uint256 lastUserActionTime)",
+    "function getPricePerFullShare() view returns (uint256)"
+];
+// Cronos Mainnet AutoVVS Vault
+const AUTO_VVS_VAULT = "0xA6fF77fC8E839679D4F7408E8988B564dE1A2dcD";
+class VvsYieldExecutor {
+    provider;
+    wallet;
+    vault;
+    constructor(provider, wallet, vaultAddress = AUTO_VVS_VAULT) {
+        this.provider = provider;
+        this.wallet = wallet;
+        this.vault = new ethers_1.ethers.Contract(vaultAddress, AUTO_VVS_VAULT_ABI, this.provider);
+    }
+    /**
+     * READ-ONLY SENSOR (Phase 5A)
+     * All values are RAW bigint
+     */
+    async getVaultPosition() {
+        const [userInfo, pricePerShare] = await Promise.all([
+            this.vault.userInfo(this.wallet.address),
+            this.vault.getPricePerFullShare()
+        ]);
+        const shares = userInfo[0];
+        /**
+         * Convention:
+         * pricePerShare is scaled by 1e18
+         */
+        const underlyingValue = (shares * pricePerShare) / 10n ** 18n;
+        return {
+            shares,
+            pricePerShare,
+            underlyingValue
+        };
+    }
+    // 🚫 Phase 5A boundary
+    async harvest() {
+        throw new Error("harvest() not implemented (AutoVVS Phase 5A)");
+    }
+}
+exports.VvsYieldExecutor = VvsYieldExecutor;

package/dist/internal/YieldExecutor.d.ts

@@ -0,0 +1,4 @@
+export interface YieldExecutor {
+    getVaultPosition(): Promise<any>;
+    harvest(): Promise<number>;
+}

package/dist/internal/YieldExecutor.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/internal/executors.d.ts

@@ -0,0 +1,7 @@
+import { PaymentRequest } from "./types";
+export interface PaymentExecutor {
+    execute(request: PaymentRequest): Promise<string>;
+}
+export declare class MockPaymentExecutor implements PaymentExecutor {
+    execute(request: PaymentRequest): Promise<string>;
+}

package/dist/internal/executors.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockPaymentExecutor = void 0;
+// Phase 3A — Mock executor
+class MockPaymentExecutor {
+    async execute(request) {
+        console.log(`[EXECUTOR] Paying ${request.amount} ${request.currency} to ${request.payTo}`);
+        return `mock_tx_${Date.now()}`;
+    }
+}
+exports.MockPaymentExecutor = MockPaymentExecutor;

package/dist/internal/types.d.ts

@@ -0,0 +1,21 @@
+export interface PaymentRequest {
+    amount: number;
+    currency: string;
+    payTo: string;
+    merchantId: string;
+    facilitatorUrl: string;
+    chainId: number;
+    route: string;
+    nonce: string;
+}
+export interface WalletContext {
+    chainId: number;
+    merchantId?: string;
+    analyticsUrl?: string;
+}
+export interface AgentWalletConfig {
+    dailyLimit?: number;
+    maxPerTransaction?: number;
+    trustedFacilitators?: string[];
+    allowedMerchants?: string[];
+}

package/dist/internal/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/internal/wallet-state.json

@@ -0,0 +1,14 @@
+{
+  "lastResetDate": "2026-01-12",
+  "spentToday": 0.2,
+  "paidRequests": [
+    [
+      "a644d13b-b537-4ad5-bc5a-65705fd3ccec:POST /api/premium:rnvj9m",
+      1768211109096
+    ],
+    [
+      "a644d13b-b537-4ad5-bc5a-65705fd3ccec:POST /api/premium:mnuc9o",
+      1768211999104
+    ]
+  ]
+}

package/dist/internal/x402ToolClient.d.ts

@@ -0,0 +1,20 @@
+import { AgentWallet } from "./AgentWallet";
+import { WalletContext } from "./types";
+export declare function x402Request(url: string, wallet: AgentWallet, context: WalletContext, options?: {
+    method?: "GET" | "POST";
+    headers?: Record<string, string>;
+    body?: any;
+    timeoutMs?: number;
+    allowBodyFallback?: boolean;
+}): Promise<{
+    data: any;
+    payment: null;
+} | {
+    data: any;
+    payment: {
+        txHash: string;
+        amount: number;
+        currency: string;
+        chainId: number;
+    };
+}>;

package/dist/internal/x402ToolClient.js

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.x402Request = x402Request;
+const axios_1 = __importDefault(require("axios"));
+const errors_1 = require("../errors");
+const HTTP_TIMEOUT_MS = 180_000;
+// Helper for fire-and-forget logging
+async function logDecision(context, agentAddress, req, decision, reason, txHash) {
+    if (!context.analyticsUrl)
+        return;
+    // Non-blocking catch
+    axios_1.default.post(`${context.analyticsUrl}/api/analytics/log`, {
+        agentAddress,
+        url: req.facilitatorUrl,
+        merchantId: req.merchantId,
+        amount: req.amount,
+        currency: req.currency,
+        decision,
+        reason,
+        txHash,
+        chainId: context.chainId
+    }).catch(err => {
+        // Silent fail for analytics to not break flow
+    });
+}
+async function x402Request(url, wallet, context, options = {}) {
+    let paymentAttempted = false; // 🛡️ CRITICAL: Prevents the "Drain Loop"
+    // 0. Version Check
+    console.log("[SDK] v1.0.4 - ROBUST MODE");
+    // Normalize inputs to support both nested headers and flat structure
+    const { method, body, headers, ...rest } = options;
+    // MERGE both sources: flat properties (rest) and nested headers
+    const effectiveHeaders = { ...rest, ...(headers || {}) };
+    try {
+        // 1. Initial attempt to fetch data
+        const res = await (0, axios_1.default)({
+            url,
+            method: method ?? "GET",
+            data: body,
+            headers: {
+                ...effectiveHeaders,
+                "x-merchant-id": context.merchantId || "",
+                "x-chain-id": context.chainId.toString(),
+            },
+            timeout: options.timeoutMs ?? HTTP_TIMEOUT_MS,
+            validateStatus: (status) => status === 200 || status === 402,
+        });
+        if (res.status === 200) {
+            return { data: res.data, payment: null };
+        }
+        // 2. 402 Flow
+        console.log("[x402] Payment Required Challenge received");
+        console.log("[SDK] Response Headers:", JSON.stringify(res.headers, null, 2));
+        console.log("[SDK] Response Body:", JSON.stringify(res.data, null, 2));
+        if (paymentAttempted) {
+            // If the server asks for pay again immediately after we just paid, something is wrong.
+            throw new Error("Recursive 402 detected: Server refused proof or loop occurred.");
+        }
+        let paymentRequest;
+        try {
+            paymentRequest = wallet.parse402Header(res.headers);
+        }
+        catch (headerErr) {
+            // [SECURITY] Explicit Opt-In for Body Fallback
+            if (!options.allowBodyFallback) {
+                throw new Error("402 Header Parsing Failed and allowBodyFallback is disabled. Server must provide X-Payment headers.");
+            }
+            console.warn("[SDK] parsing headers failed, trying body...", headerErr);
+            try {
+                paymentRequest = wallet.parse402Body(res.data, context.merchantId || "unknown", url);
+            }
+            catch (bodyErr) {
+                throw new Error(`Failed to parse 402 challenge from Headers OR Body. Header error: ${headerErr}. Body error: ${bodyErr}`);
+            }
+        }
+        const decision = wallet.shouldPay(paymentRequest, context, {
+            route: wallet.parse402Header(res.headers).route // Validate against what the server claimed in headers
+        });
+        const agentAddress = wallet.getAddress();
+        if (!decision.allow) {
+            logDecision(context, agentAddress, paymentRequest, "BLOCKED", decision.reason);
+            throw new Error(`Agent Policy Rejection: ${decision.reason}`);
+        }
+        // Mark as attempted BEFORE the async call
+        paymentAttempted = true;
+        // 3. Execute Payment (Authorized)
+        console.log(`[x402] Payment Approved. Executing on Chain ${context.chainId}...`);
+        let txHash;
+        try {
+            txHash = await wallet.executePayment(paymentRequest);
+        }
+        catch (execErr) {
+            logDecision(context, agentAddress, paymentRequest, "BLOCKED", `Execution Failed: ${execErr.message}`);
+            throw execErr;
+        }
+        logDecision(context, agentAddress, paymentRequest, "APPROVED", "Paid", txHash);
+        // 4. Retry Request with Payment Proof
+        console.log(`[x402] Payment Successful (${txHash}). Retrying request...`);
+        // [SECURITY] Protocol Alignment
+        // Must send: x-payment-proof (txHash) AND x-nonce (to verify binding)
+        const retryHeaders = {
+            ...effectiveHeaders,
+            "X-Merchant-ID": context.merchantId || "",
+            "X-Chain-ID": context.chainId.toString(),
+            "X-Payment-Proof": txHash, // Canonical
+            "X-Nonce": paymentRequest.nonce // Canonical
+        };
+        const retryRes = await (0, axios_1.default)({
+            url,
+            method: method ?? "GET",
+            data: {
+                ...(body || {}), // Preserve original body
+                nonce: paymentRequest.nonce // [CRITICAL] Send nonce in body for ReplayKey
+            },
+            headers: retryHeaders,
+            timeout: options.timeoutMs ?? HTTP_TIMEOUT_MS,
+        });
+        return {
+            data: retryRes.data,
+            payment: {
+                txHash,
+                amount: paymentRequest.amount,
+                currency: paymentRequest.currency,
+                chainId: paymentRequest.chainId // Normalized property name
+            }
+        };
+    }
+    catch (error) {
+        // Enhanced error logging
+        if (error.response?.status === 402) {
+            // This happens if the proof was rejected (REPLAY_DETECTED, etc)
+            console.error("[SDK] Payment Proof Rejected by Server:", error.response.data);
+            throw new Error(`Use Access Denied: ${error.response.data.error || "UNKNOWN"} - ${error.response.data.message || "Proof rejected"}`);
+        }
+        // Continue to standard error handling
+        if (error.name === "AgentError")
+            throw error; // Already wrapped
+        const status = error.response?.status;
+        const errorData = error.response?.data || error.message;
+        // Log minimal info, let the caller handle the details
+        console.warn(`[x402] Request Failed: ${status || "Network"} - ${error.message}`);
+        throw new errors_1.AgentError(`Request failed with status code ${status || "unknown"}: ${JSON.stringify(errorData)}`, status ? "HTTP_ERROR" : "NETWORK_ERROR", status, errorData);
+    }
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "cronos-agent-wallet",
+  "version": "1.2.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "axios": "^1.13.2",
+    "dotenv": "^17.2.3",
+    "ethers": "^6.0.0",
+    "mongoose": "^9.1.1"
+  },
+  "peerDependencies": {
+    "ethers": "^6.0.0"
+  },
+  "devDependencies": {
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^25.0.6",
+    "@types/uuid": "^10.0.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.3"
+  }
+}