@x402scan/mcp 0.0.7-beta.2 → 0.0.7-beta.4

package/dist/esm/chunk-JXXC6FYE.js

@@ -0,0 +1,970 @@
+// src/shared/neverthrow/fs/index.ts
+import * as fs from "fs/promises";
+import { existsSync } from "fs";
+
+// ../../../node_modules/.pnpm/neverthrow@8.2.0/node_modules/neverthrow/dist/index.es.js
+var defaultErrorConfig = {
+  withStackTrace: false
+};
+var createNeverThrowError = (message, result, config = defaultErrorConfig) => {
+  const data = result.isOk() ? { type: "Ok", value: result.value } : { type: "Err", value: result.error };
+  const maybeStack = config.withStackTrace ? new Error().stack : void 0;
+  return {
+    data,
+    message,
+    stack: maybeStack
+  };
+};
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function() {
+      if (o && i >= o.length) o = void 0;
+      return { value: o && o[i++], done: !o };
+    }
+  };
+  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 g = generator.apply(thisArg, _arguments || []), i, q = [];
+  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 (g[n]) {
+      i[n] = function(v) {
+        return new Promise(function(a, b) {
+          q.push([n, v, a, b]) > 1 || resume(n, v);
+        });
+      };
+      if (f) i[n] = f(i[n]);
+    }
+  }
+  function resume(n, v) {
+    try {
+      step(g[n](v));
+    } catch (e) {
+      settle(q[0][3], e);
+    }
+  }
+  function step(r) {
+    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+  }
+  function fulfill(value) {
+    resume("next", value);
+  }
+  function reject(value) {
+    resume("throw", value);
+  }
+  function settle(f, v) {
+    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+  }
+}
+function __asyncDelegator(o) {
+  var i, p;
+  return i = {}, verb("next"), verb("throw", function(e) {
+    throw e;
+  }), verb("return"), i[Symbol.iterator] = function() {
+    return this;
+  }, i;
+  function verb(n, f) {
+    i[n] = o[n] ? function(v) {
+      return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v;
+    } : f;
+  }
+}
+function __asyncValues(o) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o[Symbol.asyncIterator], i;
+  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i);
+  function verb(n) {
+    i[n] = o[n] && function(v) {
+      return new Promise(function(resolve, reject) {
+        v = o[n](v), settle(resolve, reject, v.done, v.value);
+      });
+    };
+  }
+  function settle(resolve, reject, d, v) {
+    Promise.resolve(v).then(function(v2) {
+      resolve({ value: v2, done: d });
+    }, reject);
+  }
+}
+var ResultAsync = class _ResultAsync {
+  constructor(res) {
+    this._promise = res;
+  }
+  static fromSafePromise(promise) {
+    const newPromise = promise.then((value) => new Ok(value));
+    return new _ResultAsync(newPromise);
+  }
+  static fromPromise(promise, errorFn) {
+    const newPromise = promise.then((value) => new Ok(value)).catch((e) => new Err(errorFn(e)));
+    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 (error) {
+          return new Err(errorFn ? errorFn(error) : error);
+        }
+      }))());
+    };
+  }
+  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 (e) {
+      }
+      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 (e) {
+      }
+      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(ok3, _err) {
+    return this._promise.then((res) => res.match(ok3, _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* _a() {
+      const result = yield __await(this._promise);
+      if (result.isErr()) {
+        yield yield __await(errAsync(result.error));
+      }
+      return yield __await(result.value);
+    });
+  }
+};
+function errAsync(err3) {
+  return new ResultAsync(Promise.resolve(new Err(err3)));
+}
+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 (e) {
+        return err(errorFn ? errorFn(e) : e);
+      }
+    };
+  }
+  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(err3) {
+  return new Err(err3);
+}
+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 (e) {
+    }
+    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(ok3, _err) {
+    return ok3(this.value);
+  }
+  safeUnwrap() {
+    const value = this.value;
+    return (function* () {
+      return value;
+    })();
+  }
+  _unsafeUnwrap(_) {
+    return this.value;
+  }
+  _unsafeUnwrapErr(config) {
+    throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-this-alias, require-yield
+  *[Symbol.iterator]() {
+    return this.value;
+  }
+};
+var Err = class {
+  constructor(error) {
+    this.error = error;
+  }
+  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 (e) {
+    }
+    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, err3) {
+    return err3(this.error);
+  }
+  safeUnwrap() {
+    const error = this.error;
+    return (function* () {
+      yield err(error);
+      throw new Error("Do not use this generator out of `safeTry`");
+    })();
+  }
+  _unsafeUnwrap(config) {
+    throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config);
+  }
+  _unsafeUnwrapErr(_) {
+    return this.error;
+  }
+  *[Symbol.iterator]() {
+    const self = this;
+    yield self;
+    return self;
+  }
+};
+var fromThrowable = Result.fromThrowable;
+
+// ../../internal/neverthrow/dist/index.js
+function resultFromPromise(type3, surface, promise, error) {
+  return ResultAsync.fromPromise(promise, (e) => ({
+    ...error(e),
+    type: type3,
+    surface
+  }));
+}
+function resultFromThrowable(type3, surface, fn, error) {
+  return Result.fromThrowable(fn, (e) => ({
+    ...error(e),
+    type: type3,
+    surface
+  }))();
+}
+function ok2(data) {
+  return ok(data);
+}
+function err2(type3, surface, error) {
+  return err({
+    ...error,
+    type: type3,
+    surface
+  });
+}
+
+// src/shared/neverthrow/fs/index.ts
+var errorType = "fs";
+var fsErr = (surface, error) => err2(errorType, surface, error);
+var fsResultFromPromise = (surface, promise, error) => resultFromPromise(errorType, surface, promise, error);
+var safeReadFile = (surface, path) => fsResultFromPromise(surface, fs.readFile(path, "utf-8"), () => ({
+  cause: "file_not_readable",
+  message: "Failed to read file"
+}));
+var safeWriteFile = (surface, path, data) => fsResultFromPromise(surface, fs.writeFile(path, data), () => ({
+  cause: "file_not_writable",
+  message: "Failed to write file"
+}));
+var safeAppendFile = (surface, path, data) => fsResultFromPromise(surface, fs.appendFile(path, data), () => ({
+  cause: "file_not_writable",
+  message: "Failed to append file"
+}));
+var safeChmod = (surface, path, mode) => fsResultFromPromise(surface, fs.chmod(path, mode), () => ({
+  cause: "file_not_chmodable",
+  message: "Failed to chmod file"
+}));
+var safeFileExists = (surface, path) => {
+  const fileExists = existsSync(path);
+  if (fileExists) {
+    return ok2(true);
+  }
+  return err2(errorType, surface, {
+    cause: "file_not_found",
+    message: "File not found"
+  });
+};
+
+// src/shared/fs.ts
+import { join } from "path";
+import { homedir } from "os";
+import * as fs2 from "fs";
+var BASE_DIRECTORY = join(homedir(), ".x402scan-mcp");
+if (!fs2.existsSync(BASE_DIRECTORY)) {
+  fs2.mkdirSync(BASE_DIRECTORY, { recursive: true });
+}
+var configFile = (name, defaultValue) => {
+  if (!fs2.existsSync(BASE_DIRECTORY)) {
+    fs2.mkdirSync(BASE_DIRECTORY, { recursive: true });
+  }
+  const filePath = join(BASE_DIRECTORY, name);
+  if (!fs2.existsSync(filePath)) {
+    fs2.writeFileSync(filePath, defaultValue);
+  }
+  return filePath;
+};
+
+// src/shared/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}
+`;
+  safeAppendFile("log", LOG_FILE, line);
+  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/shared/neverthrow/fetch/index.ts
+var errorType2 = "fetch";
+var fetchErr = (surface, error) => err2(errorType2, surface, error);
+var fetchHttpErr = (surface, response) => fetchErr(surface, {
+  cause: "http",
+  statusCode: response.status,
+  message: response.statusText,
+  response
+});
+var safeFetch = (surface, request) => {
+  return resultFromPromise(
+    errorType2,
+    surface,
+    fetch(request),
+    (error) => ({
+      cause: "network",
+      message: error instanceof Error ? error.message : "Network error"
+    })
+  );
+};
+var safeFetchJson = (surface, request) => {
+  return safeFetch(surface, request).andThen((response) => {
+    if (!response.ok) {
+      return fetchHttpErr(surface, response);
+    }
+    return resultFromPromise(
+      errorType2,
+      surface,
+      response.json(),
+      () => ({
+        cause: "parse",
+        message: "Could not parse JSON from response",
+        statusCode: response.status,
+        contentType: response.headers.get("content-type") ?? "Not specified"
+      })
+    );
+  });
+};
+var safeParseResponse = (surface, response) => {
+  return resultFromPromise(
+    errorType2,
+    surface,
+    (async () => {
+      const contentType = response.headers.get("content-type") ?? "";
+      switch (contentType) {
+        case "application/json":
+          return {
+            type: "json",
+            data: await response.json()
+          };
+        case "image/png":
+        case "image/jpeg":
+        case "image/gif":
+        case "image/webp":
+        case "image/svg+xml":
+        case "image/tiff":
+        case "image/bmp":
+        case "image/ico":
+          return {
+            type: "image",
+            mimeType: contentType,
+            data: await response.arrayBuffer()
+          };
+        case "audio/":
+          return {
+            type: "audio",
+            mimeType: contentType,
+            data: await response.arrayBuffer()
+          };
+        case "video/":
+          return {
+            type: "video",
+            mimeType: contentType,
+            data: await response.arrayBuffer()
+          };
+        case "application/pdf":
+          return {
+            type: "pdf",
+            mimeType: contentType,
+            data: await response.arrayBuffer()
+          };
+        case "application/octet-stream":
+          return {
+            type: "octet-stream",
+            mimeType: contentType,
+            data: await response.arrayBuffer()
+          };
+        case "multipart/form-data":
+          return { type: "formData", data: await response.formData() };
+        case "text/":
+          return { type: "text", data: await response.text() };
+        default:
+          throw new Error(`Unsupported content type: ${contentType}`);
+      }
+    })(),
+    (e) => ({
+      cause: "parse",
+      message: e instanceof Error ? e.message : "Could not parse response",
+      statusCode: response.status,
+      contentType: response.headers.get("content-type") ?? "Not specified"
+    })
+  );
+};
+var isFetchError = (error) => {
+  return error.type === errorType2;
+};
+
+// src/shared/utils.ts
+import open from "open";
+var getBaseUrl = (dev) => {
+  return dev ? "http://localhost:3000" : "https://x402scan.com";
+};
+var getDepositLink = (address, flags) => {
+  return `${getBaseUrl(flags.dev)}/mcp/deposit/${address}`;
+};
+var openDepositLink = async (address, flags) => {
+  const depositLink = getDepositLink(address, flags);
+  await open(depositLink);
+};
+
+// src/shared/state.ts
+import z from "zod";
+import fs3 from "fs";
+var STATE_FILE = configFile("state.json", "{}");
+var stateSchema = z.looseObject({
+  redeemedCodes: z.array(z.string())
+}).partial();
+var getState = () => {
+  const result = stateSchema.safeParse(
+    JSON.parse(fs3.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 });
+  fs3.writeFileSync(STATE_FILE, JSON.stringify(newState, null, 2));
+};
+
+// src/shared/redeem-invite.ts
+var redeemInviteCode = async ({
+  code,
+  dev,
+  address,
+  surface
+}) => {
+  const state = getState();
+  if (state.redeemedCodes?.includes(code)) {
+    return err2("user", surface, {
+      cause: "conflict",
+      message: "This invite code has already been redeemed"
+    });
+  }
+  const result = await safeFetchJson(
+    surface,
+    new Request(`${getBaseUrl(dev)}/api/invite/redeem`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        code,
+        recipientAddr: address
+      })
+    })
+  );
+  if (result.isOk()) {
+    setState({
+      redeemedCodes: [...state.redeemedCodes ?? [], code]
+    });
+  }
+  return result;
+};
+
+// src/shared/wallet.ts
+import { getAddress } from "viem";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+import z3 from "zod";
+
+// src/shared/neverthrow/json/index.ts
+var type = "json";
+var jsonErr = (surface, error) => {
+  return err2(type, surface, error);
+};
+var safeStringifyJson = (surface, value) => {
+  return resultFromThrowable(
+    type,
+    surface,
+    () => JSON.stringify(value),
+    () => ({
+      cause: "stringify",
+      message: "Could not stringify JSON"
+    })
+  );
+};
+var safeParseJson = (surface, value) => {
+  return resultFromThrowable(
+    type,
+    surface,
+    () => JSON.parse(value),
+    (e) => ({
+      cause: "parse",
+      message: e instanceof Error ? e.message : "Could not parse JSON"
+    })
+  );
+};
+
+// src/shared/neverthrow/parse/index.ts
+import z2 from "zod";
+var type2 = "json";
+var parseErr = (surface, error) => err2(type2, surface, error);
+var safeParse = (surface, schema, value) => {
+  const parseResult = schema.safeParse(value);
+  if (!parseResult.success) {
+    return parseErr(surface, {
+      cause: "invalid_data",
+      message: JSON.stringify(z2.treeifyError(parseResult.error), null, 2),
+      error: parseResult.error
+    });
+  }
+  return ok2(parseResult.data);
+};
+
+// src/shared/wallet.ts
+var WALLET_FILE = configFile("wallet.json", "");
+var storedWalletSchema = z3.object({
+  privateKey: z3.string().regex(/^0x[a-fA-F0-9]{64}$/, "Invalid Ethereum private key").transform((privateKey) => privateKey),
+  address: z3.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address").transform((address) => getAddress(address)),
+  createdAt: z3.string()
+});
+var walletSurface = "wallet";
+async function getWallet() {
+  if (process.env.X402_PRIVATE_KEY) {
+    const account2 = privateKeyToAccount(process.env.X402_PRIVATE_KEY);
+    log.info(`Using wallet from env: ${account2.address}`);
+    return ok2({ account: account2, isNew: false });
+  }
+  const readFileResult = await safeReadFile(walletSurface, WALLET_FILE);
+  if (!readFileResult.isOk()) {
+    const fileExistsResult = safeFileExists(walletSurface, WALLET_FILE);
+    if (fileExistsResult.isOk()) {
+      return fsErr(walletSurface, {
+        cause: "file_not_readable",
+        message: `The file exists but is not readable. Fix corrupted state file: ${WALLET_FILE}`
+      });
+    }
+  }
+  if (readFileResult.isOk()) {
+    const data = readFileResult.value;
+    const jsonParseResult = safeParseJson(walletSurface, data);
+    if (jsonParseResult.isErr()) {
+      return jsonErr(walletSurface, {
+        cause: "parse",
+        message: `The data in ${WALLET_FILE} is not valid JSON`
+      });
+    }
+    const parseResult = safeParse(
+      walletSurface,
+      storedWalletSchema,
+      jsonParseResult.value
+    );
+    if (parseResult.isErr()) {
+      return parseResult;
+    }
+    const account2 = privateKeyToAccount(parseResult.value.privateKey);
+    log.info(`Loaded wallet: ${account2.address}`);
+    return ok2({ account: account2, isNew: false });
+  }
+  const privateKey = generatePrivateKey();
+  const account = privateKeyToAccount(privateKey);
+  const stored = {
+    privateKey,
+    address: account.address,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const saveResult = await safeWriteFile(
+    walletSurface,
+    WALLET_FILE,
+    JSON.stringify(stored, null, 2)
+  ).andThen(() => safeChmod(walletSurface, WALLET_FILE, 384));
+  if (saveResult.isErr()) {
+    return saveResult;
+  }
+  log.info(`Created wallet: ${account.address}`);
+  log.info(`Saved to: ${WALLET_FILE}`);
+  return ok2({ account, isNew: true });
+}
+
+// src/shared/networks.ts
+import {
+  base,
+  baseSepolia,
+  mainnet,
+  sepolia,
+  optimism,
+  arbitrum,
+  polygon
+} from "viem/chains";
+var CHAIN_CONFIGS = {
+  "eip155:8453": {
+    chain: base,
+    caip2: "eip155:8453",
+    v1Name: "base",
+    usdcAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+  },
+  "eip155:84532": {
+    chain: baseSepolia,
+    caip2: "eip155:84532",
+    v1Name: "base-sepolia",
+    usdcAddress: "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
+  },
+  "eip155:1": {
+    chain: mainnet,
+    caip2: "eip155:1",
+    v1Name: "ethereum",
+    usdcAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+  },
+  "eip155:11155111": {
+    chain: sepolia,
+    caip2: "eip155:11155111",
+    v1Name: "ethereum-sepolia",
+    usdcAddress: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238"
+  },
+  "eip155:10": {
+    chain: optimism,
+    caip2: "eip155:10",
+    v1Name: "optimism",
+    usdcAddress: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85"
+  },
+  "eip155:42161": {
+    chain: arbitrum,
+    caip2: "eip155:42161",
+    v1Name: "arbitrum",
+    usdcAddress: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831"
+  },
+  "eip155:137": {
+    chain: polygon,
+    caip2: "eip155:137",
+    v1Name: "polygon",
+    usdcAddress: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"
+  }
+};
+var V1_TO_CAIP2 = {
+  base: "eip155:8453",
+  "base-sepolia": "eip155:84532",
+  ethereum: "eip155:1",
+  "ethereum-sepolia": "eip155:11155111",
+  optimism: "eip155:10",
+  arbitrum: "eip155:42161",
+  polygon: "eip155:137"
+};
+var DEFAULT_NETWORK = "eip155:8453";
+function toCaip2(network) {
+  if (network.startsWith("eip155:")) return network;
+  return V1_TO_CAIP2[network.toLowerCase()] ?? network;
+}
+function getChainConfig(network) {
+  return CHAIN_CONFIGS[toCaip2(network)];
+}
+function getChainName(network) {
+  return getChainConfig(network)?.chain.name ?? network;
+}
+
+export {
+  resultFromPromise,
+  resultFromThrowable,
+  ok2 as ok,
+  err2 as err,
+  fetchHttpErr,
+  safeFetch,
+  safeFetchJson,
+  safeParseResponse,
+  isFetchError,
+  safeStringifyJson,
+  getBaseUrl,
+  getDepositLink,
+  openDepositLink,
+  safeReadFile,
+  safeWriteFile,
+  log,
+  DEFAULT_NETWORK,
+  getChainName,
+  redeemInviteCode,
+  getWallet
+};
+//# sourceMappingURL=chunk-JXXC6FYE.js.map