kawasekit 0.0.1 → 0.1.0-alpha.0

package/dist/chunk-3S34WBAW.js

@@ -0,0 +1,856 @@
+import { X402InvalidPayloadError, X402_VERSION, chainIdToX402Network, X402_HEADER_PAYMENT_SIGNATURE, encodePaymentSignatureHeader, X402_HEADER_PAYMENT_RESPONSE, decodePaymentResponseHeader, x402NetworkToChainId, JPYC_V2_ADDRESS, JPYC_EIP712_DOMAIN_HINT, X402_HEADER_PAYMENT_REQUIRED, decodePaymentRequiredHeader, jpycAbi } from './chunk-6M7UN23J.js';
+import { getChain, isSupportedChainId } from './chunk-SA7LMQFG.js';
+import { invokeHookSafely } from './chunk-LEHWRDVS.js';
+import { parseSignature, getAddress, recoverTypedDataAddress, isAddress } from 'viem';
+
+var transferWithAuthorizationTypes = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+var receiveWithAuthorizationTypes = {
+  ReceiveWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+var cancelAuthorizationTypes = {
+  CancelAuthorization: [
+    { name: "authorizer", type: "address" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+function generateAuthorizationNonce() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  return `0x${Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+function authorizationDeadlineFromNow(seconds, nowSec) {
+  const now = nowSec ?? BigInt(Math.floor(Date.now() / 1e3));
+  return now + BigInt(seconds);
+}
+function requireSignTypedData(account) {
+  if (!account.signTypedData) {
+    throw new Error(
+      `Account ${account.address} cannot sign typed data \u2014 pass a LocalAccount or a JsonRpcAccount bound to a WalletClient.`
+    );
+  }
+  return account.signTypedData.bind(account);
+}
+function assertSignerMatches(account, expectedFrom, role) {
+  if (getAddress(account.address) !== getAddress(expectedFrom)) {
+    throw new Error(
+      `EIP-3009 ${role} signature must come from \`${role === "cancel" ? "authorizer" : "from"}\`: account is ${account.address}, message says ${expectedFrom}.`
+    );
+  }
+}
+async function signTransferWithAuthorization(account, domain, message) {
+  assertSignerMatches(account, message.from, "transfer");
+  const sign = requireSignTypedData(account);
+  const signature = await sign({
+    domain,
+    types: transferWithAuthorizationTypes,
+    primaryType: "TransferWithAuthorization",
+    message
+  });
+  return splitAuthorization(signature, domain, message);
+}
+async function signReceiveWithAuthorization(account, domain, message) {
+  assertSignerMatches(account, message.from, "receive");
+  const sign = requireSignTypedData(account);
+  const signature = await sign({
+    domain,
+    types: receiveWithAuthorizationTypes,
+    primaryType: "ReceiveWithAuthorization",
+    message
+  });
+  return splitAuthorization(signature, domain, message);
+}
+async function signCancelAuthorization(account, domain, message) {
+  assertSignerMatches(account, message.authorizer, "cancel");
+  const sign = requireSignTypedData(account);
+  const signature = await sign({
+    domain,
+    types: cancelAuthorizationTypes,
+    primaryType: "CancelAuthorization",
+    message
+  });
+  return splitAuthorization(signature, domain, message);
+}
+function splitAuthorization(signature, domain, message) {
+  const parsed = parseSignature(signature);
+  const v = parsed.v !== void 0 ? Number(parsed.v) : (parsed.yParity ?? 0) + 27;
+  return {
+    signature,
+    v,
+    r: parsed.r,
+    s: parsed.s,
+    domain,
+    message
+  };
+}
+var X402_DEFAULT_AUTHORIZATION_LIFETIME_SECONDS = 300;
+var UINT256_MAX = (1n << 256n) - 1n;
+var UINT256_DECIMAL = /^(0|[1-9][0-9]*)$/;
+function parseUintString(value, field) {
+  if (!UINT256_DECIMAL.test(value)) {
+    throw new X402InvalidPayloadError(
+      "PaymentRequirements",
+      `\`${field}\` must be a non-negative decimal string, got ${JSON.stringify(value)}`
+    );
+  }
+  const parsed = BigInt(value);
+  if (parsed > UINT256_MAX) {
+    throw new X402InvalidPayloadError(
+      "PaymentRequirements",
+      `\`${field}\` exceeds uint256, got ${value}`
+    );
+  }
+  return parsed;
+}
+function assertAddress(value, field) {
+  if (!isAddress(value, { strict: false })) {
+    throw new X402InvalidPayloadError(
+      "PaymentRequirements",
+      `\`${field}\` is not a valid address: ${value}`
+    );
+  }
+  return value;
+}
+function resolveDomain(requirements, override) {
+  if (override) {
+    return override;
+  }
+  const extra = requirements.extra;
+  if (typeof extra.name === "string" && typeof extra.version === "string") {
+    return { name: extra.name, version: extra.version };
+  }
+  if (getAddress(requirements.asset) === getAddress(JPYC_V2_ADDRESS)) {
+    return JPYC_EIP712_DOMAIN_HINT;
+  }
+  throw new X402InvalidPayloadError(
+    "PaymentRequirements",
+    "`extra.name` and `extra.version` are required for exact-EVM signing on a non-JPYC asset"
+  );
+}
+function validateRequirements(requirements) {
+  if (requirements.scheme !== "exact") {
+    throw new X402InvalidPayloadError(
+      "PaymentRequirements",
+      `unsupported scheme: ${requirements.scheme}`
+    );
+  }
+  const chainId = x402NetworkToChainId(requirements.network);
+  if (!isSupportedChainId(chainId)) {
+    throw new X402InvalidPayloadError(
+      "PaymentRequirements",
+      `unsupported network: ${requirements.network}`
+    );
+  }
+  const value = parseUintString(requirements.amount, "amount");
+  if (value === 0n) {
+    throw new X402InvalidPayloadError("PaymentRequirements", "`amount` must be positive");
+  }
+  if (requirements.maxTimeoutSeconds <= 0) {
+    throw new X402InvalidPayloadError(
+      "PaymentRequirements",
+      `\`maxTimeoutSeconds\` must be positive, got ${requirements.maxTimeoutSeconds}`
+    );
+  }
+  const asset = assertAddress(requirements.asset, "asset");
+  const payTo = assertAddress(requirements.payTo, "payTo");
+  return { chainId, value, asset, payTo };
+}
+function createX402PaymentSigner(params) {
+  const { account, network } = params;
+  const defaultLifetimeSeconds = params.defaultLifetimeSeconds ?? X402_DEFAULT_AUTHORIZATION_LIFETIME_SECONDS;
+  if (defaultLifetimeSeconds <= 0) {
+    throw new X402InvalidPayloadError(
+      "X402PaymentSignerConfig",
+      `\`defaultLifetimeSeconds\` must be positive, got ${defaultLifetimeSeconds}`
+    );
+  }
+  const domainOverride = params.domainOverride;
+  return {
+    address: account.address,
+    async sign(signParams) {
+      const { paymentRequirements } = signParams;
+      const { chainId, value, asset, payTo } = validateRequirements(paymentRequirements);
+      const chain = getChain(chainId);
+      if (network === "mainnet" && chain.isTestnet) {
+        throw new X402InvalidPayloadError(
+          "PaymentRequirements",
+          `signer was configured for network="mainnet" but requirements.network="${paymentRequirements.network}" (chainId ${chainId}) is a testnet`
+        );
+      }
+      if (network === "testnet" && !chain.isTestnet) {
+        throw new X402InvalidPayloadError(
+          "PaymentRequirements",
+          `signer was configured for network="testnet" but requirements.network="${paymentRequirements.network}" (chainId ${chainId}) is a mainnet \u2014 refusing to sign payment for real funds`
+        );
+      }
+      const domain = resolveDomain(paymentRequirements, domainOverride);
+      const lifetime = Math.min(defaultLifetimeSeconds, paymentRequirements.maxTimeoutSeconds);
+      const validAfter = signParams.validAfter ?? 0n;
+      const validBefore = signParams.validBefore ?? authorizationDeadlineFromNow(lifetime);
+      if (validBefore <= validAfter) {
+        throw new X402InvalidPayloadError(
+          "PaymentRequirements",
+          `\`validBefore\` (${validBefore}) must be greater than \`validAfter\` (${validAfter})`
+        );
+      }
+      const nonce = generateAuthorizationNonce();
+      const signed = await signTransferWithAuthorization(
+        account,
+        { name: domain.name, version: domain.version, chainId, verifyingContract: asset },
+        {
+          from: account.address,
+          to: payTo,
+          value,
+          validAfter,
+          validBefore,
+          nonce
+        }
+      );
+      const payload = {
+        signature: signed.signature,
+        authorization: {
+          from: signed.message.from,
+          to: signed.message.to,
+          value: signed.message.value.toString(),
+          validAfter: signed.message.validAfter.toString(),
+          validBefore: signed.message.validBefore.toString(),
+          nonce: signed.message.nonce
+        }
+      };
+      const result = signParams.resource ? {
+        x402Version: X402_VERSION,
+        resource: signParams.resource,
+        accepted: paymentRequirements,
+        payload: { ...payload }
+      } : {
+        x402Version: X402_VERSION,
+        accepted: paymentRequirements,
+        payload: { ...payload }
+      };
+      return result;
+    }
+  };
+}
+var X402_FACILITATOR_ERROR_CODES = {
+  insufficient_funds: "insufficient_funds",
+  invalid_exact_evm_payload_authorization_valid_after: "invalid_exact_evm_payload_authorization_valid_after",
+  invalid_exact_evm_payload_authorization_valid_before: "invalid_exact_evm_payload_authorization_valid_before",
+  invalid_exact_evm_payload_authorization_value_mismatch: "invalid_exact_evm_payload_authorization_value_mismatch",
+  invalid_exact_evm_payload_recipient_mismatch: "invalid_exact_evm_payload_recipient_mismatch",
+  invalid_exact_evm_payload_signature: "invalid_exact_evm_payload_signature",
+  invalid_network: "invalid_network",
+  invalid_payload: "invalid_payload",
+  invalid_scheme: "invalid_scheme",
+  invalid_transaction_state: "invalid_transaction_state",
+  unexpected_settle_error: "unexpected_settle_error",
+  unexpected_verify_error: "unexpected_verify_error"
+};
+function isHex(value) {
+  return typeof value === "string" && /^0x[0-9a-fA-F]*$/.test(value);
+}
+function isAddressLike(value) {
+  return typeof value === "string" && /^0x[0-9a-fA-F]{40}$/.test(value);
+}
+function isDecimalString(value) {
+  return typeof value === "string" && /^(0|[1-9][0-9]*)$/.test(value);
+}
+function narrowExactEvmPayload(payload) {
+  const p = payload;
+  if (!isHex(p.signature)) return null;
+  if (typeof p.authorization !== "object" || p.authorization === null) return null;
+  const a = p.authorization;
+  if (!isAddressLike(a.from)) return null;
+  if (!isAddressLike(a.to)) return null;
+  if (!isDecimalString(a.value)) return null;
+  if (!isDecimalString(a.validAfter)) return null;
+  if (!isDecimalString(a.validBefore)) return null;
+  if (!isHex(a.nonce)) return null;
+  return {
+    signature: p.signature,
+    authorization: {
+      from: a.from,
+      to: a.to,
+      value: a.value,
+      validAfter: a.validAfter,
+      validBefore: a.validBefore,
+      nonce: a.nonce
+    }
+  };
+}
+var TRANSFER_AUTHORIZATION_TYPES = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+function resolveDomain2(requirements) {
+  const extra = requirements.extra;
+  if (typeof extra.name === "string" && typeof extra.version === "string") {
+    return { name: extra.name, version: extra.version };
+  }
+  if (getAddress(requirements.asset) === getAddress(JPYC_V2_ADDRESS)) {
+    return JPYC_EIP712_DOMAIN_HINT;
+  }
+  throw new Error(
+    "resolveDomain: `extra.name` and `extra.version` are required for non-JPYC assets"
+  );
+}
+function failVerify(reason, message, payer) {
+  if (message !== void 0 && payer !== void 0) {
+    return { isValid: false, invalidReason: reason, invalidMessage: message, payer };
+  }
+  if (message !== void 0) {
+    return { isValid: false, invalidReason: reason, invalidMessage: message };
+  }
+  if (payer !== void 0) {
+    return { isValid: false, invalidReason: reason, payer };
+  }
+  return { isValid: false, invalidReason: reason };
+}
+function failSettle(network, reason, options = {}) {
+  const transaction = options.transaction ?? "";
+  const base = {
+    success: false,
+    errorReason: reason,
+    transaction,
+    network
+  };
+  if (options.message !== void 0 && options.payer !== void 0) {
+    return { ...base, errorMessage: options.message, payer: options.payer };
+  }
+  if (options.message !== void 0) {
+    return { ...base, errorMessage: options.message };
+  }
+  if (options.payer !== void 0) {
+    return { ...base, payer: options.payer };
+  }
+  return base;
+}
+function createSelfFacilitator(params) {
+  const { walletClient, publicClient } = params;
+  const receiptTimeoutMs = params.receiptTimeoutMs ?? 6e4;
+  const facilitatorChainId = walletClient.chain.id;
+  if (!isSupportedChainId(facilitatorChainId)) {
+    throw new Error(
+      `createSelfFacilitator: walletClient.chain.id ${facilitatorChainId} is not a kawasekit-supported chain`
+    );
+  }
+  const supportedChainId = facilitatorChainId;
+  const chain = getChain(supportedChainId);
+  if (params.network === "mainnet" && chain.isTestnet) {
+    throw new Error(
+      `createSelfFacilitator: network="mainnet" but walletClient.chain "${chain.name}" (chainId ${supportedChainId}) is a testnet`
+    );
+  }
+  if (params.network === "testnet" && !chain.isTestnet) {
+    throw new Error(
+      `createSelfFacilitator: network="testnet" but walletClient.chain "${chain.name}" (chainId ${supportedChainId}) is a mainnet \u2014 refusing to broadcast with real funds`
+    );
+  }
+  const network = chainIdToX402Network(supportedChainId);
+  const hooks = params.hooks;
+  function buildVerifyEvent(req, response, startedAtMs) {
+    const durationMs = Date.now() - startedAtMs;
+    const eventNetwork = req.paymentRequirements.network;
+    if (response.isValid && response.payer !== void 0) {
+      return {
+        kind: "verify",
+        result: "success",
+        startedAtMs,
+        durationMs,
+        network: eventNetwork,
+        payer: response.payer,
+        amount: req.paymentRequirements.amount
+      };
+    }
+    if (response.isValid) {
+      return {
+        kind: "verify",
+        result: "failure",
+        startedAtMs,
+        durationMs,
+        network: eventNetwork,
+        invalidReason: "unexpected_verify_error",
+        invalidMessage: "verify succeeded but payer was not surfaced"
+      };
+    }
+    const base = {
+      kind: "verify",
+      result: "failure",
+      startedAtMs,
+      durationMs,
+      network: eventNetwork,
+      invalidReason: response.invalidReason ?? "unexpected_verify_error"
+    };
+    if (response.payer !== void 0 && response.invalidMessage !== void 0) {
+      return { ...base, payer: response.payer, invalidMessage: response.invalidMessage };
+    }
+    if (response.payer !== void 0) {
+      return { ...base, payer: response.payer };
+    }
+    if (response.invalidMessage !== void 0) {
+      return { ...base, invalidMessage: response.invalidMessage };
+    }
+    return base;
+  }
+  function buildSettleEvent(req, response, startedAtMs) {
+    const durationMs = Date.now() - startedAtMs;
+    const eventNetwork = req.paymentRequirements.network;
+    if (response.success && response.payer !== void 0) {
+      return {
+        kind: "settle",
+        result: "success",
+        startedAtMs,
+        durationMs,
+        network: eventNetwork,
+        payer: response.payer,
+        amount: req.paymentRequirements.amount,
+        transaction: response.transaction
+      };
+    }
+    if (response.success) {
+      return {
+        kind: "settle",
+        result: "failure",
+        startedAtMs,
+        durationMs,
+        network: eventNetwork,
+        errorReason: "unexpected_settle_error",
+        errorMessage: "settle succeeded but payer was not surfaced",
+        transaction: response.transaction
+      };
+    }
+    const base = {
+      kind: "settle",
+      result: "failure",
+      startedAtMs,
+      durationMs,
+      network: eventNetwork,
+      errorReason: response.errorReason ?? "unexpected_settle_error"
+    };
+    const withPayer = response.payer !== void 0 ? { ...base, payer: response.payer } : base;
+    const withMessage = response.errorMessage !== void 0 ? { ...withPayer, errorMessage: response.errorMessage } : withPayer;
+    if (response.transaction !== "" && response.transaction !== void 0) {
+      return { ...withMessage, transaction: response.transaction };
+    }
+    return withMessage;
+  }
+  async function verifyCore(req) {
+    if (req.paymentRequirements.scheme !== "exact") {
+      return failVerify("invalid_scheme");
+    }
+    if (req.paymentPayload.accepted.scheme !== "exact") {
+      return failVerify("invalid_scheme");
+    }
+    const reqChainId = x402NetworkToChainId(req.paymentRequirements.network);
+    if (reqChainId !== supportedChainId) {
+      return failVerify("invalid_network");
+    }
+    if (req.paymentPayload.accepted.network !== req.paymentRequirements.network) {
+      return failVerify("invalid_network");
+    }
+    const exact = narrowExactEvmPayload(req.paymentPayload.payload);
+    if (exact === null) {
+      return failVerify("invalid_payload");
+    }
+    const auth = exact.authorization;
+    if (auth.value !== req.paymentRequirements.amount) {
+      return failVerify(
+        "invalid_exact_evm_payload_authorization_value_mismatch",
+        void 0,
+        auth.from
+      );
+    }
+    if (getAddress(auth.to) !== getAddress(req.paymentRequirements.payTo)) {
+      return failVerify("invalid_exact_evm_payload_recipient_mismatch", void 0, auth.from);
+    }
+    const now = BigInt(Math.floor(Date.now() / 1e3));
+    const validAfter = BigInt(auth.validAfter);
+    const validBefore = BigInt(auth.validBefore);
+    if (now < validAfter) {
+      return failVerify(
+        "invalid_exact_evm_payload_authorization_valid_after",
+        void 0,
+        auth.from
+      );
+    }
+    if (now >= validBefore) {
+      return failVerify(
+        "invalid_exact_evm_payload_authorization_valid_before",
+        void 0,
+        auth.from
+      );
+    }
+    let recovered;
+    try {
+      const domain = resolveDomain2(req.paymentRequirements);
+      recovered = await recoverTypedDataAddress({
+        domain: {
+          name: domain.name,
+          version: domain.version,
+          chainId: reqChainId,
+          verifyingContract: req.paymentRequirements.asset
+        },
+        types: TRANSFER_AUTHORIZATION_TYPES,
+        primaryType: "TransferWithAuthorization",
+        message: {
+          from: auth.from,
+          to: auth.to,
+          value: BigInt(auth.value),
+          validAfter,
+          validBefore,
+          nonce: auth.nonce
+        },
+        signature: exact.signature
+      });
+    } catch (cause) {
+      return failVerify(
+        "unexpected_verify_error",
+        cause instanceof Error ? cause.message : String(cause),
+        auth.from
+      );
+    }
+    if (getAddress(recovered) !== getAddress(auth.from)) {
+      return failVerify("invalid_exact_evm_payload_signature", void 0, auth.from);
+    }
+    try {
+      const [balance, used] = await Promise.all([
+        publicClient.readContract({
+          address: req.paymentRequirements.asset,
+          abi: jpycAbi,
+          functionName: "balanceOf",
+          args: [auth.from]
+        }),
+        publicClient.readContract({
+          address: req.paymentRequirements.asset,
+          abi: jpycAbi,
+          functionName: "authorizationState",
+          args: [auth.from, auth.nonce]
+        })
+      ]);
+      if (used) {
+        return failVerify("invalid_payload", "authorization nonce already used", auth.from);
+      }
+      if (balance < BigInt(auth.value)) {
+        return failVerify("insufficient_funds", void 0, auth.from);
+      }
+    } catch (cause) {
+      return failVerify(
+        "unexpected_verify_error",
+        cause instanceof Error ? cause.message : String(cause),
+        auth.from
+      );
+    }
+    return { isValid: true, payer: auth.from };
+  }
+  async function settleCore(req) {
+    const verifyResult = await verify(req);
+    if (!verifyResult.isValid) {
+      return failSettle(
+        req.paymentRequirements.network,
+        verifyResult.invalidReason ?? "unexpected_settle_error",
+        {
+          ...verifyResult.invalidMessage !== void 0 ? { message: verifyResult.invalidMessage } : {},
+          ...verifyResult.payer !== void 0 ? { payer: verifyResult.payer } : {}
+        }
+      );
+    }
+    const exact = narrowExactEvmPayload(req.paymentPayload.payload);
+    if (exact === null) {
+      return failSettle(req.paymentRequirements.network, "invalid_payload");
+    }
+    const auth = exact.authorization;
+    const parsed = parseSignature(exact.signature);
+    const v = parsed.v !== void 0 ? Number(parsed.v) : (parsed.yParity ?? 0) + 27;
+    let txHash;
+    try {
+      txHash = await walletClient.writeContract({
+        address: req.paymentRequirements.asset,
+        abi: jpycAbi,
+        functionName: "transferWithAuthorization",
+        args: [
+          auth.from,
+          auth.to,
+          BigInt(auth.value),
+          BigInt(auth.validAfter),
+          BigInt(auth.validBefore),
+          auth.nonce,
+          v,
+          parsed.r,
+          parsed.s
+        ]
+      });
+    } catch (cause) {
+      return failSettle(req.paymentRequirements.network, "unexpected_settle_error", {
+        message: cause instanceof Error ? cause.message : String(cause),
+        payer: auth.from
+      });
+    }
+    try {
+      const receipt = await publicClient.waitForTransactionReceipt({
+        hash: txHash,
+        timeout: receiptTimeoutMs
+      });
+      if (receipt.status !== "success") {
+        return failSettle(req.paymentRequirements.network, "invalid_transaction_state", {
+          transaction: txHash,
+          payer: auth.from
+        });
+      }
+    } catch (cause) {
+      return failSettle(req.paymentRequirements.network, "unexpected_settle_error", {
+        message: cause instanceof Error ? cause.message : String(cause),
+        payer: auth.from,
+        transaction: txHash
+      });
+    }
+    return {
+      success: true,
+      transaction: txHash,
+      network: req.paymentRequirements.network,
+      payer: auth.from,
+      amount: auth.value
+    };
+  }
+  async function verify(req) {
+    const startedAtMs = Date.now();
+    const result = await verifyCore(req);
+    invokeHookSafely(hooks?.onVerify, buildVerifyEvent(req, result, startedAtMs));
+    return result;
+  }
+  async function settle(req) {
+    const startedAtMs = Date.now();
+    const result = await settleCore(req);
+    invokeHookSafely(hooks?.onSettle, buildSettleEvent(req, result, startedAtMs));
+    return result;
+  }
+  async function supportedInternal() {
+    const kind = {
+      x402Version: X402_VERSION,
+      scheme: "exact",
+      network
+    };
+    return {
+      kinds: [kind],
+      extensions: [],
+      signers: { "eip155:*": [walletClient.account.address] }
+    };
+  }
+  return {
+    verify,
+    settle,
+    supported: supportedInternal
+  };
+}
+function createHttpFacilitator(params) {
+  const baseUrl = params.baseUrl.replace(/\/$/, "");
+  const fetchImpl = params.fetch ?? fetch;
+  const getAuthHeaders = params.getAuthHeaders;
+  async function post(endpoint, body) {
+    const headers = { "content-type": "application/json" };
+    if (getAuthHeaders) {
+      Object.assign(headers, await getAuthHeaders(endpoint));
+    }
+    const response = await fetchImpl(`${baseUrl}/${endpoint}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    const text = await response.text();
+    let parsed;
+    try {
+      parsed = text === "" ? null : JSON.parse(text);
+    } catch {
+      throw new Error(
+        `Facilitator ${endpoint} returned non-JSON (status ${response.status}): ${text.slice(0, 200)}`
+      );
+    }
+    if (!response.ok) {
+      throw new Error(
+        `Facilitator ${endpoint} failed (status ${response.status}): ${JSON.stringify(parsed).slice(0, 200)}`
+      );
+    }
+    return parsed;
+  }
+  async function verifyInternal(req) {
+    return post("verify", {
+      x402Version: req.x402Version,
+      paymentPayload: req.paymentPayload,
+      paymentRequirements: req.paymentRequirements
+    });
+  }
+  async function settleInternal(req) {
+    return post("settle", {
+      x402Version: req.x402Version,
+      paymentPayload: req.paymentPayload,
+      paymentRequirements: req.paymentRequirements
+    });
+  }
+  async function supportedInternal() {
+    const headers = {};
+    if (getAuthHeaders) {
+      Object.assign(headers, await getAuthHeaders("supported"));
+    }
+    const response = await fetchImpl(`${baseUrl}/supported`, { method: "GET", headers });
+    const text = await response.text();
+    let parsed;
+    try {
+      parsed = text === "" ? null : JSON.parse(text);
+    } catch {
+      throw new Error(
+        `Facilitator supported returned non-JSON (status ${response.status}): ${text.slice(0, 200)}`
+      );
+    }
+    if (!response.ok) {
+      throw new Error(
+        `Facilitator supported failed (status ${response.status}): ${JSON.stringify(parsed).slice(0, 200)}`
+      );
+    }
+    return parsed;
+  }
+  return {
+    verify: verifyInternal,
+    settle: settleInternal,
+    supported: supportedInternal
+  };
+}
+var warnedCreateCoinbaseFacilitator = false;
+function createCoinbaseFacilitator(params) {
+  if (!warnedCreateCoinbaseFacilitator) {
+    warnedCreateCoinbaseFacilitator = true;
+    process.emitWarning(
+      "createCoinbaseFacilitator() is deprecated and will be removed in kawasekit v0.2.0. Use createHttpFacilitator() instead \u2014 the function works with any x402 v2-compliant HTTP endpoint, not only Coinbase CDP.",
+      { type: "DeprecationWarning", code: "KAWASEKIT_DEP_001" }
+    );
+  }
+  return createHttpFacilitator(params);
+}
+
+// src/x402/fetch.ts
+async function readPaymentRequired(response) {
+  const headerValue = response.headers.get(X402_HEADER_PAYMENT_REQUIRED);
+  if (headerValue !== null && headerValue !== "") {
+    try {
+      return decodePaymentRequiredHeader(headerValue);
+    } catch {
+    }
+  }
+  try {
+    const body = await response.clone().text();
+    if (body === "") return null;
+    const parsed = JSON.parse(body);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function defaultSelectRequirements(accepts) {
+  return accepts[0] ?? null;
+}
+function wrapFetch(params) {
+  const baseFetch = params.fetch ?? ((input, init) => fetch(input, init));
+  const selectRequirements = params.selectRequirements ?? defaultSelectRequirements;
+  const onPayment = params.onPayment;
+  const hooks = params.hooks;
+  return async function x402Fetch(input, init) {
+    const startedAtMs = Date.now();
+    const requestUrl = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const emitFailure = (reason, httpStatus) => {
+      const event = {
+        kind: "client_payment",
+        result: "failure",
+        startedAtMs,
+        durationMs: Date.now() - startedAtMs,
+        requestUrl,
+        reason,
+        ...httpStatus !== void 0 ? { httpStatus } : {}
+      };
+      invokeHookSafely(hooks?.onClientPayment, event);
+    };
+    const initialResponse = await baseFetch(input, init);
+    if (initialResponse.status !== 402) {
+      return initialResponse;
+    }
+    const paymentRequired = await readPaymentRequired(initialResponse);
+    if (paymentRequired === null || paymentRequired.accepts.length === 0) {
+      emitFailure("no_acceptable_requirement", 402);
+      return initialResponse;
+    }
+    const chosen = selectRequirements(paymentRequired.accepts, initialResponse);
+    if (chosen === null) {
+      emitFailure("no_acceptable_requirement", 402);
+      return initialResponse;
+    }
+    if (onPayment) {
+      const proceed = await onPayment(chosen, paymentRequired);
+      if (proceed === false) {
+        emitFailure("onPayment_declined", 402);
+        return initialResponse;
+      }
+    }
+    const paymentPayload = await params.signer.sign({
+      paymentRequirements: chosen,
+      ...paymentRequired.resource ? { resource: paymentRequired.resource } : {}
+    });
+    const retryHeaders = new Headers(init?.headers);
+    retryHeaders.set(X402_HEADER_PAYMENT_SIGNATURE, encodePaymentSignatureHeader(paymentPayload));
+    const retryResponse = await baseFetch(input, { ...init, headers: retryHeaders });
+    if (retryResponse.status >= 200 && retryResponse.status < 300) {
+      const settlementHeader = retryResponse.headers.get(X402_HEADER_PAYMENT_RESPONSE);
+      let transaction;
+      if (settlementHeader !== null && settlementHeader !== "") {
+        try {
+          const settlement = decodePaymentResponseHeader(settlementHeader);
+          if (settlement.transaction !== "") {
+            transaction = settlement.transaction;
+          }
+        } catch {
+        }
+      }
+      const successEvent = {
+        kind: "client_payment",
+        result: "success",
+        startedAtMs,
+        durationMs: Date.now() - startedAtMs,
+        requestUrl,
+        payer: params.signer.address,
+        amount: chosen.amount,
+        network: chosen.network,
+        ...transaction !== void 0 ? { transaction } : {}
+      };
+      invokeHookSafely(hooks?.onClientPayment, successEvent);
+    } else {
+      emitFailure(
+        retryResponse.status === 402 ? "settle_rejected" : "http_error",
+        retryResponse.status
+      );
+    }
+    return retryResponse;
+  };
+}
+
+export { X402_DEFAULT_AUTHORIZATION_LIFETIME_SECONDS, X402_FACILITATOR_ERROR_CODES, authorizationDeadlineFromNow, createCoinbaseFacilitator, createHttpFacilitator, createSelfFacilitator, createX402PaymentSigner, generateAuthorizationNonce, signCancelAuthorization, signReceiveWithAuthorization, signTransferWithAuthorization, wrapFetch };
+//# sourceMappingURL=chunk-3S34WBAW.js.map
+//# sourceMappingURL=chunk-3S34WBAW.js.map