@secondlayer/sdk 7.0.0 → 8.0.1

package/dist/x402.d.ts

@@ -1,160 +0,0 @@
-import { X402TokenSymbol } from "@secondlayer/shared/x402";
-import { LocalAccount } from "@secondlayer/stacks/accounts";
-import { StacksChain } from "@secondlayer/stacks/chains";
-/**
-* Client for the x402 pay-per-request rail. Turns a 402 challenge into a signed
-* `PAYMENT-SIGNATURE` and retries — gasless (the agent signs origin-only; the
-* facilitator sponsors the STX fee) and accountless (no key/Stripe/session).
-*
-* Three layers:
-*  - `withX402(fetch, opts)` — drop-in fetch that auto-pays on 402.
-*  - `createX402Client(opts)` — `.get/.post` returning `{ data, payment }`.
-*  - `buildSignedX402Payment` / `readX402Challenge` — primitives for custom transports.
-*/
-type X402Accept = {
-	scheme: "exact";
-	network: string;
-	asset: string;
-	/** Atomic units. */
-	amount: string;
-	payTo: string;
-	maxTimeoutSeconds: number;
-	extra: {
-		nonce: string;
-	};
-};
-type X402Challenge = {
-	x402Version: number;
-	accepts: X402Accept[];
-	error?: string;
-};
-/** Decoded `PAYMENT-RESPONSE` settlement receipt. */
-type X402Receipt = {
-	success: boolean;
-	/** Settlement tier: `optimistic` (served on broadcast-accept, reconciled
-	*  async) or `confirmed` (canonical). Absent on older deployments. */
-	state?: "optimistic" | "confirmed";
-	txid: string;
-	payer: string;
-	network: string;
-};
-/** Bitcoin-native first — sBTC is the compelling micropay asset; USDCx the
-*  dollar peg; STX the fallback. Override via `preferAssets`. */
-declare const DEFAULT_PREFER_ASSETS: X402TokenSymbol[];
-/** Default node for auto-resolving the payer's account nonce (`/v2/accounts`). */
-declare const DEFAULT_NONCE_NODE_URL = "https://api.hiro.so";
-/** Thrown when no offered asset is within the caller's spend guard / preferences. */
-declare class X402SpendGuardError extends Error {
-	constructor(message: string);
-}
-/** Read the x402 challenge from a 402 response — prefer the wire header, fall
-*  back to the JSON body. */
-declare function readX402Challenge(res: Response): Promise<X402Challenge | null>;
-/** Read the settlement receipt from a paid 200 response. */
-declare function readX402Receipt(res: Response): X402Receipt | null;
-type SelectOfferOptions = {
-	preferAssets?: X402TokenSymbol[];
-	maxAmountPerCall?: Partial<Record<X402TokenSymbol, bigint>>;
-};
-/** Choose an `accepts[]` entry by preference order, skipping any that exceed the
-*  per-asset spend cap. Throws {@link X402SpendGuardError} if none qualify. */
-declare function selectOffer(challenge: X402Challenge, opts?: SelectOfferOptions): {
-	accept: X402Accept;
-	symbol: X402TokenSymbol;
-};
-/** Fetch the payer account's next nonce from a Stacks node (`/v2/accounts`). */
-declare function resolveAccountNonce(address: string, nodeUrl?: string): Promise<number>;
-type BuildSignedX402PaymentOptions = {
-	challenge: X402Challenge;
-	account: LocalAccount;
-	/** The payer account's next nonce. */
-	accountNonce: bigint | number | string;
-	/** Preferred asset string (e.g. an sBTC/USDCx id). Defaults to the first offer. */
-	asset?: string;
-	chain?: StacksChain;
-};
-/** Build a signed, base64 `PAYMENT-SIGNATURE` header for one `accepts[]` entry. */
-declare function buildSignedX402Payment(opts: BuildSignedX402PaymentOptions): Promise<{
-	header: string;
-	accept: X402Accept;
-}>;
-type WithX402Options = SelectOfferOptions & {
-	account: LocalAccount;
-	/** Prepaid-credit token (PAYMENT-BALANCE) from a prior deposit — calls
-	*  debit the tab server-side instead of settling on-chain per call. */
-	balanceToken?: string;
-	/** Autonomous treasury policy: when the tab's remaining balance (read from
-	*  X-BALANCE-REMAINING-USD) drops below `whenBelow`, deposit `usd` more in
-	*  the background (one on-chain payment) and adopt the fresh token. */
-	topUp?: {
-		usd: number;
-		whenBelow: number;
-	};
-	/** Override the payer nonce; auto-resolved from `nodeUrl` when omitted. */
-	accountNonce?: bigint | number | string;
-	/** Node for auto-nonce lookup. Defaults to {@link DEFAULT_NONCE_NODE_URL}. */
-	nodeUrl?: string;
-	chain?: StacksChain;
-	/** Fired just before the paid retry (the call then blocks on confirmed-tier
-	*  settle, or returns near-instantly on an optimistic surface). */
-	onSettling?: (info: {
-		asset: string;
-		amount: string;
-	}) => void;
-	/** Abort the paid retry after this long. */
-	timeoutMs?: number;
-};
-type X402Fetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
-/**
-* Wrap a `fetch` so requests transparently pay on 402: select an offer (by
-* `preferAssets` + `maxAmountPerCall`), resolve the nonce, sign origin-only, and
-* retry once with `PAYMENT-SIGNATURE`. Returns the final `Response` (read the
-* receipt with {@link readX402Receipt}).
-*
-* @example
-* const x402fetch = withX402(fetch, { account });
-* const res = await x402fetch("http://127.0.0.1:3800/v1/index/events?event_type=ft_transfer");
-*/
-declare function withX402(baseFetch: typeof fetch, opts: WithX402Options): X402Fetch;
-type X402ClientOptions = WithX402Options & {
-	/** Instance API. Defaults to {@link resolveBaseUrl}. */
-	baseUrl?: string;
-	/** Override the underlying fetch (tests). */
-	fetch?: typeof fetch;
-};
-type X402Result<T = unknown> = {
-	data: T;
-	/** Settlement receipt, or null if the response carried none. */
-	payment: X402Receipt | null;
-	response: Response;
-};
-type X402Client = {
-	get<T = unknown>(path: string, o?: {
-		query?: Record<string, string>;
-	}): Promise<X402Result<T>>;
-	post<T = unknown>(path: string, o?: {
-		body?: unknown;
-	}): Promise<X402Result<T>>;
-};
-/**
-* A small client over {@link withX402}: `.get/.post` against `baseUrl`, returning
-* parsed JSON plus the settlement receipt.
-*
-* @example
-* const sl = createX402Client({ account, baseUrl: "http://127.0.0.1:3800" });
-* const { data, payment } = await sl.get("/v1/index/events", { query: { event_type: "ft_transfer" } });
-*/
-declare function createX402Client(opts: X402ClientOptions): X402Client;
-/** Caller-supplied fetch that re-runs the request with the given extra headers. */
-type X402FetchFn = (extraHeaders: Record<string, string>) => Promise<Response>;
-type PayAndRetryOptions = Omit<WithX402Options, never> & {
-	/** Required here (use `withX402` for auto-nonce). */
-	accountNonce: bigint | number | string;
-};
-/**
-* Low-level: run a request via a caller-controlled fetch; if it 402s, pay and
-* retry once. Prefer {@link withX402} for the common case (it auto-resolves the
-* nonce + selects the asset). Kept for custom transports.
-*/
-declare function payAndRetry(doFetch: X402FetchFn, opts: PayAndRetryOptions): Promise<Response>;
-export { withX402, selectOffer, resolveAccountNonce, readX402Receipt, readX402Challenge, payAndRetry, createX402Client, buildSignedX402Payment, X402SpendGuardError, X402Result, X402Receipt, X402FetchFn, X402Fetch, X402ClientOptions, X402Client, X402Challenge, X402Accept, WithX402Options, SelectOfferOptions, PayAndRetryOptions, DEFAULT_PREFER_ASSETS, DEFAULT_NONCE_NODE_URL, BuildSignedX402PaymentOptions };

