@x402scan/mcp 0.0.3 → 0.0.4

package/dist/cjs/run-server.cjs

@@ -1319,21 +1319,21 @@ var require_errors = __commonJS({
     function extendErrors({ gen: gen2, keyword, schemaValue, data, errsCount, it }) {
       if (errsCount === void 0)
         throw new Error("ajv implementation error");
-      const err = gen2.name("err");
+      const err2 = gen2.name("err");
       gen2.forRange("i", errsCount, names_1.default.errors, (i) => {
-        gen2.const(err, (0, codegen_1._)`${names_1.default.vErrors}[${i}]`);
-        gen2.if((0, codegen_1._)`${err}.instancePath === undefined`, () => gen2.assign((0, codegen_1._)`${err}.instancePath`, (0, codegen_1.strConcat)(names_1.default.instancePath, it.errorPath)));
-        gen2.assign((0, codegen_1._)`${err}.schemaPath`, (0, codegen_1.str)`${it.errSchemaPath}/${keyword}`);
+        gen2.const(err2, (0, codegen_1._)`${names_1.default.vErrors}[${i}]`);
+        gen2.if((0, codegen_1._)`${err2}.instancePath === undefined`, () => gen2.assign((0, codegen_1._)`${err2}.instancePath`, (0, codegen_1.strConcat)(names_1.default.instancePath, it.errorPath)));
+        gen2.assign((0, codegen_1._)`${err2}.schemaPath`, (0, codegen_1.str)`${it.errSchemaPath}/${keyword}`);
         if (it.opts.verbose) {
-          gen2.assign((0, codegen_1._)`${err}.schema`, schemaValue);
-          gen2.assign((0, codegen_1._)`${err}.data`, data);
+          gen2.assign((0, codegen_1._)`${err2}.schema`, schemaValue);
+          gen2.assign((0, codegen_1._)`${err2}.data`, data);
         }
       });
     }
     exports2.extendErrors = extendErrors;
     function addError(gen2, errObj) {
-      const err = gen2.const("err", errObj);
-      gen2.if((0, codegen_1._)`${names_1.default.vErrors} === null`, () => gen2.assign(names_1.default.vErrors, (0, codegen_1._)`[${err}]`), (0, codegen_1._)`${names_1.default.vErrors}.push(${err})`);
+      const err2 = gen2.const("err", errObj);
+      gen2.if((0, codegen_1._)`${names_1.default.vErrors} === null`, () => gen2.assign(names_1.default.vErrors, (0, codegen_1._)`[${err2}]`), (0, codegen_1._)`${names_1.default.vErrors}.push(${err2})`);
       gen2.code((0, codegen_1._)`${names_1.default.errors}++`);
     }
     function returnErrors(it, errs) {
@@ -6860,12 +6860,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs8, exportName) {
+    function addFormats(ajv, list, fs10, exportName) {
       var _a2;
       var _b;
       (_a2 = (_b = ajv.opts.code).formats) !== null && _a2 !== void 0 ? _a2 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs8[f]);
+        ajv.addFormat(f, fs10[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -6913,12 +6913,12 @@ var init_version = __esm({
 });
 
 // ../../../node_modules/.pnpm/viem@2.44.1_bufferutil@4.0.9_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/base.js
-function walk(err, fn) {
-  if (fn?.(err))
-    return err;
-  if (err && typeof err === "object" && "cause" in err && err.cause !== void 0)
-    return walk(err.cause, fn);
-  return fn ? null : err;
+function walk(err2, fn) {
+  if (fn?.(err2))
+    return err2;
+  if (err2 && typeof err2 === "object" && "cause" in err2 && err2.cause !== void 0)
+    return walk(err2.cause, fn);
+  return fn ? null : err2;
 }
 var errorConfig, BaseError;
 var init_base = __esm({
@@ -11294,12 +11294,12 @@ var init_version3 = __esm({
 });
 
 // ../../../node_modules/.pnpm/viem@2.44.1_bufferutil@4.0.9_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.3.5/node_modules/viem/_esm/errors/base.js
-function walk2(err, fn) {
-  if (fn?.(err))
-    return err;
-  if (err && typeof err === "object" && "cause" in err && err.cause !== void 0)
-    return walk2(err.cause, fn);
-  return fn ? null : err;
+function walk2(err2, fn) {
+  if (fn?.(err2))
+    return err2;
+  if (err2 && typeof err2 === "object" && "cause" in err2 && err2.cause !== void 0)
+    return walk2(err2.cause, fn);
+  return fn ? null : err2;
 }
 var errorConfig2, BaseError3;
 var init_base2 = __esm({
@@ -13784,8 +13784,8 @@ ${prettyStateOverride(stateOverride)}`;
                 formattedArgs && formattedArgs !== "()" ? `       ${[...Array(errorName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}` : ""
               ];
             }
-          } catch (err) {
-            cause = err;
+          } catch (err2) {
+            cause = err2;
           }
         } else if (message)
           reason = message;
@@ -14609,51 +14609,51 @@ var init_node = __esm({
 });
 
 // ../../../node_modules/.pnpm/viem@2.44.1_bufferutil@4.0.9_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.3.5/node_modules/viem/_esm/utils/errors/getNodeError.js
-function getNodeError(err, args) {
-  const message = (err.details || "").toLowerCase();
-  const executionRevertedError = err instanceof BaseError3 ? err.walk((e2) => e2?.code === ExecutionRevertedError.code) : err;
+function getNodeError(err2, args) {
+  const message = (err2.details || "").toLowerCase();
+  const executionRevertedError = err2 instanceof BaseError3 ? err2.walk((e2) => e2?.code === ExecutionRevertedError.code) : err2;
   if (executionRevertedError instanceof BaseError3)
     return new ExecutionRevertedError({
-      cause: err,
+      cause: err2,
       message: executionRevertedError.details
     });
   if (ExecutionRevertedError.nodeMessage.test(message))
     return new ExecutionRevertedError({
-      cause: err,
-      message: err.details
+      cause: err2,
+      message: err2.details
     });
   if (FeeCapTooHighError.nodeMessage.test(message))
     return new FeeCapTooHighError({
-      cause: err,
+      cause: err2,
       maxFeePerGas: args?.maxFeePerGas
     });
   if (FeeCapTooLowError.nodeMessage.test(message))
     return new FeeCapTooLowError({
-      cause: err,
+      cause: err2,
       maxFeePerGas: args?.maxFeePerGas
     });
   if (NonceTooHighError.nodeMessage.test(message))
-    return new NonceTooHighError({ cause: err, nonce: args?.nonce });
+    return new NonceTooHighError({ cause: err2, nonce: args?.nonce });
   if (NonceTooLowError.nodeMessage.test(message))
-    return new NonceTooLowError({ cause: err, nonce: args?.nonce });
+    return new NonceTooLowError({ cause: err2, nonce: args?.nonce });
   if (NonceMaxValueError.nodeMessage.test(message))
-    return new NonceMaxValueError({ cause: err, nonce: args?.nonce });
+    return new NonceMaxValueError({ cause: err2, nonce: args?.nonce });
   if (InsufficientFundsError.nodeMessage.test(message))
-    return new InsufficientFundsError({ cause: err });
+    return new InsufficientFundsError({ cause: err2 });
   if (IntrinsicGasTooHighError.nodeMessage.test(message))
-    return new IntrinsicGasTooHighError({ cause: err, gas: args?.gas });
+    return new IntrinsicGasTooHighError({ cause: err2, gas: args?.gas });
   if (IntrinsicGasTooLowError.nodeMessage.test(message))
-    return new IntrinsicGasTooLowError({ cause: err, gas: args?.gas });
+    return new IntrinsicGasTooLowError({ cause: err2, gas: args?.gas });
   if (TransactionTypeNotSupportedError.nodeMessage.test(message))
-    return new TransactionTypeNotSupportedError({ cause: err });
+    return new TransactionTypeNotSupportedError({ cause: err2 });
   if (TipAboveFeeCapError.nodeMessage.test(message))
     return new TipAboveFeeCapError({
-      cause: err,
+      cause: err2,
       maxFeePerGas: args?.maxFeePerGas,
       maxPriorityFeePerGas: args?.maxPriorityFeePerGas
     });
   return new UnknownNodeError({
-    cause: err
+    cause: err2
   });
 }
 var init_getNodeError = __esm({
@@ -15053,12 +15053,12 @@ var init_errors2 = __esm({
 });
 
 // ../../../node_modules/.pnpm/ox@0.11.3_typescript@5.9.3_zod@4.3.5/node_modules/ox/_esm/core/Errors.js
-function walk3(err, fn) {
-  if (fn?.(err))
-    return err;
-  if (err && typeof err === "object" && "cause" in err && err.cause)
-    return walk3(err.cause, fn);
-  return fn ? null : err;
+function walk3(err2, fn) {
+  if (fn?.(err2))
+    return err2;
+  if (err2 && typeof err2 === "object" && "cause" in err2 && err2.cause)
+    return walk3(err2.cause, fn);
+  return fn ? null : err2;
 }
 var BaseError4;
 var init_Errors = __esm({
@@ -16454,11 +16454,11 @@ var init_getChainContractAddress = __esm({
 });
 
 // ../../../node_modules/.pnpm/viem@2.44.1_bufferutil@4.0.9_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.3.5/node_modules/viem/_esm/utils/errors/getCallError.js
-function getCallError(err, { docsPath: docsPath8, ...args }) {
+function getCallError(err2, { docsPath: docsPath8, ...args }) {
   const cause = (() => {
-    const cause2 = getNodeError(err, args);
+    const cause2 = getNodeError(err2, args);
     if (cause2 instanceof UnknownNodeError)
-      return err;
+      return err2;
     return cause2;
   })();
   return new CallExecutionError(cause, {
@@ -16508,10 +16508,10 @@ function createBatchScheduler({ fn, id, shouldSplitBatch, wait: wait3 = 0, sort
         const { resolve } = scheduler[i];
         resolve?.([data[i], data]);
       }
-    }).catch((err) => {
+    }).catch((err2) => {
       for (let i = 0; i < scheduler.length; i++) {
         const { reject } = scheduler[i];
-        reject?.(err);
+        reject?.(err2);
       }
     });
   };
@@ -16712,9 +16712,9 @@ async function localBatchGatewayRequest(parameters) {
     try {
       responses[i] = query.urls.includes(localBatchGatewayUrl) ? await localBatchGatewayRequest({ data: query.data, ccipRequest: ccipRequest2 }) : await ccipRequest2(query);
       failures[i] = false;
-    } catch (err) {
+    } catch (err2) {
       failures[i] = true;
-      responses[i] = encodeError(err);
+      responses[i] = encodeError(err2);
     }
   }));
   return encodeFunctionResult({
@@ -16783,10 +16783,10 @@ async function offchainLookup(client, { blockNumber, blockTag, data, to }) {
       to
     });
     return data_;
-  } catch (err) {
+  } catch (err2) {
     throw new OffchainLookupError({
       callbackSelector,
-      cause: err,
+      cause: err2,
       data,
       extraData,
       sender,
@@ -16831,10 +16831,10 @@ async function ccipRequest({ data, sender, urls }) {
         continue;
       }
       return result;
-    } catch (err) {
+    } catch (err2) {
       error48 = new HttpRequestError({
         body,
-        details: err.message,
+        details: err2.message,
         url: url2
       });
     }
@@ -16944,9 +16944,9 @@ async function call(client, args) {
           blockNumber,
           blockTag
         });
-      } catch (err) {
-        if (!(err instanceof ClientChainNotConfiguredError) && !(err instanceof ChainDoesNotSupportContract))
-          throw err;
+      } catch (err2) {
+        if (!(err2 instanceof ClientChainNotConfiguredError) && !(err2 instanceof ChainDoesNotSupportContract))
+          throw err2;
       }
     }
     const params = (() => {
@@ -16969,14 +16969,14 @@ async function call(client, args) {
     if (response === "0x")
       return { data: void 0 };
     return { data: response };
-  } catch (err) {
-    const data2 = getRevertErrorData(err);
+  } catch (err2) {
+    const data2 = getRevertErrorData(err2);
     const { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 } = await Promise.resolve().then(() => (init_ccip2(), ccip_exports));
     if (client.ccipRead !== false && data2?.slice(0, 10) === offchainLookupSignature2 && to)
       return { data: await offchainLookup2(client, { data: data2, to }) };
     if (deploylessCall && data2?.slice(0, 10) === "0x101bb98d")
       throw new CounterfactualDeploymentFailedError({ factory });
-    throw getCallError(err, {
+    throw getCallError(err2, {
       ...args,
       account,
       chain: client.chain
@@ -17077,10 +17077,10 @@ function toDeploylessCallViaFactoryData(parameters) {
     args: [to, data, factory, factoryData]
   });
 }
-function getRevertErrorData(err) {
-  if (!(err instanceof BaseError3))
+function getRevertErrorData(err2) {
+  if (!(err2 instanceof BaseError3))
     return void 0;
-  const error48 = err.walk();
+  const error48 = err2.walk();
   return typeof error48?.data === "object" ? error48.data?.data : error48.data;
 }
 var init_call = __esm({
@@ -26531,11 +26531,11 @@ var tslib_es6_exports = {};
 __export(tslib_es6_exports, {
   __addDisposableResource: () => __addDisposableResource,
   __assign: () => __assign,
-  __asyncDelegator: () => __asyncDelegator,
-  __asyncGenerator: () => __asyncGenerator,
-  __asyncValues: () => __asyncValues,
-  __await: () => __await,
-  __awaiter: () => __awaiter,
+  __asyncDelegator: () => __asyncDelegator2,
+  __asyncGenerator: () => __asyncGenerator2,
+  __asyncValues: () => __asyncValues2,
+  __await: () => __await2,
+  __awaiter: () => __awaiter2,
   __classPrivateFieldGet: () => __classPrivateFieldGet,
   __classPrivateFieldIn: () => __classPrivateFieldIn,
   __classPrivateFieldSet: () => __classPrivateFieldSet,
@@ -26559,7 +26559,7 @@ __export(tslib_es6_exports, {
   __spread: () => __spread,
   __spreadArray: () => __spreadArray,
   __spreadArrays: () => __spreadArrays,
-  __values: () => __values,
+  __values: () => __values2,
   default: () => tslib_es6_default
 });
 function __extends(d2, b2) {
@@ -26642,7 +26642,7 @@ function __setFunctionName(f, name, prefix) {
 function __metadata(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
 }
-function __awaiter(thisArg, _arguments, P2, generator) {
+function __awaiter2(thisArg, _arguments, P2, generator) {
   function adopt(value) {
     return value instanceof P2 ? value : new P2(function(resolve) {
       resolve(value);
@@ -26741,7 +26741,7 @@ function __generator(thisArg, body) {
 function __exportStar(m, o2) {
   for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o2, p)) __createBinding(o2, m, p);
 }
-function __values(o2) {
+function __values2(o2) {
   var s = typeof Symbol === "function" && Symbol.iterator, m = s && o2[s], i = 0;
   if (m) return m.call(o2);
   if (o2 && typeof o2.length === "number") return {
@@ -26790,10 +26790,10 @@ function __spreadArray(to, from14, pack) {
   }
   return to.concat(ar || Array.prototype.slice.call(from14));
 }
-function __await(v) {
-  return this instanceof __await ? (this.v = v, this) : new __await(v);
+function __await2(v) {
+  return this instanceof __await2 ? (this.v = v, this) : new __await2(v);
 }
-function __asyncGenerator(thisArg, _arguments, generator) {
+function __asyncGenerator2(thisArg, _arguments, generator) {
   if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
   var g2 = generator.apply(thisArg, _arguments || []), i, q2 = [];
   return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
@@ -26822,7 +26822,7 @@ function __asyncGenerator(thisArg, _arguments, generator) {
     }
   }
   function step(r2) {
-    r2.value instanceof __await ? Promise.resolve(r2.value.v).then(fulfill, reject) : settle(q2[0][2], r2);
+    r2.value instanceof __await2 ? Promise.resolve(r2.value.v).then(fulfill, reject) : settle(q2[0][2], r2);
   }
   function fulfill(value) {
     resume("next", value);
@@ -26834,7 +26834,7 @@ function __asyncGenerator(thisArg, _arguments, generator) {
     if (f(v), q2.shift(), q2.length) resume(q2[0][0], q2[0][1]);
   }
 }
-function __asyncDelegator(o2) {
+function __asyncDelegator2(o2) {
   var i, p;
   return i = {}, verb("next"), verb("throw", function(e2) {
     throw e2;
@@ -26843,14 +26843,14 @@ function __asyncDelegator(o2) {
   }, i;
   function verb(n, f) {
     i[n] = o2[n] ? function(v) {
-      return (p = !p) ? { value: __await(o2[n](v)), done: false } : f ? f(v) : v;
+      return (p = !p) ? { value: __await2(o2[n](v)), done: false } : f ? f(v) : v;
     } : f;
   }
 }
-function __asyncValues(o2) {
+function __asyncValues2(o2) {
   if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
   var m = o2[Symbol.asyncIterator], i;
-  return m ? m.call(o2) : (o2 = typeof __values === "function" ? __values(o2) : o2[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+  return m ? m.call(o2) : (o2 = typeof __values2 === "function" ? __values2(o2) : o2[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
     return this;
   }, i);
   function verb(n) {
@@ -27006,19 +27006,19 @@ var init_tslib_es6 = __esm({
       __decorate,
       __param,
       __metadata,
-      __awaiter,
+      __awaiter: __awaiter2,
       __generator,
       __createBinding,
       __exportStar,
-      __values,
+      __values: __values2,
       __read,
       __spread,
       __spreadArrays,
       __spreadArray,
-      __await,
-      __asyncGenerator,
-      __asyncDelegator,
-      __asyncValues,
+      __await: __await2,
+      __asyncGenerator: __asyncGenerator2,
+      __asyncDelegator: __asyncDelegator2,
+      __asyncValues: __asyncValues2,
       __makeTemplateObject,
       __importStar,
       __importDefault,
@@ -29701,7 +29701,7 @@ var require_abstract_coder = __commonJS({
     function toObject(names, items, deep) {
       if (names.indexOf(null) >= 0) {
         return items.map((item, index2) => {
-          if (item instanceof Result) {
+          if (item instanceof Result2) {
             return toObject(getNames(item), item, deep);
           }
           return item;
@@ -29710,7 +29710,7 @@ var require_abstract_coder = __commonJS({
       return names.reduce((accum, name, index2) => {
         let item = items.getValue(name);
         if (!(name in accum)) {
-          if (deep && item instanceof Result) {
+          if (deep && item instanceof Result2) {
             item = toObject(getNames(item), item, deep);
           }
           accum[name] = item;
@@ -29718,7 +29718,7 @@ var require_abstract_coder = __commonJS({
         return accum;
       }, {});
     }
-    var Result = class _Result extends Array {
+    var Result2 = class _Result extends Array {
       // No longer used; but cannot be removed as it will remove the
       // #private field from the .d.ts which may break backwards
       // compatibility
@@ -29922,7 +29922,7 @@ var require_abstract_coder = __commonJS({
         return new _Result(_guard, items, keys);
       }
     };
-    exports2.Result = Result;
+    exports2.Result = Result2;
     function checkResultErrors(result) {
       const errors = [];
       const checkErrors = function(path2, object3) {
@@ -37735,8 +37735,8 @@ var require_dist2 = __commonJS({
             }
           }
           info.type = type;
-        } catch (err) {
-          info.error = err;
+        } catch (err2) {
+          info.error = err2;
         }
         return info;
       });
@@ -48883,7 +48883,7 @@ var require_node_gyp_build = __commonJS({
   "../../../node_modules/.pnpm/node-gyp-build@4.8.4/node_modules/node-gyp-build/node-gyp-build.js"(exports2, module2) {
     "use strict";
     init_cjs_shims();
-    var fs8 = require("fs");
+    var fs10 = require("fs");
     var path2 = require("path");
     var os2 = require("os");
     var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
@@ -48905,7 +48905,7 @@ var require_node_gyp_build = __commonJS({
       try {
         var name = runtimeRequire(path2.join(dir, "package.json")).name.toUpperCase().replace(/-/g, "_");
         if (process.env[name + "_PREBUILD"]) dir = process.env[name + "_PREBUILD"];
-      } catch (err) {
+      } catch (err2) {
       }
       if (!prebuildsOnly) {
         var release = getFirst(path2.join(dir, "build/Release"), matchBuild);
@@ -48944,8 +48944,8 @@ var require_node_gyp_build = __commonJS({
     };
     function readdirSync(dir) {
       try {
-        return fs8.readdirSync(dir);
-      } catch (err) {
+        return fs10.readdirSync(dir);
+      } catch (err2) {
         return [];
       }
     }
@@ -49038,7 +49038,7 @@ var require_node_gyp_build = __commonJS({
       return typeof window !== "undefined" && window.process && window.process.type === "renderer";
     }
     function isAlpine(platform3) {
-      return platform3 === "linux" && fs8.existsSync("/etc/alpine-release");
+      return platform3 === "linux" && fs10.existsSync("/etc/alpine-release");
     }
     load.parseTags = parseTags;
     load.matchTags = matchTags;
@@ -49461,9 +49461,9 @@ var require_permessage_deflate = __commonJS({
        */
       decompress(data, fin, callback) {
         zlibLimiter.add((done) => {
-          this._decompress(data, fin, (err, result) => {
+          this._decompress(data, fin, (err2, result) => {
             done();
-            callback(err, result);
+            callback(err2, result);
           });
         });
       }
@@ -49477,9 +49477,9 @@ var require_permessage_deflate = __commonJS({
        */
       compress(data, fin, callback) {
         zlibLimiter.add((done) => {
-          this._compress(data, fin, (err, result) => {
+          this._compress(data, fin, (err2, result) => {
             done();
-            callback(err, result);
+            callback(err2, result);
           });
         });
       }
@@ -49510,11 +49510,11 @@ var require_permessage_deflate = __commonJS({
         this._inflate.write(data);
         if (fin) this._inflate.write(TRAILER);
         this._inflate.flush(() => {
-          const err = this._inflate[kError];
-          if (err) {
+          const err2 = this._inflate[kError];
+          if (err2) {
             this._inflate.close();
             this._inflate = null;
-            callback(err);
+            callback(err2);
             return;
           }
           const data2 = bufferUtil.concat(
@@ -49595,10 +49595,10 @@ var require_permessage_deflate = __commonJS({
       this.removeListener("data", inflateOnData);
       this.reset();
     }
-    function inflateOnError(err) {
+    function inflateOnError(err2) {
       this[kPerMessageDeflate]._inflate = null;
-      err[kStatusCode] = 1007;
-      this[kCallback](err);
+      err2[kStatusCode] = 1007;
+      this[kCallback](err2);
     }
   }
 });
@@ -50269,8 +50269,8 @@ var require_receiver = __commonJS({
        */
       decompress(data, cb) {
         const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
-        perMessageDeflate.decompress(data, this._fin, (err, buf) => {
-          if (err) return cb(err);
+        perMessageDeflate.decompress(data, this._fin, (err2, buf) => {
+          if (err2) return cb(err2);
           if (buf.length) {
             this._messageLength += buf.length;
             if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
@@ -50429,13 +50429,13 @@ var require_receiver = __commonJS({
       createError(ErrorCtor, message, prefix, statusCode, errorCode) {
         this._loop = false;
         this._errored = true;
-        const err = new ErrorCtor(
+        const err2 = new ErrorCtor(
           prefix ? `Invalid WebSocket frame: ${message}` : message
         );
-        Error.captureStackTrace(err, this.createError);
-        err.code = errorCode;
-        err[kStatusCode] = statusCode;
-        return err;
+        Error.captureStackTrace(err2, this.createError);
+        err2.code = errorCode;
+        err2[kStatusCode] = statusCode;
+        return err2;
       }
     };
     module2.exports = Receiver;
@@ -50799,14 +50799,14 @@ var require_sender = __commonJS({
         this._deflating = true;
         perMessageDeflate.compress(data, options.fin, (_3, buf) => {
           if (this._socket.destroyed) {
-            const err = new Error(
+            const err2 = new Error(
               "The socket was closed while data was being compressed"
             );
-            if (typeof cb === "function") cb(err);
+            if (typeof cb === "function") cb(err2);
             for (let i = 0; i < this._queue.length; i++) {
               const params = this._queue[i];
               const callback = params[params.length - 1];
-              if (typeof callback === "function") callback(err);
+              if (typeof callback === "function") callback(err2);
             }
             return;
           }
@@ -51502,8 +51502,8 @@ var require_websocket = __commonJS({
           return;
         }
         this._readyState = _WebSocket.CLOSING;
-        this._sender.close(code, data, !this._isServer, (err) => {
-          if (err) return;
+        this._sender.close(code, data, !this._isServer, (err2) => {
+          if (err2) return;
           this._closeFrameSent = true;
           if (this._closeFrameReceived || this._receiver._writableState.errorEmitted) {
             this._socket.end();
@@ -51772,11 +51772,11 @@ var require_websocket = __commonJS({
         invalidUrlMessage = "The URL contains a fragment identifier";
       }
       if (invalidUrlMessage) {
-        const err = new SyntaxError(invalidUrlMessage);
+        const err2 = new SyntaxError(invalidUrlMessage);
         if (websocket._redirects === 0) {
-          throw err;
+          throw err2;
         } else {
-          emitErrorAndClose(websocket, err);
+          emitErrorAndClose(websocket, err2);
           return;
         }
       }
@@ -51871,10 +51871,10 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, req, "Opening handshake has timed out");
         });
       }
-      req.on("error", (err) => {
+      req.on("error", (err2) => {
         if (req === null || req[kAborted]) return;
         req = websocket._req = null;
-        emitErrorAndClose(websocket, err);
+        emitErrorAndClose(websocket, err2);
       });
       req.on("response", (res) => {
         const location = res.headers.location;
@@ -51889,8 +51889,8 @@ var require_websocket = __commonJS({
           try {
             addr = new URL2(location, address);
           } catch (e2) {
-            const err = new SyntaxError(`Invalid URL: ${location}`);
-            emitErrorAndClose(websocket, err);
+            const err2 = new SyntaxError(`Invalid URL: ${location}`);
+            emitErrorAndClose(websocket, err2);
             return;
           }
           initAsClient(websocket, addr, protocols, options);
@@ -51942,7 +51942,7 @@ var require_websocket = __commonJS({
           let extensions;
           try {
             extensions = parse3(secWebSocketExtensions);
-          } catch (err) {
+          } catch (err2) {
             const message = "Invalid Sec-WebSocket-Extensions header";
             abortHandshake(websocket, socket, message);
             return;
@@ -51955,7 +51955,7 @@ var require_websocket = __commonJS({
           }
           try {
             perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
-          } catch (err) {
+          } catch (err2) {
             const message = "Invalid Sec-WebSocket-Extensions header";
             abortHandshake(websocket, socket, message);
             return;
@@ -51975,9 +51975,9 @@ var require_websocket = __commonJS({
         req.end();
       }
     }
-    function emitErrorAndClose(websocket, err) {
+    function emitErrorAndClose(websocket, err2) {
       websocket._readyState = WebSocket.CLOSING;
-      websocket.emit("error", err);
+      websocket.emit("error", err2);
       websocket.emitClose();
     }
     function netConnect(options) {
@@ -51993,17 +51993,17 @@ var require_websocket = __commonJS({
     }
     function abortHandshake(websocket, stream, message) {
       websocket._readyState = WebSocket.CLOSING;
-      const err = new Error(message);
-      Error.captureStackTrace(err, abortHandshake);
+      const err2 = new Error(message);
+      Error.captureStackTrace(err2, abortHandshake);
       if (stream.setHeader) {
         stream[kAborted] = true;
         stream.abort();
         if (stream.socket && !stream.socket.destroyed) {
           stream.socket.destroy();
         }
-        process.nextTick(emitErrorAndClose, websocket, err);
+        process.nextTick(emitErrorAndClose, websocket, err2);
       } else {
-        stream.destroy(err);
+        stream.destroy(err2);
         stream.once("error", websocket.emit.bind(websocket, "error"));
         stream.once("close", websocket.emitClose.bind(websocket));
       }
@@ -52015,10 +52015,10 @@ var require_websocket = __commonJS({
         else websocket._bufferedAmount += length;
       }
       if (cb) {
-        const err = new Error(
+        const err2 = new Error(
           `WebSocket is not open: readyState ${websocket.readyState} (${readyStates[websocket.readyState]})`
         );
-        process.nextTick(cb, err);
+        process.nextTick(cb, err2);
       }
     }
     function receiverOnConclude(code, reason) {
@@ -52036,14 +52036,14 @@ var require_websocket = __commonJS({
       const websocket = this[kWebSocket];
       if (!websocket.isPaused) websocket._socket.resume();
     }
-    function receiverOnError(err) {
+    function receiverOnError(err2) {
       const websocket = this[kWebSocket];
       if (websocket._socket[kWebSocket] !== void 0) {
         websocket._socket.removeListener("data", socketOnData);
         process.nextTick(resume, websocket._socket);
-        websocket.close(err[kStatusCode]);
+        websocket.close(err2[kStatusCode]);
       }
-      websocket.emit("error", err);
+      websocket.emit("error", err2);
     }
     function receiverOnFinish() {
       this[kWebSocket].emitClose();
@@ -52119,11 +52119,11 @@ var require_stream = __commonJS({
         this.destroy();
       }
     }
-    function duplexOnError(err) {
+    function duplexOnError(err2) {
       this.removeListener("error", duplexOnError);
       this.destroy();
       if (this.listenerCount("error") === 0) {
-        this.emit("error", err);
+        this.emit("error", err2);
       }
     }
     function createWebSocketStream(ws, options) {
@@ -52139,28 +52139,28 @@ var require_stream = __commonJS({
         const data = !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
         if (!duplex.push(data)) ws.pause();
       });
-      ws.once("error", function error48(err) {
+      ws.once("error", function error48(err2) {
         if (duplex.destroyed) return;
         terminateOnDestroy = false;
-        duplex.destroy(err);
+        duplex.destroy(err2);
       });
       ws.once("close", function close() {
         if (duplex.destroyed) return;
         duplex.push(null);
       });
-      duplex._destroy = function(err, callback) {
+      duplex._destroy = function(err2, callback) {
         if (ws.readyState === ws.CLOSED) {
-          callback(err);
+          callback(err2);
           process.nextTick(emitClose, duplex);
           return;
         }
         let called = false;
-        ws.once("error", function error48(err2) {
+        ws.once("error", function error48(err3) {
           called = true;
-          callback(err2);
+          callback(err3);
         });
         ws.once("close", function close() {
-          if (!called) callback(err);
+          if (!called) callback(err2);
           process.nextTick(emitClose, duplex);
         });
         if (terminateOnDestroy) ws.terminate();
@@ -52478,7 +52478,7 @@ var require_websocket_server = __commonJS({
         if (secWebSocketProtocol !== void 0) {
           try {
             protocols = subprotocol.parse(secWebSocketProtocol);
-          } catch (err) {
+          } catch (err2) {
             const message = "Invalid Sec-WebSocket-Protocol header";
             abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
             return;
@@ -52498,7 +52498,7 @@ var require_websocket_server = __commonJS({
               perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
               extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
             }
-          } catch (err) {
+          } catch (err2) {
             const message = "Invalid or unacceptable Sec-WebSocket-Extensions header";
             abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
             return;
@@ -52627,9 +52627,9 @@ var require_websocket_server = __commonJS({
     }
     function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
       if (server.listenerCount("wsClientError")) {
-        const err = new Error(message);
-        Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
-        server.emit("wsClientError", err, socket, req);
+        const err2 = new Error(message);
+        Error.captureStackTrace(err2, abortHandshakeOrEmitwsClientError);
+        server.emit("wsClientError", err2, socket, req);
       } else {
         abortHandshake(socket, code, message);
       }
@@ -59102,6 +59102,57 @@ var require_siwe = __commonJS({
 // src/run-server.ts
 init_cjs_shims();
 
+// src/lib/log.ts
+init_cjs_shims();
+var import_fs = require("fs");
+
+// src/lib/fs.ts
+init_cjs_shims();
+var import_path = require("path");
+var import_os = require("os");
+var fs = __toESM(require("fs"), 1);
+var BASE_DIRECTORY = (0, import_path.join)((0, import_os.homedir)(), ".x402scan-mcp");
+if (!fs.existsSync(BASE_DIRECTORY)) {
+  fs.mkdirSync(BASE_DIRECTORY, { recursive: true });
+}
+var configFile = (name) => {
+  if (!fs.existsSync(BASE_DIRECTORY)) {
+    fs.mkdirSync(BASE_DIRECTORY, { recursive: true });
+  }
+  const filePath = (0, import_path.join)(BASE_DIRECTORY, name);
+  if (!fs.existsSync(filePath)) {
+    fs.writeFileSync(filePath, "{}");
+  }
+  return filePath;
+};
+
+// src/lib/log.ts
+var LOG_FILE = configFile("mcp.log");
+var DEBUG = process.env.X402_DEBUG === "true";
+function format(args) {
+  return args.map(
+    (a) => typeof a === "object" && a !== null ? JSON.stringify(a) : String(a)
+  ).join(" ");
+}
+function write(level, msg, args) {
+  const formatted = args.length ? `${msg} ${format(args)}` : msg;
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${level}] ${formatted}
+`;
+  try {
+    (0, import_fs.appendFileSync)(LOG_FILE, line);
+  } catch {
+  }
+  if (process.env.X402_DEBUG === "true") {
+    console.error(`[x402scan] ${formatted}`);
+  }
+}
+var log = {
+  info: (msg, ...args) => write("INFO", msg, args),
+  error: (msg, ...args) => write("ERROR", msg, args),
+  debug: (msg, ...args) => DEBUG && write("DEBUG", msg, args),
+  path: LOG_FILE
+};
+
 // src/server/index.ts
 init_cjs_shims();
 
@@ -59759,8 +59810,8 @@ var ZodType = class {
         } : {
           issues: ctx.common.issues
         };
-      } catch (err) {
-        if (err?.message?.toLowerCase()?.includes("encountered")) {
+      } catch (err2) {
+        if (err2?.message?.toLowerCase()?.includes("encountered")) {
           this["~standard"].async = true;
         }
         ctx.common = {
@@ -83220,11 +83271,11 @@ init_contract();
 init_request();
 init_rpc();
 var EXECUTION_REVERTED_ERROR_CODE = 3;
-function getContractError(err, { abi: abi2, address, args, docsPath: docsPath8, functionName, sender }) {
-  const error48 = err instanceof RawContractError ? err : err instanceof BaseError3 ? err.walk((err2) => "data" in err2) || err.walk() : {};
+function getContractError(err2, { abi: abi2, address, args, docsPath: docsPath8, functionName, sender }) {
+  const error48 = err2 instanceof RawContractError ? err2 : err2 instanceof BaseError3 ? err2.walk((err3) => "data" in err3) || err2.walk() : {};
   const { code, data, details, message, shortMessage } = error48;
   const cause = (() => {
-    if (err instanceof AbiDecodingZeroDataError)
+    if (err2 instanceof AbiDecodingZeroDataError)
       return new ContractFunctionZeroDataError({ functionName });
     if ([EXECUTION_REVERTED_ERROR_CODE, InternalRpcError.code].includes(code) && (data || details || message || shortMessage) || code === InvalidInputRpcError.code && details === "execution reverted" && data) {
       return new ContractFunctionRevertedError({
@@ -83234,7 +83285,7 @@ function getContractError(err, { abi: abi2, address, args, docsPath: docsPath8,
         message: error48 instanceof RpcRequestError ? details : shortMessage ?? message
       });
     }
-    return err;
+    return err2;
   })();
   return new ContractFunctionExecutionError(cause, {
     abi: abi2,
@@ -83482,11 +83533,11 @@ var EstimateGasExecutionError = class extends BaseError3 {
 // ../../../node_modules/.pnpm/viem@2.44.1_bufferutil@4.0.9_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.3.5/node_modules/viem/_esm/utils/errors/getEstimateGasError.js
 init_node();
 init_getNodeError();
-function getEstimateGasError(err, { docsPath: docsPath8, ...args }) {
+function getEstimateGasError(err2, { docsPath: docsPath8, ...args }) {
   const cause = (() => {
-    const cause2 = getNodeError(err, args);
+    const cause2 = getNodeError(err2, args);
     if (cause2 instanceof UnknownNodeError)
-      return err;
+      return err2;
     return cause2;
   })();
   return new EstimateGasExecutionError(cause, {
@@ -84023,11 +84074,11 @@ init_cjs_shims();
 init_node();
 init_transaction();
 init_getNodeError();
-function getTransactionError(err, { docsPath: docsPath8, ...args }) {
+function getTransactionError(err2, { docsPath: docsPath8, ...args }) {
   const cause = (() => {
-    const cause2 = getNodeError(err, args);
+    const cause2 = getNodeError(err2, args);
     if (cause2 instanceof UnknownNodeError)
-      return err;
+      return err2;
     return cause2;
   })();
   return new TransactionExecutionError(cause, {
@@ -84145,8 +84196,8 @@ async function fillTransaction(client, parameters) {
         ...transaction
       }
     };
-  } catch (err) {
-    throw getTransactionError(err, {
+  } catch (err2) {
+    throw getTransactionError(err2, {
       ...parameters,
       chain: client.chain
     });
@@ -84422,8 +84473,8 @@ async function estimateGas(client, args) {
         rpcStateOverride
       ] : block ? [request, block] : [request]
     }));
-  } catch (err) {
-    throw getEstimateGasError(err, {
+  } catch (err2) {
+    throw getEstimateGasError(err2, {
       ...args,
       account,
       chain: client.chain
@@ -84521,16 +84572,16 @@ function decodeEventLog(parameters) {
             for (let i = 0; i < nonIndexedInputs.length; i++)
               args[nonIndexedInputs[i].name] = decodedData[i];
         }
-      } catch (err) {
+      } catch (err2) {
         if (strict) {
-          if (err instanceof AbiDecodingDataSizeTooSmallError || err instanceof PositionOutOfBoundsError)
+          if (err2 instanceof AbiDecodingDataSizeTooSmallError || err2 instanceof PositionOutOfBoundsError)
             throw new DecodeLogDataMismatch({
               abiItem,
               data,
               params: nonIndexedInputs,
               size: size2(data)
             });
-          throw err;
+          throw err2;
         }
       }
     } else if (strict) {
@@ -85066,10 +85117,10 @@ function watchContractEvent(client, parameters) {
           else
             for (const log2 of logs)
               emit.onLogs([log2]);
-        } catch (err) {
-          if (filter && err instanceof InvalidInputRpcError)
+        } catch (err2) {
+          if (filter && err2 instanceof InvalidInputRpcError)
             initialized = false;
-          emit.onError?.(err);
+          emit.onError?.(err2);
         }
       }, {
         emitOnBegin: true,
@@ -85132,14 +85183,14 @@ function watchContractEvent(client, parameters) {
                   eventName: eventName2
                 });
                 emit.onLogs([formatted]);
-              } catch (err) {
+              } catch (err2) {
                 let eventName2;
                 let isUnnamed;
-                if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
+                if (err2 instanceof DecodeLogDataMismatch || err2 instanceof DecodeLogTopicsMismatch) {
                   if (strict_)
                     return;
-                  eventName2 = err.abiItem.name;
-                  isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
+                  eventName2 = err2.abiItem.name;
+                  isUnnamed = err2.abiItem.inputs?.some((x) => !("name" in x && x.name));
                 }
                 const formatted = formatLog(log2, {
                   args: isUnnamed ? [] : {},
@@ -85155,8 +85206,8 @@ function watchContractEvent(client, parameters) {
           unsubscribe = unsubscribe_;
           if (!active)
             unsubscribe();
-        } catch (err) {
-          onError?.(err);
+        } catch (err2) {
+          onError?.(err2);
         }
       })();
       return () => unsubscribe();
@@ -85188,10 +85239,10 @@ function withRetry(fn, { delay: delay_ = 100, retryCount = 2, shouldRetry: shoul
       try {
         const data = await fn();
         resolve(data);
-      } catch (err) {
-        if (count < retryCount && await shouldRetry2({ count, error: err }))
-          return retry({ error: err });
-        reject(err);
+      } catch (err2) {
+        if (count < retryCount && await shouldRetry2({ count, error: err2 }))
+          return retry({ error: err2 });
+        reject(err2);
       }
     };
     attemptRetry();
@@ -85309,10 +85360,10 @@ init_toHex2();
 init_cjs_shims();
 init_base2();
 init_contract();
-function isNullUniversalResolverError(err) {
-  if (!(err instanceof BaseError3))
+function isNullUniversalResolverError(err2) {
+  if (!(err2 instanceof BaseError3))
     return false;
-  const cause = err.walk((e2) => e2 instanceof ContractFunctionRevertedError);
+  const cause = err2.walk((e2) => e2 instanceof ContractFunctionRevertedError);
   if (!(cause instanceof ContractFunctionRevertedError))
     return false;
   if (cause.data?.errorName === "HttpError")
@@ -85469,12 +85520,12 @@ async function getEnsAddress(client, parameters) {
     if (trim(address) === "0x00")
       return null;
     return address;
-  } catch (err) {
+  } catch (err2) {
     if (strict)
-      throw err;
-    if (isNullUniversalResolverError(err))
+      throw err2;
+    if (isNullUniversalResolverError(err2))
       return null;
-    throw err;
+    throw err2;
   }
 }
 
@@ -85773,12 +85824,12 @@ async function getEnsText(client, parameters) {
       data: res[0]
     });
     return record2 === "" ? null : record2;
-  } catch (err) {
+  } catch (err2) {
     if (strict)
-      throw err;
-    if (isNullUniversalResolverError(err))
+      throw err2;
+    if (isNullUniversalResolverError(err2))
       return null;
-    throw err;
+    throw err2;
   }
 }
 
@@ -85836,12 +85887,12 @@ async function getEnsName(client, parameters) {
     const readContractAction = getAction(client, readContract, "readContract");
     const [name] = await readContractAction(readContractParameters);
     return name || null;
-  } catch (err) {
+  } catch (err2) {
     if (strict)
-      throw err;
-    if (isNullUniversalResolverError(err))
+      throw err2;
+    if (isNullUniversalResolverError(err2))
       return null;
-    throw err;
+    throw err2;
   }
 }
 
@@ -85931,8 +85982,8 @@ async function createAccessList(client, args) {
       accessList: response.accessList,
       gasUsed: BigInt(response.gasUsed)
     };
-  } catch (err) {
-    throw getCallError(err, {
+  } catch (err2) {
+    throw getCallError(err2, {
       ...args,
       account,
       chain: client.chain
@@ -86573,93 +86624,93 @@ function buildRequest(request, options = {}) {
       try {
         return await request(args);
       } catch (err_) {
-        const err = err_;
-        switch (err.code) {
+        const err2 = err_;
+        switch (err2.code) {
           // -32700
           case ParseRpcError.code:
-            throw new ParseRpcError(err);
+            throw new ParseRpcError(err2);
           // -32600
           case InvalidRequestRpcError.code:
-            throw new InvalidRequestRpcError(err);
+            throw new InvalidRequestRpcError(err2);
           // -32601
           case MethodNotFoundRpcError.code:
-            throw new MethodNotFoundRpcError(err, { method: args.method });
+            throw new MethodNotFoundRpcError(err2, { method: args.method });
           // -32602
           case InvalidParamsRpcError.code:
-            throw new InvalidParamsRpcError(err);
+            throw new InvalidParamsRpcError(err2);
           // -32603
           case InternalRpcError.code:
-            throw new InternalRpcError(err);
+            throw new InternalRpcError(err2);
           // -32000
           case InvalidInputRpcError.code:
-            throw new InvalidInputRpcError(err);
+            throw new InvalidInputRpcError(err2);
           // -32001
           case ResourceNotFoundRpcError.code:
-            throw new ResourceNotFoundRpcError(err);
+            throw new ResourceNotFoundRpcError(err2);
           // -32002
           case ResourceUnavailableRpcError.code:
-            throw new ResourceUnavailableRpcError(err);
+            throw new ResourceUnavailableRpcError(err2);
           // -32003
           case TransactionRejectedRpcError.code:
-            throw new TransactionRejectedRpcError(err);
+            throw new TransactionRejectedRpcError(err2);
           // -32004
           case MethodNotSupportedRpcError.code:
-            throw new MethodNotSupportedRpcError(err, {
+            throw new MethodNotSupportedRpcError(err2, {
               method: args.method
             });
           // -32005
           case LimitExceededRpcError.code:
-            throw new LimitExceededRpcError(err);
+            throw new LimitExceededRpcError(err2);
           // -32006
           case JsonRpcVersionUnsupportedError.code:
-            throw new JsonRpcVersionUnsupportedError(err);
+            throw new JsonRpcVersionUnsupportedError(err2);
           // 4001
           case UserRejectedRequestError.code:
-            throw new UserRejectedRequestError(err);
+            throw new UserRejectedRequestError(err2);
           // 4100
           case UnauthorizedProviderError.code:
-            throw new UnauthorizedProviderError(err);
+            throw new UnauthorizedProviderError(err2);
           // 4200
           case UnsupportedProviderMethodError.code:
-            throw new UnsupportedProviderMethodError(err);
+            throw new UnsupportedProviderMethodError(err2);
           // 4900
           case ProviderDisconnectedError.code:
-            throw new ProviderDisconnectedError(err);
+            throw new ProviderDisconnectedError(err2);
           // 4901
           case ChainDisconnectedError.code:
-            throw new ChainDisconnectedError(err);
+            throw new ChainDisconnectedError(err2);
           // 4902
           case SwitchChainError.code:
-            throw new SwitchChainError(err);
+            throw new SwitchChainError(err2);
           // 5700
           case UnsupportedNonOptionalCapabilityError.code:
-            throw new UnsupportedNonOptionalCapabilityError(err);
+            throw new UnsupportedNonOptionalCapabilityError(err2);
           // 5710
           case UnsupportedChainIdError.code:
-            throw new UnsupportedChainIdError(err);
+            throw new UnsupportedChainIdError(err2);
           // 5720
           case DuplicateIdError.code:
-            throw new DuplicateIdError(err);
+            throw new DuplicateIdError(err2);
           // 5730
           case UnknownBundleIdError.code:
-            throw new UnknownBundleIdError(err);
+            throw new UnknownBundleIdError(err2);
           // 5740
           case BundleTooLargeError.code:
-            throw new BundleTooLargeError(err);
+            throw new BundleTooLargeError(err2);
           // 5750
           case AtomicReadyWalletRejectedUpgradeError.code:
-            throw new AtomicReadyWalletRejectedUpgradeError(err);
+            throw new AtomicReadyWalletRejectedUpgradeError(err2);
           // 5760
           case AtomicityNotSupportedError.code:
-            throw new AtomicityNotSupportedError(err);
+            throw new AtomicityNotSupportedError(err2);
           // CAIP-25: User Rejected Error
           // https://docs.walletconnect.com/2.0/specs/clients/sign/error-codes#rejected-caip-25
           case 5e3:
-            throw new UserRejectedRequestError(err);
+            throw new UserRejectedRequestError(err2);
           default:
             if (err_ instanceof BaseError3)
               throw err_;
-            throw new UnknownRpcError(err);
+            throw new UnknownRpcError(err2);
         }
       }
     }, {
@@ -86756,10 +86807,10 @@ function withTimeout(fn, { errorInstance = new Error("timed out"), timeout, sign
           }, timeout);
         }
         resolve(await fn({ signal: controller?.signal || null }));
-      } catch (err) {
-        if (err?.name === "AbortError")
+      } catch (err2) {
+        if (err2?.name === "AbortError")
           reject(errorInstance);
-        reject(err);
+        reject(err2);
       } finally {
         clearTimeout(timeoutId);
       }
@@ -86833,9 +86884,9 @@ function getHttpRpcClient(url2, options = {}) {
           data = await response.text();
           try {
             data = JSON.parse(data || "{}");
-          } catch (err) {
+          } catch (err2) {
             if (response.ok)
-              throw err;
+              throw err2;
             data = { error: data };
           }
         }
@@ -86849,14 +86900,14 @@ function getHttpRpcClient(url2, options = {}) {
           });
         }
         return data;
-      } catch (err) {
-        if (err instanceof HttpRequestError)
-          throw err;
-        if (err instanceof TimeoutError)
-          throw err;
+      } catch (err2) {
+        if (err2 instanceof HttpRequestError)
+          throw err2;
+        if (err2 instanceof TimeoutError)
+          throw err2;
         throw new HttpRequestError({
           body,
-          cause: err,
+          cause: err2,
           url: url2
         });
       }
@@ -88934,8 +88985,8 @@ async function multicall(client, parameters) {
           target: address
         }
       ];
-    } catch (err) {
-      const error48 = getContractError(err, {
+    } catch (err2) {
+      const error48 = getContractError(err2, {
         abi: abi2,
         address,
         args,
@@ -88999,8 +89050,8 @@ async function multicall(client, parameters) {
           functionName
         });
         results.push(allowFailure ? { result: result2, status: "success" } : result2);
-      } catch (err) {
-        const error48 = getContractError(err, {
+      } catch (err2) {
+        const error48 = getContractError(err2, {
           abi: abi2,
           address,
           args,
@@ -90040,8 +90091,8 @@ function watchBlockNumber(client, { emitOnBegin = false, emitMissed = false, onB
           emit.onBlockNumber(blockNumber, prevBlockNumber);
           prevBlockNumber = blockNumber;
         }
-      } catch (err) {
-        emit.onError?.(err);
+      } catch (err2) {
+        emit.onError?.(err2);
       }
     }, {
       emitOnBegin,
@@ -90085,8 +90136,8 @@ function watchBlockNumber(client, { emitOnBegin = false, emitMissed = false, onB
           unsubscribe = unsubscribe_;
           if (!active)
             unsubscribe();
-        } catch (err) {
-          onError?.(err);
+        } catch (err2) {
+          onError?.(err2);
         }
       })();
       return () => unsubscribe();
@@ -90173,8 +90224,8 @@ async function waitForTransactionReceipt(client, parameters) {
           if (confirmations > 1 && (!receipt.blockNumber || blockNumber - receipt.blockNumber + 1n < confirmations))
             return;
           done(() => emit.resolve(receipt));
-        } catch (err) {
-          if (err instanceof TransactionNotFoundError || err instanceof TransactionReceiptNotFoundError) {
+        } catch (err2) {
+          if (err2 instanceof TransactionNotFoundError || err2 instanceof TransactionReceiptNotFoundError) {
             if (!transaction) {
               retrying = false;
               return;
@@ -90218,7 +90269,7 @@ async function waitForTransactionReceipt(client, parameters) {
               done(() => emit.reject(err_));
             }
           } else {
-            done(() => emit.reject(err));
+            done(() => emit.reject(err2));
           }
         }
       }
@@ -90282,8 +90333,8 @@ function watchBlocks(client, { blockTag = client.experimental_blockTag ?? "lates
           emit.onBlock(block, prevBlock);
           prevBlock = block;
         }
-      } catch (err) {
-        emit.onError?.(err);
+      } catch (err2) {
+        emit.onError?.(err2);
       }
     }, {
       emitOnBegin,
@@ -90341,8 +90392,8 @@ function watchBlocks(client, { blockTag = client.experimental_blockTag ?? "lates
         unsubscribe = unsubscribe_;
         if (!active)
           unsubscribe();
-      } catch (err) {
-        onError?.(err);
+      } catch (err2) {
+        onError?.(err2);
       }
     })();
     return () => unsubscribe();
@@ -90428,10 +90479,10 @@ function watchEvent(client, { address, args, batch = true, event, events, fromBl
           else
             for (const log2 of logs)
               emit.onLogs([log2]);
-        } catch (err) {
-          if (filter && err instanceof InvalidInputRpcError)
+        } catch (err2) {
+          if (filter && err2 instanceof InvalidInputRpcError)
             initialized = false;
-          emit.onError?.(err);
+          emit.onError?.(err2);
         }
       }, {
         emitOnBegin: true,
@@ -90485,14 +90536,14 @@ function watchEvent(client, { address, args, batch = true, event, events, fromBl
               });
               const formatted = formatLog(log2, { args: args2, eventName });
               onLogs([formatted]);
-            } catch (err) {
+            } catch (err2) {
               let eventName;
               let isUnnamed;
-              if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
+              if (err2 instanceof DecodeLogDataMismatch || err2 instanceof DecodeLogTopicsMismatch) {
                 if (strict_)
                   return;
-                eventName = err.abiItem.name;
-                isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
+                eventName = err2.abiItem.name;
+                isUnnamed = err2.abiItem.inputs?.some((x) => !("name" in x && x.name));
               }
               const formatted = formatLog(log2, {
                 args: isUnnamed ? [] : {},
@@ -90508,8 +90559,8 @@ function watchEvent(client, { address, args, batch = true, event, events, fromBl
         unsubscribe = unsubscribe_;
         if (!active)
           unsubscribe();
-      } catch (err) {
-        onError?.(err);
+      } catch (err2) {
+        onError?.(err2);
       }
     })();
     return () => unsubscribe();
@@ -90537,9 +90588,9 @@ function watchPendingTransactions(client, { batch = true, onError, onTransaction
             try {
               filter = await getAction(client, createPendingTransactionFilter, "createPendingTransactionFilter")({});
               return;
-            } catch (err) {
+            } catch (err2) {
               unwatch();
-              throw err;
+              throw err2;
             }
           }
           const hashes = await getAction(client, getFilterChanges, "getFilterChanges")({ filter });
@@ -90550,8 +90601,8 @@ function watchPendingTransactions(client, { batch = true, onError, onTransaction
           else
             for (const hash4 of hashes)
               emit.onTransactions([hash4]);
-        } catch (err) {
-          emit.onError?.(err);
+        } catch (err2) {
+          emit.onError?.(err2);
         }
       }, {
         emitOnBegin: true,
@@ -90584,8 +90635,8 @@ function watchPendingTransactions(client, { batch = true, onError, onTransaction
         unsubscribe = unsubscribe_;
         if (!active)
           unsubscribe();
-      } catch (err) {
-        onError?.(err);
+      } catch (err2) {
+        onError?.(err2);
       }
     })();
     return () => unsubscribe();
@@ -90880,42 +90931,6 @@ var requestWithHeadersSchema = requestSchema.extend({
 // src/server/types.ts
 init_cjs_shims();
 
-// src/lib/log.ts
-init_cjs_shims();
-var import_fs = require("fs");
-var import_path = require("path");
-var import_os = require("os");
-var LOG_DIR = (0, import_path.join)((0, import_os.homedir)(), ".x402scan-mcp");
-var LOG_FILE = (0, import_path.join)(LOG_DIR, "mcp.log");
-var DEBUG = process.env.X402_DEBUG === "true";
-try {
-  (0, import_fs.mkdirSync)(LOG_DIR, { recursive: true });
-} catch {
-}
-function format(args) {
-  return args.map(
-    (a) => typeof a === "object" && a !== null ? JSON.stringify(a) : String(a)
-  ).join(" ");
-}
-function write(level, msg, args) {
-  const formatted = args.length ? `${msg} ${format(args)}` : msg;
-  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${level}] ${formatted}
-`;
-  try {
-    (0, import_fs.appendFileSync)(LOG_FILE, line);
-  } catch {
-  }
-  if (process.env.X402_DEBUG === "true") {
-    console.error(`[x402scan] ${formatted}`);
-  }
-}
-var log = {
-  info: (msg, ...args) => write("INFO", msg, args),
-  error: (msg, ...args) => write("ERROR", msg, args),
-  debug: (msg, ...args) => DEBUG && write("DEBUG", msg, args),
-  path: LOG_FILE
-};
-
 // src/lib/networks.ts
 init_cjs_shims();
 
@@ -92203,10 +92218,597 @@ var open_default = open;
 // src/lib/wait.ts
 init_cjs_shims();
 
+// src/lib/redeem-invite.ts
+init_cjs_shims();
+
+// ../../../node_modules/.pnpm/neverthrow@8.2.0/node_modules/neverthrow/dist/index.es.js
+init_cjs_shims();
+var defaultErrorConfig = {
+  withStackTrace: false
+};
+var createNeverThrowError = (message, result, config2 = defaultErrorConfig) => {
+  const data = result.isOk() ? { type: "Ok", value: result.value } : { type: "Err", value: result.error };
+  const maybeStack = config2.withStackTrace ? new Error().stack : void 0;
+  return {
+    data,
+    message,
+    stack: maybeStack
+  };
+};
+function __awaiter(thisArg, _arguments, P2, generator) {
+  function adopt(value) {
+    return value instanceof P2 ? value : new P2(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P2 || (P2 = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e2) {
+        reject(e2);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e2) {
+        reject(e2);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+function __values(o2) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o2[s], i = 0;
+  if (m) return m.call(o2);
+  if (o2 && typeof o2.length === "number") return {
+    next: function() {
+      if (o2 && i >= o2.length) o2 = void 0;
+      return { value: o2 && o2[i++], done: !o2 };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __await(v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+function __asyncGenerator(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g2 = generator.apply(thisArg, _arguments || []), i, q2 = [];
+  return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function awaitReturn(f) {
+    return function(v) {
+      return Promise.resolve(v).then(f, reject);
+    };
+  }
+  function verb(n, f) {
+    if (g2[n]) {
+      i[n] = function(v) {
+        return new Promise(function(a, b2) {
+          q2.push([n, v, a, b2]) > 1 || resume(n, v);
+        });
+      };
+      if (f) i[n] = f(i[n]);
+    }
+  }
+  function resume(n, v) {
+    try {
+      step(g2[n](v));
+    } catch (e2) {
+      settle(q2[0][3], e2);
+    }
+  }
+  function step(r2) {
+    r2.value instanceof __await ? Promise.resolve(r2.value.v).then(fulfill, reject) : settle(q2[0][2], r2);
+  }
+  function fulfill(value) {
+    resume("next", value);
+  }
+  function reject(value) {
+    resume("throw", value);
+  }
+  function settle(f, v) {
+    if (f(v), q2.shift(), q2.length) resume(q2[0][0], q2[0][1]);
+  }
+}
+function __asyncDelegator(o2) {
+  var i, p;
+  return i = {}, verb("next"), verb("throw", function(e2) {
+    throw e2;
+  }), verb("return"), i[Symbol.iterator] = function() {
+    return this;
+  }, i;
+  function verb(n, f) {
+    i[n] = o2[n] ? function(v) {
+      return (p = !p) ? { value: __await(o2[n](v)), done: false } : f ? f(v) : v;
+    } : f;
+  }
+}
+function __asyncValues(o2) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o2[Symbol.asyncIterator], i;
+  return m ? m.call(o2) : (o2 = typeof __values === "function" ? __values(o2) : o2[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i);
+  function verb(n) {
+    i[n] = o2[n] && function(v) {
+      return new Promise(function(resolve, reject) {
+        v = o2[n](v), settle(resolve, reject, v.done, v.value);
+      });
+    };
+  }
+  function settle(resolve, reject, d2, v) {
+    Promise.resolve(v).then(function(v2) {
+      resolve({ value: v2, done: d2 });
+    }, reject);
+  }
+}
+var ResultAsync = class _ResultAsync {
+  constructor(res) {
+    this._promise = res;
+  }
+  static fromSafePromise(promise2) {
+    const newPromise = promise2.then((value) => new Ok(value));
+    return new _ResultAsync(newPromise);
+  }
+  static fromPromise(promise2, errorFn) {
+    const newPromise = promise2.then((value) => new Ok(value)).catch((e2) => new Err(errorFn(e2)));
+    return new _ResultAsync(newPromise);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromThrowable(fn, errorFn) {
+    return (...args) => {
+      return new _ResultAsync((() => __awaiter(this, void 0, void 0, function* () {
+        try {
+          return new Ok(yield fn(...args));
+        } catch (error48) {
+          return new Err(errorFn ? errorFn(error48) : error48);
+        }
+      }))());
+    };
+  }
+  static combine(asyncResultList) {
+    return combineResultAsyncList(asyncResultList);
+  }
+  static combineWithAllErrors(asyncResultList) {
+    return combineResultAsyncListWithAllErrors(asyncResultList);
+  }
+  map(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      return new Ok(yield f(res.value));
+    })));
+  }
+  andThrough(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      const newRes = yield f(res.value);
+      if (newRes.isErr()) {
+        return new Err(newRes.error);
+      }
+      return new Ok(res.value);
+    })));
+  }
+  andTee(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      try {
+        yield f(res.value);
+      } catch (e2) {
+      }
+      return new Ok(res.value);
+    })));
+  }
+  orTee(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isOk()) {
+        return new Ok(res.value);
+      }
+      try {
+        yield f(res.error);
+      } catch (e2) {
+      }
+      return new Err(res.error);
+    })));
+  }
+  mapErr(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isOk()) {
+        return new Ok(res.value);
+      }
+      return new Err(yield f(res.error));
+    })));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThen(f) {
+    return new _ResultAsync(this._promise.then((res) => {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      const newValue = f(res.value);
+      return newValue instanceof _ResultAsync ? newValue._promise : newValue;
+    }));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  orElse(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return f(res.error);
+      }
+      return new Ok(res.value);
+    })));
+  }
+  match(ok2, _err) {
+    return this._promise.then((res) => res.match(ok2, _err));
+  }
+  unwrapOr(t) {
+    return this._promise.then((res) => res.unwrapOr(t));
+  }
+  /**
+   * @deprecated will be removed in 9.0.0.
+   *
+   * You can use `safeTry` without this method.
+   * @example
+   * ```typescript
+   * safeTry(async function* () {
+   *   const okValue = yield* yourResult
+   * })
+   * ```
+   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+   */
+  safeUnwrap() {
+    return __asyncGenerator(this, arguments, function* safeUnwrap_1() {
+      return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(yield __await(this._promise.then((res) => res.safeUnwrap()))))));
+    });
+  }
+  // Makes ResultAsync implement PromiseLike<Result>
+  then(successCallback, failureCallback) {
+    return this._promise.then(successCallback, failureCallback);
+  }
+  [Symbol.asyncIterator]() {
+    return __asyncGenerator(this, arguments, function* _a2() {
+      const result = yield __await(this._promise);
+      if (result.isErr()) {
+        yield yield __await(errAsync(result.error));
+      }
+      return yield __await(result.value);
+    });
+  }
+};
+function errAsync(err2) {
+  return new ResultAsync(Promise.resolve(new Err(err2)));
+}
+var fromPromise = ResultAsync.fromPromise;
+var fromSafePromise = ResultAsync.fromSafePromise;
+var fromAsyncThrowable = ResultAsync.fromThrowable;
+var combineResultList = (resultList) => {
+  let acc = ok([]);
+  for (const result of resultList) {
+    if (result.isErr()) {
+      acc = err(result.error);
+      break;
+    } else {
+      acc.map((list) => list.push(result.value));
+    }
+  }
+  return acc;
+};
+var combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
+var combineResultListWithAllErrors = (resultList) => {
+  let acc = ok([]);
+  for (const result of resultList) {
+    if (result.isErr() && acc.isErr()) {
+      acc.error.push(result.error);
+    } else if (result.isErr() && acc.isOk()) {
+      acc = err([result.error]);
+    } else if (result.isOk() && acc.isOk()) {
+      acc.value.push(result.value);
+    }
+  }
+  return acc;
+};
+var combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
+var Result;
+(function(Result2) {
+  function fromThrowable2(fn, errorFn) {
+    return (...args) => {
+      try {
+        const result = fn(...args);
+        return ok(result);
+      } catch (e2) {
+        return err(errorFn ? errorFn(e2) : e2);
+      }
+    };
+  }
+  Result2.fromThrowable = fromThrowable2;
+  function combine(resultList) {
+    return combineResultList(resultList);
+  }
+  Result2.combine = combine;
+  function combineWithAllErrors(resultList) {
+    return combineResultListWithAllErrors(resultList);
+  }
+  Result2.combineWithAllErrors = combineWithAllErrors;
+})(Result || (Result = {}));
+function ok(value) {
+  return new Ok(value);
+}
+function err(err2) {
+  return new Err(err2);
+}
+var Ok = class {
+  constructor(value) {
+    this.value = value;
+  }
+  isOk() {
+    return true;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+  map(f) {
+    return ok(f(this.value));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  mapErr(_f) {
+    return ok(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThen(f) {
+    return f(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThrough(f) {
+    return f(this.value).map((_value) => this.value);
+  }
+  andTee(f) {
+    try {
+      f(this.value);
+    } catch (e2) {
+    }
+    return ok(this.value);
+  }
+  orTee(_f) {
+    return ok(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  orElse(_f) {
+    return ok(this.value);
+  }
+  asyncAndThen(f) {
+    return f(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  asyncAndThrough(f) {
+    return f(this.value).map(() => this.value);
+  }
+  asyncMap(f) {
+    return ResultAsync.fromSafePromise(f(this.value));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  unwrapOr(_v) {
+    return this.value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  match(ok2, _err) {
+    return ok2(this.value);
+  }
+  safeUnwrap() {
+    const value = this.value;
+    return (function* () {
+      return value;
+    })();
+  }
+  _unsafeUnwrap(_3) {
+    return this.value;
+  }
+  _unsafeUnwrapErr(config2) {
+    throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config2);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-this-alias, require-yield
+  *[Symbol.iterator]() {
+    return this.value;
+  }
+};
+var Err = class {
+  constructor(error48) {
+    this.error = error48;
+  }
+  isOk() {
+    return false;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  map(_f) {
+    return err(this.error);
+  }
+  mapErr(f) {
+    return err(f(this.error));
+  }
+  andThrough(_f) {
+    return err(this.error);
+  }
+  andTee(_f) {
+    return err(this.error);
+  }
+  orTee(f) {
+    try {
+      f(this.error);
+    } catch (e2) {
+    }
+    return err(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThen(_f) {
+    return err(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  orElse(f) {
+    return f(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  asyncAndThen(_f) {
+    return errAsync(this.error);
+  }
+  asyncAndThrough(_f) {
+    return errAsync(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  asyncMap(_f) {
+    return errAsync(this.error);
+  }
+  unwrapOr(v) {
+    return v;
+  }
+  match(_ok, err2) {
+    return err2(this.error);
+  }
+  safeUnwrap() {
+    const error48 = this.error;
+    return (function* () {
+      yield err(error48);
+      throw new Error("Do not use this generator out of `safeTry`");
+    })();
+  }
+  _unsafeUnwrap(config2) {
+    throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config2);
+  }
+  _unsafeUnwrapErr(_3) {
+    return this.error;
+  }
+  *[Symbol.iterator]() {
+    const self2 = this;
+    yield self2;
+    return self2;
+  }
+};
+var fromThrowable = Result.fromThrowable;
+
+// src/lib/safe-fetch.ts
+init_cjs_shims();
+function safeFetch(input, init) {
+  return ResultAsync.fromPromise(
+    fetch(input, init),
+    (error48) => ({
+      type: "network",
+      message: "Network error",
+      error: error48 instanceof Error ? error48 : new Error(String(error48))
+    })
+  );
+}
+var safeFetchJson = (input, init, errorMessage) => {
+  return safeFetch(input, init).andThen((response) => {
+    if (!response.ok) {
+      return ResultAsync.fromSafePromise(
+        response.json().catch(() => void 0)
+      ).andThen(
+        (json2) => err({
+          type: "http",
+          message: json2 !== void 0 && errorMessage ? errorMessage(json2) : response.statusText,
+          status: response.status,
+          headers: response.headers,
+          json: json2
+        })
+      );
+    }
+    return ResultAsync.fromPromise(
+      response.json(),
+      (error48) => ({
+        type: "parse",
+        message: "Could not parse JSON from response",
+        error: error48 instanceof Error ? error48 : new Error(String(error48))
+      })
+    );
+  });
+};
+
+// src/lib/utils.ts
+init_cjs_shims();
+var getBaseUrl = (dev) => {
+  return dev ? "http://localhost:3000" : "https://x402scan.com";
+};
+
+// src/lib/state.ts
+init_cjs_shims();
+var import_fs3 = __toESM(require("fs"), 1);
+var STATE_FILE = configFile("state.json");
+var stateSchema = zod_default.looseObject({
+  redeemedCodes: zod_default.array(zod_default.string())
+}).partial();
+var getState = () => {
+  if (!import_fs3.default.existsSync(STATE_FILE)) {
+    import_fs3.default.writeFileSync(STATE_FILE, JSON.stringify({}));
+    return {};
+  }
+  const result = stateSchema.safeParse(
+    JSON.parse(import_fs3.default.readFileSync(STATE_FILE, "utf-8"))
+  );
+  if (!result.success) {
+    log.error("Failed to parse state", { error: result.error });
+    return {};
+  }
+  return result.data;
+};
+var setState = (state) => {
+  const existing = getState();
+  const newState = stateSchema.parse({ ...existing, ...state });
+  import_fs3.default.writeFileSync(STATE_FILE, JSON.stringify(newState, null, 2));
+};
+
+// src/lib/redeem-invite.ts
+var redeemInviteCode = async ({
+  code,
+  dev,
+  address
+}) => {
+  const state = getState();
+  if (state.redeemedCodes?.includes(code)) {
+    return Promise.resolve(
+      errAsync({
+        success: false,
+        message: "This invite code has already been redeemed"
+      })
+    );
+  }
+  return await safeFetchJson(
+    `${getBaseUrl(dev)}/api/invite/redeem`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        code,
+        recipientAddr: address
+      })
+    },
+    ({ message }) => message
+  ).andTee((result) => {
+    if (result.success) {
+      setState({
+        redeemedCodes: [...state.redeemedCodes ?? [], code]
+      });
+    }
+  });
+};
+
 // src/lib/deposit.ts
 var getDepositLink = (address, flags) => {
-  const baseUrl = flags.dev ? "http://localhost:3000" : "https://x402scan.com";
-  return `${baseUrl}/deposit/${address}`;
+  return `${getBaseUrl(flags.dev)}/deposit/${address}`;
 };
 var openDepositLink = async (address, flags) => {
   const depositLink = getDepositLink(address, flags);
@@ -92248,6 +92850,23 @@ You can deposit USDC at ${getDepositLink(address, flags)}`
   return balance;
 };
 
+// src/server/lib/parse-response.ts
+init_cjs_shims();
+var parseResponse = async (response) => {
+  try {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      return await response.json();
+    } else if (contentType.includes("image/")) {
+      return await response.arrayBuffer();
+    } else {
+      return await response.text();
+    }
+  } catch {
+    return void 0;
+  }
+};
+
 // src/server/tools/fetch-x402-resource.ts
 var registerFetchX402ResourceTool = ({
   server,
@@ -92300,9 +92919,8 @@ var registerFetchX402ResourceTool = ({
           }
         });
         if (!response.ok) {
-          const errorData = await response.text();
           const errorResponse = {
-            data: errorData,
+            data: await parseResponse(response),
             statusCode: response.status,
             state
           };
@@ -92325,11 +92943,11 @@ var registerFetchX402ResourceTool = ({
         };
         const settlement = getSettlement();
         return mcpSuccess({
-          data: await response.text().catch(() => void 0),
+          data: await parseResponse(response),
           payment: settlement
         });
-      } catch (err) {
-        return mcpError(err, { state });
+      } catch (err2) {
+        return mcpError(err2, { state });
       }
     }
   );
@@ -92862,8 +93480,8 @@ var registerAuthTools = ({ server, account }) => {
             chainId: serverInfo.chainId
           }
         });
-      } catch (err) {
-        return mcpError(err, { tool: "authed_call", url: url2 });
+      } catch (err2) {
+        return mcpError(err2, { tool: "authed_call", url: url2 });
       }
     }
   );
@@ -92967,8 +93585,131 @@ var registerCheckX402EndpointTool = ({ server }) => {
           statusCode: response.status,
           routeDetails
         });
-      } catch (err) {
-        return mcpError(err, { tool: "query_endpoint", url: url2 });
+      } catch (err2) {
+        return mcpError(err2, { tool: "query_endpoint", url: url2 });
+      }
+    }
+  );
+};
+
+// src/server/tools/redeem-invite.ts
+init_cjs_shims();
+var registerRedeemInviteTool = ({
+  server,
+  account: { address },
+  flags
+}) => {
+  const baseUrl = flags.dev ? "http://localhost:3000" : "https://x402scan.com";
+  server.registerTool(
+    "redeem_invite",
+    {
+      description: "Redeem an invite code to receive USDC.",
+      inputSchema: zod_default.object({
+        code: zod_default.string().min(1).describe("The invite code")
+      })
+    },
+    async ({ code }) => {
+      const res = await fetch(`${baseUrl}/api/invite/redeem`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ code, recipientAddr: address })
+      });
+      const data = await res.json();
+      if (!data.success) {
+        return mcpError(data.error ?? "Failed to redeem invite code");
+      }
+      return mcpSuccess({
+        amount: `${data.amount} USDC`,
+        txHash: data.txHash
+      });
+    }
+  );
+};
+
+// src/server/tools/telemetry.ts
+init_cjs_shims();
+
+// src/server/lib/version.ts
+init_cjs_shims();
+var import_fs5 = require("fs");
+var import_path2 = require("path");
+var import_url = require("url");
+function getVersion2() {
+  if (true) {
+    return "0.0.4";
+  }
+  const __dirname3 = (0, import_path2.dirname)((0, import_url.fileURLToPath)(importMetaUrl));
+  const pkg = JSON.parse(
+    (0, import_fs5.readFileSync)((0, import_path2.join)(__dirname3, "../../../package.json"), "utf-8")
+  );
+  return pkg.version;
+}
+var MCP_VERSION = getVersion2();
+
+// src/server/tools/telemetry.ts
+var errorReportSchema = external_exports3.object({
+  tool: external_exports3.string().describe("MCP tool name"),
+  resource: external_exports3.string().optional().describe("x402 resource URL"),
+  summary: external_exports3.string().describe("1-2 sentence summary"),
+  errorMessage: external_exports3.string().describe("Error message"),
+  stack: external_exports3.string().optional().describe("Stack trace"),
+  fullReport: external_exports3.string().optional().describe("Detailed report with context, logs, repro steps")
+});
+var registerTelemetryTools = ({
+  server,
+  account: { address },
+  flags
+}) => {
+  const baseUrl = flags.dev ? "http://localhost:3000" : "https://x402scan.com";
+  server.registerTool(
+    "report_error",
+    {
+      description: "EMERGENCY ONLY. Report critical MCP tool bugs. Do NOT use for normal errors (balance, network, 4xx) - those are recoverable.",
+      inputSchema: errorReportSchema
+    },
+    async (input) => {
+      try {
+        log.info("Submitting error report", {
+          tool: input.tool,
+          resource: input.resource,
+          summary: input.summary
+        });
+        const report = {
+          ...input,
+          walletAddress: address,
+          mcpVersion: MCP_VERSION,
+          reportedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        const response = await fetch(`${baseUrl}/api/telemetry`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(report)
+        });
+        if (!response.ok) {
+          const errorText = await response.text().catch(() => "Unknown error");
+          log.error("Failed to submit error report", {
+            status: response.status,
+            error: errorText
+          });
+          return mcpError(
+            `Failed to submit error report: ${response.status} ${errorText}`,
+            { tool: "report_error" }
+          );
+        }
+        const result = await response.json();
+        log.info("Error report submitted successfully", {
+          reportId: result.reportId
+        });
+        return mcpSuccess({
+          submitted: true,
+          reportId: result.reportId,
+          message: "Error report submitted successfully. The x402scan team will investigate."
+        });
+      } catch (err2) {
+        log.error("Failed to submit error report", { error: err2 });
+        return mcpError(err2, { tool: "report_error" });
       }
     }
   );
@@ -93100,9 +93841,7 @@ var getResourceResponse = async (resource, response) => {
 // src/lib/wallet.ts
 init_cjs_shims();
 var import_crypto2 = require("crypto");
-var fs7 = __toESM(require("fs/promises"), 1);
-var import_path2 = require("path");
-var import_os2 = require("os");
+var fs9 = __toESM(require("fs/promises"), 1);
 
 // ../../../node_modules/.pnpm/viem@2.44.1_bufferutil@4.0.9_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.3.5/node_modules/viem/_esm/accounts/index.js
 init_cjs_shims();
@@ -93254,8 +93993,7 @@ function privateKeyToAccount(privateKey, options = {}) {
 }
 
 // src/lib/wallet.ts
-var KEYSTORE_DIR = (0, import_path2.join)((0, import_os2.homedir)(), ".x402scan-mcp");
-var KEYSTORE_FILE = (0, import_path2.join)(KEYSTORE_DIR, "wallet.json");
+var WALLET_FILE = configFile("wallet.json");
 var storedWalletSchema = zod_default.object({
   privateKey: ethereumPrivateKeySchema,
   address: ethereumAddressSchema,
@@ -93268,7 +94006,7 @@ async function getWallet() {
     return { account: account2, isNew: false };
   }
   try {
-    const data = await fs7.readFile(KEYSTORE_FILE, "utf-8");
+    const data = await fs9.readFile(WALLET_FILE, "utf-8");
     const stored2 = storedWalletSchema.parse(JSON.parse(data));
     const account2 = privateKeyToAccount(stored2.privateKey);
     log.info(`Loaded wallet: ${account2.address}`);
@@ -93282,14 +94020,13 @@ async function getWallet() {
     address: account.address,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await fs7.mkdir(KEYSTORE_DIR, { recursive: true });
-  await fs7.writeFile(KEYSTORE_FILE, JSON.stringify(stored, null, 2));
+  await fs9.writeFile(WALLET_FILE, JSON.stringify(stored, null, 2));
   try {
-    await fs7.chmod(KEYSTORE_FILE, 384);
+    await fs9.chmod(WALLET_FILE, 384);
   } catch {
   }
   log.info(`Created wallet: ${account.address}`);
-  log.info(`Saved to: ${KEYSTORE_FILE}`);
+  log.info(`Saved to: ${WALLET_FILE}`);
   return { account, isNew: true };
 }
 
@@ -93331,9 +94068,9 @@ async function lookupDnsTxtRecord(hostname3) {
       log.debug(`DNS TXT value is not a valid URL: ${txtValue}`);
       return null;
     }
-  } catch (err) {
+  } catch (err2) {
     log.debug(
-      `DNS lookup error: ${err instanceof Error ? err.message : String(err)}`
+      `DNS lookup error: ${err2 instanceof Error ? err2.message : String(err2)}`
     );
     return null;
   }
@@ -93356,10 +94093,10 @@ async function fetchLlmsTxt(origin) {
       return { found: false, error: "llms.txt is empty" };
     }
     return { found: true, content };
-  } catch (err) {
+  } catch (err2) {
     return {
       found: false,
-      error: `Network error: ${err instanceof Error ? err.message : String(err)}`
+      error: `Network error: ${err2 instanceof Error ? err2.message : String(err2)}`
     };
   }
 }
@@ -93396,10 +94133,10 @@ async function fetchDiscoveryFromUrl(url2) {
       };
     }
     return { found: true, document: parsed.data };
-  } catch (err) {
+  } catch (err2) {
     return {
       found: false,
-      error: `Network error: ${err instanceof Error ? err.message : String(err)}`
+      error: `Network error: ${err2 instanceof Error ? err2.message : String(err2)}`
     };
   }
 }
@@ -93491,11 +94228,11 @@ async function queryResource(url2) {
       resource.signInWithX = { required: true, info: siwx.info };
     }
     return resource;
-  } catch (err) {
+  } catch (err2) {
     return {
       url: url2,
       isX402Endpoint: false,
-      error: err instanceof Error ? err.message : String(err)
+      error: err2 instanceof Error ? err2.message : String(err2)
     };
   }
 }
@@ -93529,7 +94266,7 @@ function registerDiscoveryTools(server) {
         )
       }
     },
-    async ({ url: url2, testResources, concurrency }) => {
+    async ({ url: url2, fanOut, concurrency }) => {
       try {
         const origin = getOrigin(url2);
         log.info(`Discovering resources for origin: ${origin}`);
@@ -93563,7 +94300,7 @@ function registerDiscoveryTools(server) {
           usage: "Use query_endpoint to get full pricing/requirements for a resource. Use execute_call (for payment) or authed_call (for SIWX auth) to call it.",
           resources: []
         };
-        if (!testResources) {
+        if (!fanOut) {
           result.resources = doc.resources.map((resourceUrl) => ({
             url: resourceUrl
           }));
@@ -93580,8 +94317,8 @@ function registerDiscoveryTools(server) {
         }
         result.resources = allResources;
         return mcpSuccess(result);
-      } catch (err) {
-        return mcpError(err, { tool: "discover_resources", url: url2 });
+      } catch (err2) {
+        return mcpError(err2, { tool: "discover_resources", url: url2 });
       }
     }
   );
@@ -93604,11 +94341,20 @@ function getHostname(origin) {
 // src/server/index.ts
 var startServer = async (flags) => {
   log.info("Starting x402scan-mcp...");
+  const { dev, invite } = flags;
   const { account } = await getWallet();
+  const code = invite ?? process.env.INVITE_CODE;
+  if (code) {
+    await redeemInviteCode({
+      code,
+      dev,
+      address: account.address
+    });
+  }
   const server = new McpServer(
     {
       name: "@x402scan/mcp",
-      version: "0.0.1",
+      version: MCP_VERSION,
       websiteUrl: "https://x402scan.com/mcp",
       icons: [{ src: "https://x402scan.com/logo.svg" }]
     },
@@ -93630,7 +94376,9 @@ var startServer = async (flags) => {
   registerAuthTools(props);
   registerWalletTools(props);
   registerCheckX402EndpointTool(props);
+  registerRedeemInviteTool(props);
   registerDiscoveryTools(server);
+  registerTelemetryTools(props);
   await registerOrigins({ server, flags });
   const transport = new StdioServerTransport();
   await server.connect(transport);
@@ -93644,8 +94392,8 @@ var startServer = async (flags) => {
 };
 
 // src/run-server.ts
-startServer({ dev: false }).catch((err) => {
-  console.error(err);
+startServer({ dev: false }).catch((err2) => {
+  log.error(String(err2));
   process.exit(1);
 });
 /*! Bundled license information: