@lunora/x402 1.0.0-alpha.6 → 1.0.0-alpha.61

package/dist/packem_shared/createChargeMiddleware-D3yhOpFs.mjs

@@ -1,162 +0,0 @@
-import { x402HTTPResourceServer } from '@x402/core/http';
-import { toCaip2, isEvmNetwork } from './EVM_NETWORKS-BhnYWUQ4.mjs';
-import { toReceipt } from './toPaymentEventRow-DW4O9N7Y.mjs';
-import { createFacilitatorClient } from './createFacilitatorClient-rXHBnCZm.mjs';
-
-const buildResourceServer = async (config) => {
-  const { x402ResourceServer: ResourceServer } = await import('@x402/core/server');
-  const server = new ResourceServer(createFacilitatorClient(config.facilitator));
-  const network = toCaip2(config.network);
-  if (isEvmNetwork(config.network)) {
-    const { registerExactEvmScheme } = await import('@x402/evm/exact/server');
-    registerExactEvmScheme(server, { networks: [network] });
-  } else {
-    const { registerExactSvmScheme } = await import('@x402/svm/exact/server');
-    registerExactSvmScheme(server, { networks: [network] });
-  }
-  return server;
-};
-
-const PAYMENT_HEADER = "X-PAYMENT";
-const headerRecord = (headers) => {
-  const record = /* @__PURE__ */ Object.create(null);
-  for (const [key, value] of headers) {
-    record[key] = value;
-  }
-  return record;
-};
-const reportReceipt = (sink, settlement, resource, waitUntil) => {
-  if (sink === void 0) {
-    return;
-  }
-  try {
-    const sent = Promise.resolve(sink(toReceipt(settlement, { resource, ts: Date.now() }))).catch(() => {
-    });
-    waitUntil?.(sent);
-  } catch {
-  }
-};
-const resolvePayTo = (config) => {
-  const evm = isEvmNetwork(config.network);
-  const address = evm ? config.recipient.evm : config.recipient.svm;
-  if (address === void 0 || address.length === 0) {
-    throw new Error(`x402 charge on "${config.network}" needs recipient.${evm ? "evm" : "svm"} set.`);
-  }
-  return address;
-};
-const buildRoute = (config) => {
-  const accepts = {
-    network: toCaip2(config.network),
-    payTo: resolvePayTo(config),
-    price: config.price,
-    scheme: "exact"
-  };
-  return { accepts };
-};
-const createRequestAdapter = (request, url) => {
-  return {
-    getAcceptHeader: () => request.headers.get("accept") ?? "",
-    getHeader: (name) => request.headers.get(name) ?? void 0,
-    getMethod: () => request.method,
-    getPath: () => url.pathname,
-    getQueryParam: (name) => {
-      const values = url.searchParams.getAll(name);
-      if (values.length === 0) {
-        return void 0;
-      }
-      return values.length === 1 ? values[0] : values;
-    },
-    getQueryParams: () => {
-      const params = /* @__PURE__ */ Object.create(null);
-      for (const key of new Set(url.searchParams.keys())) {
-        const values = url.searchParams.getAll(key);
-        const [first, ...rest] = values;
-        if (first === void 0) {
-          continue;
-        }
-        params[key] = rest.length > 0 ? values : first;
-      }
-      return params;
-    },
-    getUrl: () => request.url,
-    getUserAgent: () => request.headers.get("user-agent") ?? ""
-  };
-};
-const toResponse = (instructions) => {
-  const headers = new Headers(instructions.headers);
-  const { body } = instructions;
-  if (body === void 0 || body === null) {
-    return new Response(void 0, { headers, status: instructions.status });
-  }
-  if (typeof body === "string") {
-    if (instructions.isHtml && !headers.has("content-type")) {
-      headers.set("content-type", "text/html; charset=utf-8");
-    }
-    return new Response(body, { headers, status: instructions.status });
-  }
-  return Response.json(body, { headers, status: instructions.status });
-};
-const withHeaders = (response, extra) => {
-  const headers = new Headers(response.headers);
-  for (const [key, value] of Object.entries(extra)) {
-    headers.set(key, value);
-  }
-  return new Response(response.body, { headers, status: response.status, statusText: response.statusText });
-};
-const createChargeMiddleware = async (config, routeOverrides, options) => {
-  const server = await buildResourceServer(config);
-  const http = new x402HTTPResourceServer(server, { ...buildRoute(config), ...routeOverrides });
-  await http.initialize();
-  const settleBeforeHandler = options?.settleBeforeHandler ?? false;
-  const handle = async (request, runHandler, deps) => {
-    const url = new URL(request.url);
-    const context = {
-      adapter: createRequestAdapter(request, url),
-      method: request.method,
-      path: url.pathname,
-      paymentHeader: request.headers.get(PAYMENT_HEADER) ?? void 0
-    };
-    const result = await http.processHTTPRequest(context);
-    if (result.type === "no-payment-required") {
-      return runHandler();
-    }
-    if (result.type === "payment-error") {
-      return toResponse(result.response);
-    }
-    const resource = routeOverrides?.resource ?? request.url;
-    if (settleBeforeHandler) {
-      const settlement2 = await http.processSettlement(result.paymentPayload, result.paymentRequirements, result.declaredExtensions, {
-        request: context
-      });
-      if (!settlement2.success) {
-        return toResponse(settlement2.response);
-      }
-      reportReceipt(config.onReceipt, settlement2, resource, deps?.waitUntil);
-      const response2 = await runHandler();
-      return withHeaders(response2, settlement2.headers);
-    }
-    let response;
-    try {
-      response = await runHandler();
-    } catch (error) {
-      try {
-        await result.cancellationDispatcher.cancel({ error, reason: "handler_threw" });
-      } catch (cancelError) {
-        console.error("x402 charge: failed to cancel payment after the handler threw", cancelError);
-      }
-      throw error;
-    }
-    const settlement = await http.processSettlement(result.paymentPayload, result.paymentRequirements, result.declaredExtensions, {
-      request: context,
-      responseHeaders: headerRecord(response.headers)
-    });
-    if (settlement.success) {
-      reportReceipt(config.onReceipt, settlement, resource, deps?.waitUntil);
-      return withHeaders(response, settlement.headers);
-    }
-    return toResponse(settlement.response);
-  };
-  return { handle };
-};
-
-export { buildRoute, createChargeMiddleware, createRequestAdapter, reportReceipt, resolvePayTo, toResponse, withHeaders };

package/dist/packem_shared/createFacilitatorClient-rXHBnCZm.mjs

@@ -1,16 +0,0 @@
-import { HTTPFacilitatorClient } from '@x402/core/server';
-import { resolveFacilitatorUrl } from './DEFAULT_FACILITATOR_URL-Cbz6kIqa.mjs';
-
-const createFacilitatorClient = (config) => {
-  const url = resolveFacilitatorUrl(config);
-  if (config?.headers === void 0) {
-    return new HTTPFacilitatorClient({ url });
-  }
-  const headers = { ...config.headers };
-  return new HTTPFacilitatorClient({
-    createAuthHeaders: () => Promise.resolve({ settle: headers, supported: headers, verify: headers }),
-    url
-  });
-};
-
-export { createFacilitatorClient };

package/dist/packem_shared/createPayFetch-BeT05njL.mjs

@@ -1,17 +0,0 @@
-import { x402Client } from '@x402/core/client';
-import { wrapFetchWithPayment } from '@x402/fetch';
-import { assertBoundedPolicy, buildSpendPolicy, buildPaymentGuard, releaseSpendOnFailure, createSpendState } from './DEFAULT_STABLECOIN_DECIMALS-CpW619nu.mjs';
-import { registerWallet } from './registerWallet-I4pVwq65.mjs';
-
-const createPayFetch = async (config, deps) => {
-  assertBoundedPolicy(config.policy);
-  const client = new x402Client();
-  await registerWallet(client, config, deps);
-  const state = createSpendState();
-  client.registerPolicy(buildSpendPolicy(config.policy));
-  client.onBeforePaymentCreation(buildPaymentGuard(config.policy, state));
-  client.onPaymentCreationFailure(releaseSpendOnFailure(state));
-  return wrapFetchWithPayment(deps.fetch ?? globalThis.fetch, client);
-};
-
-export { createPayFetch };

package/dist/packem_shared/createProcedureChargeGate-eh9yv36U.mjs

@@ -1,21 +0,0 @@
-import { createChargeMiddleware } from './createChargeMiddleware-D3yhOpFs.mjs';
-
-const createProcedureChargeGate = (config) => {
-  const middlewareByFunction = /* @__PURE__ */ new Map();
-  return async (request, spec, dispatch, deps) => {
-    let pending = middlewareByFunction.get(spec.functionPath);
-    if (pending === void 0) {
-      pending = createChargeMiddleware({ ...config, price: spec.price }, { resource: spec.functionPath }, { settleBeforeHandler: true }).catch(
-        (error) => {
-          middlewareByFunction.delete(spec.functionPath);
-          throw error;
-        }
-      );
-      middlewareByFunction.set(spec.functionPath, pending);
-    }
-    const middleware = await pending;
-    return middleware.handle(request, dispatch, deps);
-  };
-};
-
-export { createProcedureChargeGate };

package/dist/packem_shared/registerWallet-I4pVwq65.mjs

@@ -1,109 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-import { toCaip2, isEvmNetwork } from './EVM_NETWORKS-BhnYWUQ4.mjs';
-
-const HEX_PRIVATE_KEY = /^0x[0-9a-fA-F]{64}$/;
-const requireSecret = async (getSecret, name) => {
-  const value = await getSecret(name);
-  if (value === void 0 || value.length === 0) {
-    throw new LunoraError("ENV_INVALID", `x402 pay: secret "${name}" is not set — the agent wallet has no key to sign with.`);
-  }
-  return value;
-};
-const assertSignerFamily = (signer, evm) => {
-  const looksEvm = signer.address.startsWith("0x");
-  if (evm && !looksEvm) {
-    throw new LunoraError("ENV_INVALID", `x402 pay: the supplied signer address "${signer.address}" is not an EVM (0x…) address, but the network is EVM.`);
-  }
-  if (!evm && looksEvm) {
-    throw new LunoraError("ENV_INVALID", `x402 pay: the supplied signer address "${signer.address}" is an EVM (0x…) address, but the network is Solana.`);
-  }
-};
-const resolveCdpEvmAccount = async (signer, getSecret) => {
-  let cdpModule;
-  try {
-    cdpModule = await import('@coinbase/cdp-sdk');
-  } catch {
-    throw new LunoraError(
-      "ENV_INVALID",
-      'x402 pay: CDP-managed custody needs the optional @coinbase/cdp-sdk peer — install it, or use "raw-key"/"signer" custody instead.'
-    );
-  }
-  const [apiKeyId, apiKeySecret, walletSecret] = await Promise.all([
-    requireSecret(getSecret, signer.apiKeyIdSecretName ?? "CDP_API_KEY_ID"),
-    requireSecret(getSecret, signer.apiKeySecretName ?? "CDP_API_KEY_SECRET"),
-    requireSecret(getSecret, signer.walletSecretName ?? "CDP_WALLET_SECRET")
-  ]);
-  const cdp = new cdpModule.CdpClient({ apiKeyId, apiKeySecret, walletSecret });
-  return cdp.evm.getOrCreateAccount({ name: signer.account });
-};
-const resolveEvmAccount = async (privateKey) => {
-  const key = privateKey.startsWith("0x") ? privateKey : `0x${privateKey}`;
-  if (!HEX_PRIVATE_KEY.test(key)) {
-    throw new LunoraError("ENV_INVALID", "x402 pay: the EVM wallet key must be a 32-byte hex private key (64 hex chars, optional 0x prefix).");
-  }
-  const { privateKeyToAccount } = await import('viem/accounts');
-  return privateKeyToAccount(key);
-};
-const resolveSvmSigner = async (secret) => {
-  const trimmed = secret.trim();
-  const { createKeyPairSignerFromBytes, createKeyPairSignerFromPrivateKeyBytes, getBase58Encoder } = await import('@solana/kit');
-  let bytes;
-  if (trimmed.startsWith("[")) {
-    let parsed;
-    try {
-      parsed = JSON.parse(trimmed);
-    } catch {
-      throw new LunoraError("ENV_INVALID", "x402 pay: the Solana wallet key looks like a JSON byte array but is not valid JSON.");
-    }
-    if (!Array.isArray(parsed) || parsed.some((entry) => typeof entry !== "number")) {
-      throw new LunoraError("ENV_INVALID", "x402 pay: the Solana wallet key JSON must be an array of byte values.");
-    }
-    bytes = Uint8Array.from(parsed);
-  } else {
-    try {
-      bytes = Uint8Array.from(getBase58Encoder().encode(trimmed));
-    } catch {
-      throw new LunoraError("ENV_INVALID", "x402 pay: the Solana wallet key must be a base58 secret key or a JSON byte array.");
-    }
-  }
-  if (bytes.length === 64) {
-    return createKeyPairSignerFromBytes(bytes);
-  }
-  if (bytes.length === 32) {
-    return createKeyPairSignerFromPrivateKeyBytes(bytes);
-  }
-  throw new LunoraError(
-    "ENV_INVALID",
-    `x402 pay: the Solana wallet key must decode to 32 or 64 bytes (got ${String(bytes.length)}). Provide a base58 secret key or a JSON byte array.`
-  );
-};
-const registerWallet = async (client, config, deps) => {
-  const network = toCaip2(config.network);
-  const { signer } = config;
-  const evm = isEvmNetwork(config.network);
-  let account;
-  if (signer.type === "signer") {
-    assertSignerFamily(signer.signer, evm);
-    account = signer.signer;
-  } else if (signer.type === "cdp") {
-    if (!evm) {
-      throw new LunoraError(
-        "NOT_IMPLEMENTED",
-        `x402 pay: CDP-managed Solana custody (account "${signer.account}") is not wired — a CDP Solana account is not a @solana/kit signer. Build a @solana/kit signer around it and pass it via the { type: "signer" } escape hatch, or use "raw-key".`
-      );
-    }
-    account = await resolveCdpEvmAccount(signer, deps.getSecret);
-  } else {
-    const secret = await requireSecret(deps.getSecret, signer.secretName);
-    account = evm ? await resolveEvmAccount(secret) : await resolveSvmSigner(secret);
-  }
-  if (evm) {
-    const { registerExactEvmScheme } = await import('@x402/evm/exact/client');
-    registerExactEvmScheme(client, { networks: [network], signer: account });
-  } else {
-    const { registerExactSvmScheme } = await import('@x402/svm/exact/client');
-    registerExactSvmScheme(client, { networks: [network], signer: account });
-  }
-};
-
-export { registerWallet, resolveEvmAccount, resolveSvmSigner };

package/dist/packem_shared/toPaymentEventRow-DW4O9N7Y.mjs

@@ -1,22 +0,0 @@
-const toReceipt = (settlement, context) => {
-  return {
-    amount: settlement.amount ?? settlement.requirements.amount,
-    asset: settlement.requirements.asset,
-    from: settlement.payer,
-    network: settlement.network,
-    resource: context.resource,
-    to: settlement.requirements.payTo,
-    ts: context.ts,
-    tx: settlement.transaction
-  };
-};
-const toPaymentEventRow = (receipt) => {
-  return {
-    processedAt: receipt.ts,
-    provider: "x402",
-    providerEventId: receipt.tx,
-    type: "x402.settled"
-  };
-};
-
-export { toPaymentEventRow, toReceipt };

package/dist/packem_shared/withX402-DILL2DvD.mjs

@@ -1,15 +0,0 @@
-import { createChargeMiddleware } from './createChargeMiddleware-D3yhOpFs.mjs';
-
-const withX402 = (config, handler) => {
-  let pending;
-  return async (context, request) => {
-    pending ??= createChargeMiddleware(config).catch((error) => {
-      pending = void 0;
-      throw error;
-    });
-    const middleware = await pending;
-    return middleware.handle(request, () => handler(context, request));
-  };
-};
-
-export { withX402 };