package/dist/x402.js

@@ -1,506 +0,0 @@
-// src/x402.ts
-import {
-  X402_TOKENS,
-  findX402TokenByAsset
-} from "@secondlayer/shared/x402";
-import { http, createPublicClient } from "@secondlayer/stacks";
-import { getNonce } from "@secondlayer/stacks/actions";
-import {
-  serializeTransactionHex,
-  signTransactionWithAccount
-} from "@secondlayer/stacks/transactions";
-import { buildExactTransfer } from "@secondlayer/stacks/x402";
-
-// src/errors.ts
-var DOCS_BASE = "https://www.secondlayer.tools";
-
-class SecondLayerError extends Error {
-  name = "SecondLayerError";
-  shortMessage;
-  code;
-  docsUrl;
-  metaMessages;
-  retryable;
-  retryAfterSeconds;
-  constructor(shortMessage, options = {}) {
-    const detailBlocks = [
-      ...options.metaMessages ?? [],
-      ...options.details ? [options.details] : [],
-      ...options.docsUrl ? [`Docs: ${options.docsUrl}`] : []
-    ];
-    const message = [
-      shortMessage,
-      detailBlocks.length > 0 ? `
-${detailBlocks.join(`
-`)}` : ""
-    ].join("");
-    super(message, options.cause ? { cause: options.cause } : undefined);
-    this.shortMessage = shortMessage;
-    this.code = options.code;
-    this.docsUrl = options.docsUrl;
-    this.metaMessages = options.metaMessages;
-    this.retryable = options.retryable ?? false;
-    this.retryAfterSeconds = options.retryAfterSeconds;
-  }
-  walk(fn) {
-    let err = this;
-    let last = this;
-    while (err != null) {
-      if (fn?.(err))
-        return err;
-      last = err;
-      err = err.cause;
-    }
-    return fn ? null : last;
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      shortMessage: this.shortMessage,
-      cause: this.cause instanceof Error ? this.cause.message : undefined,
-      code: this.code,
-      docsUrl: this.docsUrl,
-      retryable: this.retryable,
-      retryAfterSeconds: this.retryAfterSeconds
-    };
-  }
-}
-function statusRetryable(status) {
-  return status === 429 || status >= 500;
-}
-function docsFor(status, code) {
-  if (code === "UPGRADE_REQUIRED" || status === 402)
-    return `${DOCS_BASE}/docs/authentication#pay-as-you-go-credits`;
-  if (status === 429 || status === 401)
-    return `${DOCS_BASE}/docs/authentication`;
-  return;
-}
-
-class ApiError extends SecondLayerError {
-  status;
-  body;
-  constructor(status, message, body, code, options = {}) {
-    super(message, {
-      code,
-      retryable: options.retryable ?? statusRetryable(status),
-      docsUrl: options.docsUrl ?? docsFor(status, code),
-      ...options.cause ? { cause: options.cause } : {},
-      ...options.details ? { details: options.details } : {},
-      ...options.metaMessages ? { metaMessages: options.metaMessages } : {},
-      ...options.retryAfterSeconds !== undefined ? { retryAfterSeconds: options.retryAfterSeconds } : {}
-    });
-    this.status = status;
-    this.body = body;
-    this.name = "ApiError";
-  }
-}
-
-class AuthError extends ApiError {
-  status = 401;
-  constructor(message = "API key invalid or expired.") {
-    super(401, message);
-    this.name = "AuthError";
-  }
-}
-
-class RateLimitError extends ApiError {
-  retryAfter;
-  status = 429;
-  constructor(message = "Rate limited. Try again later.", retryAfter) {
-    super(429, message, undefined, undefined, {
-      retryable: true,
-      retryAfterSeconds: parseRetryAfter(retryAfter)
-    });
-    this.retryAfter = retryAfter;
-    this.name = "RateLimitError";
-  }
-}
-
-class ValidationError extends ApiError {
-  constructor(message, status, body) {
-    super(status, message, body, undefined, { retryable: false });
-    this.name = "ValidationError";
-  }
-}
-function parseRetryAfter(value) {
-  if (!value)
-    return;
-  const seconds = Number(value);
-  if (Number.isFinite(seconds) && seconds >= 0)
-    return seconds;
-  const date = Date.parse(value);
-  if (!Number.isNaN(date))
-    return Math.max(0, (date - Date.now()) / 1000);
-  return;
-}
-
-class VersionConflictError extends ApiError {
-  currentVersion;
-  expectedVersion;
-  constructor(currentVersion, expectedVersion, message = `Version conflict: expected ${expectedVersion}, current ${currentVersion}`) {
-    super(409, message, { currentVersion, expectedVersion });
-    this.currentVersion = currentVersion;
-    this.expectedVersion = expectedVersion;
-    this.name = "VersionConflictError";
-  }
-}
-
-// src/base.ts
-var LOCAL_API_URL = "http://127.0.0.1:3800";
-function resolveBaseUrl(explicit) {
-  if (explicit && explicit.length > 0)
-    return explicit.replace(/\/+$/, "");
-  if (typeof process !== "undefined") {
-    const fromEnv = process.env?.SL_API_URL || process.env?.SECONDLAYER_API_URL;
-    if (fromEnv)
-      return fromEnv.replace(/\/+$/, "");
-  }
-  return LOCAL_API_URL;
-}
-function resolveApiKey(apiKey) {
-  if (apiKey !== undefined)
-    return apiKey;
-  if (typeof process === "undefined")
-    return;
-  return process.env?.SL_API_KEY || undefined;
-}
-function buildQuery(params) {
-  const search = new URLSearchParams;
-  for (const [name, value] of Object.entries(params)) {
-    if (value === undefined || value === null)
-      continue;
-    const serialized = Array.isArray(value) ? value.join(",") : String(value);
-    if (serialized.length === 0)
-      continue;
-    search.set(name, serialized);
-  }
-  const query = search.toString();
-  return query ? `?${query}` : "";
-}
-
-class BaseClient {
-  baseUrl;
-  apiKey;
-  origin;
-  fetchImpl;
-  constructor(options = {}) {
-    this.baseUrl = resolveBaseUrl(options.baseUrl);
-    this.apiKey = resolveApiKey(options.apiKey);
-    this.origin = options.origin ?? "cli";
-    this.fetchImpl = options.fetchImpl ?? ((...args) => fetch(...args));
-  }
-  static authHeaders(apiKey) {
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (apiKey) {
-      headers.Authorization = `Bearer ${apiKey}`;
-    }
-    return headers;
-  }
-  async request(method, path, body) {
-    const response = await this.fetchResponse(method, path, body);
-    if (response.status === 204) {
-      return;
-    }
-    return response.json();
-  }
-  async requestOrNull(method, path, body) {
-    try {
-      return await this.request(method, path, body);
-    } catch (err) {
-      if (err instanceof ApiError && err.status === 404)
-        return null;
-      throw err;
-    }
-  }
-  async requestText(method, path, body) {
-    const response = await this.fetchResponse(method, path, body);
-    return response.text();
-  }
-  async fetchResponse(method, path, body) {
-    const url = `${this.baseUrl}${path}`;
-    const headers = BaseClient.authHeaders(this.apiKey);
-    headers["x-sl-origin"] = this.origin;
-    let serializedBody;
-    if (body !== undefined && body !== null) {
-      try {
-        serializedBody = JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value);
-      } catch (err) {
-        const detail = err instanceof Error ? err.message : String(err);
-        throw new ApiError(0, `Failed to serialize request body: ${detail}`, undefined, undefined, { retryable: false });
-      }
-    }
-    let response;
-    try {
-      response = await this.fetchImpl(url, {
-        method,
-        headers,
-        body: serializedBody
-      });
-    } catch (err) {
-      throw new ApiError(0, `Cannot reach API at ${this.baseUrl}. Check your connection or try again.`, undefined, undefined, { retryable: true, cause: err instanceof Error ? err : undefined });
-    }
-    if (!response.ok) {
-      if (response.status === 401) {
-        throw new AuthError;
-      }
-      if (response.status === 429) {
-        const retryAfter = response.headers.get("Retry-After");
-        const msg = retryAfter ? `Rate limited. Wait ${retryAfter} seconds.` : "Rate limited. Try again later.";
-        throw new RateLimitError(msg, retryAfter ?? undefined);
-      }
-      if (response.status >= 500) {
-        throw new ApiError(response.status, `Server error. Try again or check status at ${this.baseUrl}/health`);
-      }
-      const errorBody = await response.text();
-      let message = `HTTP ${response.status}`;
-      let parsedBody = errorBody;
-      let code;
-      try {
-        const json = JSON.parse(errorBody);
-        parsedBody = json;
-        const err = json.error ?? json.message;
-        if (typeof err === "string") {
-          message = err;
-        } else if (err && typeof err === "object") {
-          message = JSON.stringify(err);
-        }
-        if (typeof json.code === "string") {
-          code = json.code;
-        }
-      } catch {
-        if (errorBody)
-          message = errorBody;
-      }
-      throw new ApiError(response.status, message, parsedBody, code);
-    }
-    return response;
-  }
-}
-
-// src/x402.ts
-var DEFAULT_PREFER_ASSETS = [
-  "sBTC",
-  "USDCx",
-  "STX"
-];
-var DEFAULT_NONCE_NODE_URL = "https://api.hiro.so";
-
-class X402SpendGuardError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "X402SpendGuardError";
-  }
-}
-function b64encode(value) {
-  const utf8 = new TextEncoder().encode(JSON.stringify(value));
-  let binary = "";
-  for (const byte of utf8)
-    binary += String.fromCharCode(byte);
-  return btoa(binary);
-}
-function b64decodeJson(value) {
-  try {
-    const binary = atob(value);
-    const utf8 = Uint8Array.from(binary, (ch) => ch.charCodeAt(0));
-    return JSON.parse(new TextDecoder().decode(utf8));
-  } catch {
-    return null;
-  }
-}
-async function readX402Challenge(res) {
-  const header = res.headers.get("PAYMENT-REQUIRED");
-  if (header) {
-    const decoded = b64decodeJson(header);
-    if (decoded)
-      return decoded;
-  }
-  try {
-    return await res.clone().json();
-  } catch {
-    return null;
-  }
-}
-function readX402Receipt(res) {
-  const header = res.headers.get("PAYMENT-RESPONSE");
-  return header ? b64decodeJson(header) : null;
-}
-function selectOffer(challenge, opts = {}) {
-  const prefer = opts.preferAssets ?? DEFAULT_PREFER_ASSETS;
-  for (const symbol of prefer) {
-    const token = X402_TOKENS[symbol];
-    const accept = challenge.accepts.find((a) => a.asset === token.asset);
-    if (!accept)
-      continue;
-    const cap = opts.maxAmountPerCall?.[symbol];
-    if (cap !== undefined && BigInt(accept.amount) > cap)
-      continue;
-    return { accept, symbol };
-  }
-  throw new X402SpendGuardError("no x402 offer matched preferAssets within maxAmountPerCall");
-}
-async function resolveAccountNonce(address, nodeUrl = DEFAULT_NONCE_NODE_URL) {
-  const client = createPublicClient({ transport: http(nodeUrl) });
-  return Number(await getNonce(client, { address }));
-}
-async function buildSignedX402Payment(opts) {
-  const accept = opts.asset ? opts.challenge.accepts.find((a) => a.asset === opts.asset) : opts.challenge.accepts[0];
-  if (!accept) {
-    throw new Error(`No x402 offer${opts.asset ? ` for asset ${opts.asset}` : ""}`);
-  }
-  const token = findX402TokenByAsset(accept.asset);
-  if (!token)
-    throw new Error(`Unknown x402 asset: ${accept.asset}`);
-  const asset = token.contractId && token.assetName ? {
-    kind: "sip010",
-    contractId: token.contractId,
-    assetName: token.assetName
-  } : { kind: "stx" };
-  const tx = buildExactTransfer({
-    asset,
-    amount: BigInt(accept.amount),
-    payTo: accept.payTo,
-    payer: opts.account.address,
-    payerPublicKey: opts.account.publicKey,
-    accountNonce: opts.accountNonce,
-    nonce: accept.extra.nonce,
-    chain: opts.chain
-  });
-  const signed = await signTransactionWithAccount(tx, opts.account);
-  const header = b64encode({
-    x402Version: opts.challenge.x402Version ?? 2,
-    scheme: "exact",
-    network: accept.network,
-    asset: accept.asset,
-    payload: { transaction: serializeTransactionHex(signed) },
-    extra: { nonce: accept.extra.nonce }
-  });
-  return { header, accept };
-}
-function withX402(baseFetch, opts) {
-  const sessions = new Map;
-  let balanceToken = opts.balanceToken ?? null;
-  let toppingUp = false;
-  const originOf = (input) => {
-    try {
-      return new URL(String(input)).origin;
-    } catch {
-      return "";
-    }
-  };
-  const wrapped = async (input, init) => {
-    const origin = originOf(input);
-    const run = (extra, signal2) => baseFetch(input, {
-      ...init,
-      headers: { ...init?.headers, ...extra },
-      ...signal2 ? { signal: signal2 } : {}
-    });
-    const maybeTopUp = (res) => {
-      const policy = opts.topUp;
-      if (!policy || toppingUp || !origin)
-        return;
-      const remaining = res.headers.get("X-BALANCE-REMAINING-USD");
-      if (remaining === null || Number(remaining) >= policy.whenBelow)
-        return;
-      toppingUp = true;
-      (async () => {
-        try {
-          const dep = await wrapped(`${origin}/v1/x402/deposit?usd=${policy.usd}`, { method: "POST" });
-          if (dep.ok) {
-            const body = await dep.json();
-            if (body.balance_token)
-              balanceToken = body.balance_token;
-          }
-        } catch {} finally {
-          toppingUp = false;
-        }
-      })();
-    };
-    const remember = (res) => {
-      const voucher = res.headers.get("PAYMENT-SESSION");
-      if (voucher && origin)
-        sessions.set(origin, voucher);
-      maybeTopUp(res);
-      return res;
-    };
-    const cached = origin ? sessions.get(origin) : undefined;
-    const first = await run({
-      ...cached ? { "PAYMENT-SESSION": cached } : {},
-      ...balanceToken ? { "PAYMENT-BALANCE": balanceToken } : {}
-    });
-    if (first.status !== 402)
-      return remember(first);
-    if (cached && origin)
-      sessions.delete(origin);
-    const challenge = await readX402Challenge(first);
-    if (!challenge)
-      return first;
-    const { accept } = selectOffer(challenge, opts);
-    const accountNonce = opts.accountNonce ?? await resolveAccountNonce(opts.account.address, opts.nodeUrl);
-    const { header } = await buildSignedX402Payment({
-      challenge,
-      account: opts.account,
-      accountNonce,
-      asset: accept.asset,
-      chain: opts.chain
-    });
-    opts.onSettling?.({ asset: accept.asset, amount: accept.amount });
-    const signal = opts.timeoutMs ? AbortSignal.timeout(opts.timeoutMs) : undefined;
-    return remember(await run({ "PAYMENT-SIGNATURE": header }, signal));
-  };
-  return wrapped;
-}
-function createX402Client(opts) {
-  const f = withX402(opts.fetch ?? fetch, opts);
-  const base = resolveBaseUrl(opts.baseUrl);
-  async function request(method, path, o = {}) {
-    const qs = o.query ? `?${new URLSearchParams(o.query).toString()}` : "";
-    const init = { method };
-    if (o.body !== undefined) {
-      init.body = JSON.stringify(o.body);
-      init.headers = { "content-type": "application/json" };
-    }
-    const response = await f(`${base}${path}${qs}`, init);
-    const data = await response.json().catch(() => null);
-    return { data, payment: readX402Receipt(response), response };
-  }
-  return {
-    get: (path, o) => request("GET", path, o),
-    post: (path, o) => request("POST", path, o)
-  };
-}
-async function payAndRetry(doFetch, opts) {
-  const first = await doFetch({});
-  if (first.status !== 402)
-    return first;
-  const challenge = await readX402Challenge(first);
-  if (!challenge)
-    return first;
-  const { accept } = selectOffer(challenge, opts);
-  const { header } = await buildSignedX402Payment({
-    challenge,
-    account: opts.account,
-    accountNonce: opts.accountNonce,
-    asset: accept.asset,
-    chain: opts.chain
-  });
-  return doFetch({ "PAYMENT-SIGNATURE": header });
-}
-export {
-  withX402,
-  selectOffer,
-  resolveAccountNonce,
-  readX402Receipt,
-  readX402Challenge,
-  payAndRetry,
-  createX402Client,
-  buildSignedX402Payment,
-  X402SpendGuardError,
-  DEFAULT_PREFER_ASSETS,
-  DEFAULT_NONCE_NODE_URL
-};
-
-//# debugId=BE9E5DFBC321406664756E2164756E21
-//# sourceMappingURL=x402.js.map