@happyvertical/payments 0.74.8

package/dist/adapters/base-usdc.js

@@ -0,0 +1,1182 @@
+import { createHash } from "node:crypto";
+import { P as PaymentConfigurationError, b as PaymentProviderError, d as PaymentVerificationError } from "../chunks/errors-BgFC46qQ.js";
+import { n as normalizeNonEmptyString, g as getFetch, a as normalizeMaxStoredPaymentOptions, b as normalizeUrlString, c as normalizeFutureDate, d as normalizeCurrency, e as normalizePositiveMinorUnitAmount, f as decimalToMinorUnitAmount, r as rememberPaymentOption, p as pollPaymentStatus, h as normalizeDate, i as normalizeMinorUnitAmount, j as readJsonResponse, m as minorUnitsToDecimal, k as currencyMinorUnitDecimals, l as decimalToAtomicUnits } from "../chunks/shared-DGHSqDQT.js";
+const BASE_USDC_BACKEND_ID = "base-usdc";
+const BASE_MAINNET_CHAIN_ID = 8453;
+const BASE_MAINNET_CAIP2 = "eip155:8453";
+const BASE_USDC_CONTRACT = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+const USDC_DECIMALS = 6;
+const TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+const DEFAULT_LOG_LOOKBACK_BLOCKS = 10000n;
+const DEFAULT_MAX_SEEN_X402_TRANSACTION_IDS = 5e4;
+class BaseUsdcAdapter {
+  constructor(options) {
+    this.options = options;
+    if (typeof options.rpcUrl !== "string" || !options.rpcUrl.trim()) {
+      throw new PaymentConfigurationError(
+        "BaseUsdcAdapter requires an RPC URL."
+      );
+    }
+    this.masterXpub = options.masterXpub === void 0 ? void 0 : normalizeNonEmptyString(options.masterXpub, "Base USDC masterXpub");
+    this.derivationPathPrefix = normalizeDerivationPathPrefix(
+      options.derivationPathPrefix ?? "m/0"
+    );
+    if (!this.masterXpub && !options.addressDeriver) {
+      throw new PaymentConfigurationError(
+        "BaseUsdcAdapter requires masterXpub or addressDeriver."
+      );
+    }
+    this.fetch = getFetch(options.fetch);
+    this.maxStoredPaymentOptions = normalizeMaxStoredPaymentOptions(
+      options.maxStoredPaymentOptions,
+      "BaseUsdcAdapter maxStoredPaymentOptions"
+    );
+    this.allowCumulativeTransferMatching = options.allowCumulativeTransferMatching === true;
+    this.rpcUrl = normalizeUrlString(options.rpcUrl, "BaseUsdcAdapter rpcUrl");
+    this.usdcContractAddress = normalizeAddress(
+      options.usdcContractAddress ?? BASE_USDC_CONTRACT
+    );
+    this.confirmations = normalizeConfirmationCount(
+      options.confirmations ?? 1,
+      "BaseUsdcAdapter confirmations"
+    );
+    this.configuredFromBlock = options.fromBlock === void 0 ? void 0 : normalizeFromBlock(options.fromBlock);
+    this.x402FacilitatorUrl = options.x402FacilitatorUrl === void 0 ? void 0 : normalizeUrlString(
+      options.x402FacilitatorUrl,
+      "BaseUsdcAdapter x402FacilitatorUrl"
+    ).replace(/\/$/, "");
+    this.capabilities = {
+      id: BASE_USDC_BACKEND_ID,
+      displayName: "Base USDC",
+      settlementCurrency: "USDC",
+      supportedSettlementCurrencies: ["USDC"],
+      chain: "base",
+      settlementShape: "address",
+      x402Capable: true,
+      confirmationLatency: {
+        expectedSeconds: 2,
+        minConfirmations: this.confirmations,
+        description: "Base L2 USDC transfer confirmation"
+      },
+      supportsRefunds: true,
+      supportsPayouts: true,
+      supportsWebhooks: false,
+      metadata: {
+        chainId: BASE_MAINNET_CHAIN_ID,
+        caip2Network: BASE_MAINNET_CAIP2,
+        usdcContractAddress: this.usdcContractAddress
+      }
+    };
+  }
+  capabilities;
+  fetch;
+  rpcUrl;
+  usdcContractAddress;
+  confirmations;
+  configuredFromBlock;
+  masterXpub;
+  derivationPathPrefix;
+  x402FacilitatorUrl;
+  maxStoredPaymentOptions;
+  allowCumulativeTransferMatching;
+  optionsByQuote = /* @__PURE__ */ new Map();
+  seenX402TransactionIds = /* @__PURE__ */ new Set();
+  rpcId = 0;
+  async createPaymentOption(input) {
+    const quoteId = normalizeNonEmptyString(input.quoteId, "Base USDC quoteId");
+    const expiresAt = normalizeFutureDate(input.expiresAt, "Base USDC expiry");
+    const currency = normalizeCurrency(input.currency, "Base USDC");
+    const amount = normalizePositiveMinorUnitAmount(
+      input.amount,
+      "Base USDC amount"
+    );
+    const expectedAmountAtomic = amountToUsdcAtomicUnits(
+      amount,
+      currency,
+      "Base USDC amount"
+    );
+    const settlementAmount = decimalToMinorUnitAmount(
+      BigInt(expectedAmountAtomic),
+      USDC_DECIMALS,
+      "Base USDC settlement"
+    );
+    const configuredIndex = this.options.addressIndexForQuote?.(quoteId);
+    const indexes = configuredIndex === void 0 ? quoteIdToDerivationIndexes(quoteId) : [normalizeDerivationIndex(configuredIndex)];
+    const index = indexes[0] ?? 0;
+    const path = `${this.derivationPathPrefix}/${indexes.join("/")}`;
+    const payTo = normalizeAddress(
+      await this.deriveAddress({
+        quoteId,
+        index,
+        indexes,
+        path
+      })
+    );
+    const searchStartBlock = await this.getCurrentBlockNumber();
+    const option = {
+      backendId: this.capabilities.id,
+      quoteId,
+      payTo,
+      settlementShape: "address",
+      settlementCurrency: "USDC",
+      settlementAmount,
+      amount,
+      currency,
+      expiresAt,
+      paymentUri: buildUsdcPaymentUri({
+        tokenAddress: this.usdcContractAddress,
+        payTo,
+        amountAtomic: expectedAmountAtomic
+      }),
+      metadata: {
+        derivationIndex: index,
+        derivationIndexes: indexes,
+        derivationPath: path,
+        caip2Network: BASE_MAINNET_CAIP2,
+        tokenAddress: this.usdcContractAddress,
+        searchStartBlock: toHexQuantity(searchStartBlock)
+      }
+    };
+    rememberPaymentOption(
+      this.optionsByQuote,
+      quoteId,
+      { ...option, expectedAmountAtomic, searchStartBlock },
+      this.maxStoredPaymentOptions
+    );
+    return option;
+  }
+  watchPayment(input) {
+    return pollPaymentStatus(
+      {
+        ...input,
+        pollIntervalMs: input.pollIntervalMs ?? this.options.pollIntervalMs ?? 2e3
+      },
+      () => this.getStatus(input.quoteId, input.payTo, input.statusContext)
+    );
+  }
+  async getStatus(quoteId, payTo, context = {}) {
+    const normalizedQuoteId = normalizeNonEmptyString(
+      quoteId,
+      "Base USDC quoteId"
+    );
+    const normalizedPayTo = normalizeAddress(payTo);
+    const option = this.optionsByQuote.get(normalizedQuoteId);
+    const expectedAmountAtomic = resolveExpectedUsdcAmount(option, context);
+    const contextSearchStartBlock = context.searchStartBlock === void 0 ? void 0 : parseHexQuantity(normalizeFromBlock(context.searchStartBlock));
+    const searchStartBlock = option?.searchStartBlock ?? contextSearchStartBlock;
+    if (!option && expectedAmountAtomic !== void 0 && searchStartBlock === void 0 && this.configuredFromBlock === void 0) {
+      throw new PaymentConfigurationError(
+        "Base USDC getStatus requires statusContext.searchStartBlock when checking stateless payment status without a configured fromBlock."
+      );
+    }
+    const logs = await this.getTransferLogs(normalizedPayTo, searchStartBlock);
+    const matchMinBlock = searchStartBlock ?? configuredFromBlockMinBlock(this.configuredFromBlock);
+    const matchingTransfer = expectedAmountAtomic === void 0 ? void 0 : this.allowCumulativeTransferMatching ? pickCumulativeTransferMatch(
+      logs,
+      expectedAmountAtomic,
+      void 0,
+      matchMinBlock
+    ) : pickSingleTransferMatch(
+      logs,
+      expectedAmountAtomic,
+      void 0,
+      matchMinBlock
+    );
+    if (!matchingTransfer) {
+      const expiresAt = option?.expiresAt ?? (context.expiresAt === void 0 ? void 0 : normalizeDate(context.expiresAt));
+      return {
+        backendId: this.capabilities.id,
+        quoteId: normalizedQuoteId,
+        payTo: normalizedPayTo,
+        status: expiresAt && expiresAt < /* @__PURE__ */ new Date() ? "expired" : "pending",
+        settlementCurrency: "USDC",
+        settlementAmount: option?.settlementAmount ?? (context.settlementAmount === void 0 ? void 0 : normalizeMinorUnitAmount(
+          context.settlementAmount,
+          "Base USDC settlement status"
+        )),
+        amount: option?.amount ?? (context.amount === void 0 ? void 0 : normalizeMinorUnitAmount(context.amount, "Base USDC status")),
+        currency: option?.currency ?? (context.currency === void 0 ? void 0 : normalizeCurrency(context.currency, "Base USDC status")),
+        requiredConfirmations: this.confirmations,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+    }
+    const currentBlock = await this.getCurrentBlockNumber();
+    const blockNumber = readLogBlockNumber(matchingTransfer.latestLog);
+    const confirmations = calculateConfirmations(currentBlock, blockNumber);
+    const requiredConfirmations = this.confirmations;
+    const receivedAmountAtomic = decimalToMinorUnitAmount(
+      matchingTransfer.amountAtomic,
+      USDC_DECIMALS,
+      "Base USDC received"
+    );
+    return {
+      backendId: this.capabilities.id,
+      quoteId: normalizedQuoteId,
+      payTo: normalizedPayTo,
+      status: confirmations >= requiredConfirmations ? "confirmed" : "processing",
+      settlementCurrency: "USDC",
+      settlementAmount: option?.settlementAmount ?? (context.settlementAmount === void 0 ? void 0 : normalizeMinorUnitAmount(
+        context.settlementAmount,
+        "Base USDC settlement status"
+      )),
+      receivedAmount: receivedAmountAtomic,
+      amount: option?.amount ?? (context.amount === void 0 ? void 0 : normalizeMinorUnitAmount(context.amount, "Base USDC status")),
+      currency: option?.currency ?? (context.currency === void 0 ? void 0 : normalizeCurrency(context.currency, "Base USDC status")),
+      requiredConfirmations,
+      confirmations,
+      transactionId: matchingTransfer.latestLog.transactionHash,
+      updatedAt: /* @__PURE__ */ new Date(),
+      raw: matchingTransfer.latestLog
+    };
+  }
+  async verifyX402Proof(input) {
+    const quoteId = normalizeNonEmptyString(input.quoteId, "Base USDC quoteId");
+    let payload;
+    try {
+      payload = decodePaymentHeader(input.paymentHeader);
+    } catch (error) {
+      return {
+        valid: false,
+        backendId: this.capabilities.id,
+        quoteId,
+        payTo: input.payTo,
+        reason: "x402 payment header could not be decoded.",
+        raw: {
+          paymentHeader: input.paymentHeader,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      };
+    }
+    const transactionId = readX402PayloadString(payload, [
+      "transactionHash",
+      "txHash",
+      "tx",
+      "hash"
+    ])?.trim();
+    if (this.x402FacilitatorUrl) {
+      return this.verifyWithFacilitator(input, payload);
+    }
+    if (!transactionId) {
+      return {
+        valid: false,
+        backendId: this.capabilities.id,
+        quoteId,
+        payTo: input.payTo,
+        reason: "x402 proof did not include a transaction hash and no facilitator URL is configured.",
+        raw: payload
+      };
+    }
+    if (!isEvmTransactionHash(transactionId)) {
+      return {
+        valid: false,
+        backendId: this.capabilities.id,
+        quoteId,
+        payTo: input.payTo,
+        transactionId,
+        reason: "x402 proof transaction hash was invalid.",
+        raw: payload
+      };
+    }
+    const requirementError = validateX402PayloadRequirements(payload, input);
+    if (requirementError) {
+      return {
+        valid: false,
+        backendId: this.capabilities.id,
+        quoteId,
+        payTo: input.payTo,
+        transactionId,
+        reason: requirementError,
+        raw: payload
+      };
+    }
+    const expectedAmountAtomic = amountToUsdcAtomicUnits(
+      normalizePositiveMinorUnitAmount(input.amount, "Base USDC x402 amount"),
+      normalizeCurrency(input.currency, "Base USDC x402"),
+      "Base USDC x402 amount"
+    );
+    return this.verifyX402Receipt(
+      input,
+      payload,
+      quoteId,
+      transactionId,
+      expectedAmountAtomic
+    );
+  }
+  async sendPayout(input) {
+    if (input.currency !== void 0) {
+      const currency = normalizeNonEmptyString(
+        input.currency,
+        "Base USDC payout currency"
+      );
+      if (currency.toUpperCase() !== "USDC") {
+        throw new PaymentConfigurationError(
+          `BaseUsdcAdapter can only send USDC payouts, received ${input.currency}.`
+        );
+      }
+    }
+    if (!this.options.sendTransaction) {
+      throw new PaymentConfigurationError(
+        "BaseUsdcAdapter sendPayout requires a sendTransaction callback."
+      );
+    }
+    const amount = normalizePositiveMinorUnitAmount(
+      input.amount,
+      "Base USDC payout amount"
+    );
+    const amountAtomic = String(amount);
+    const destination = normalizeAddress(input.destination);
+    const quoteId = input.quoteId === void 0 ? void 0 : normalizeNonEmptyString(input.quoteId, "Base USDC payout quoteId");
+    const idempotencyKey = input.idempotencyKey === void 0 ? void 0 : normalizeNonEmptyString(
+      input.idempotencyKey,
+      "Base USDC payout idempotencyKey"
+    );
+    const result = await this.options.sendTransaction({
+      destination,
+      amount,
+      amountAtomic,
+      currency: "USDC",
+      tokenAddress: this.usdcContractAddress,
+      memo: input.memo,
+      quoteId,
+      idempotencyKey,
+      metadata: input.metadata
+    });
+    return {
+      backendId: this.capabilities.id,
+      status: "submitted",
+      transactionId: result.transactionId,
+      destination,
+      amount,
+      currency: "USDC",
+      raw: result.raw
+    };
+  }
+  async refundPayment(input) {
+    if (input.currency !== void 0) {
+      const currency = normalizeNonEmptyString(
+        input.currency,
+        "Base USDC refund currency"
+      );
+      if (currency.toUpperCase() !== "USDC") {
+        throw new PaymentConfigurationError(
+          `BaseUsdcAdapter refunds require USDC currency when specified, received ${input.currency}.`
+        );
+      }
+    }
+    if (!input.destination) {
+      throw new PaymentConfigurationError(
+        "Base USDC refunds require a destination payer address."
+      );
+    }
+    if (input.amount === void 0) {
+      throw new PaymentConfigurationError(
+        "Base USDC refunds require an amount."
+      );
+    }
+    const payout = await this.sendPayout({
+      destination: input.destination,
+      amount: input.amount,
+      currency: "USDC",
+      idempotencyKey: input.idempotencyKey,
+      memo: input.reason,
+      metadata: input.metadata
+    });
+    return {
+      backendId: this.capabilities.id,
+      status: "submitted",
+      transactionId: payout.transactionId,
+      amount: payout.amount,
+      currency: payout.currency,
+      raw: payout.raw
+    };
+  }
+  async deriveAddress(input) {
+    if (this.options.addressDeriver) {
+      return this.options.addressDeriver(input);
+    }
+    if (!this.masterXpub) {
+      throw new PaymentConfigurationError(
+        "BaseUsdcAdapter requires masterXpub or addressDeriver."
+      );
+    }
+    return deriveBaseUsdcAddress({
+      masterXpub: this.masterXpub,
+      path: input.path
+    });
+  }
+  async getTransferLogs(payTo, requiredFromBlock) {
+    const fromBlock = this.configuredFromBlock ?? await this.getDefaultFromBlock(requiredFromBlock);
+    const logs = await this.rpc("eth_getLogs", [
+      {
+        address: this.usdcContractAddress,
+        fromBlock,
+        toBlock: "latest",
+        topics: [TRANSFER_TOPIC, null, addressToTopic(payTo)]
+      }
+    ]);
+    return Array.isArray(logs) ? logs : [];
+  }
+  async getDefaultFromBlock(requiredFromBlock) {
+    const currentBlock = await this.getCurrentBlockNumber();
+    const lookbackStartBlock = currentBlock > DEFAULT_LOG_LOOKBACK_BLOCKS ? currentBlock - DEFAULT_LOG_LOOKBACK_BLOCKS : 0n;
+    const startBlock = requiredFromBlock ?? lookbackStartBlock;
+    return toHexQuantity(startBlock);
+  }
+  async getCurrentBlockNumber() {
+    return parseHexQuantity(await this.rpc("eth_blockNumber", []));
+  }
+  async rpc(method, params) {
+    const response = await this.fetch(this.rpcUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: ++this.rpcId,
+        method,
+        params
+      })
+    });
+    const json = await readJsonResponse(
+      response,
+      `Base RPC ${method}`
+    );
+    if (json.error) {
+      throw new PaymentProviderError(
+        `Base RPC ${method}: ${json.error.message}`,
+        { retryable: json.error.code === -32005 }
+      );
+    }
+    return json.result;
+  }
+  async verifyX402Receipt(input, payload, quoteId, transactionId, expectedAmountAtomic, extraRaw) {
+    if (this.seenX402TransactionIds.has(transactionId)) {
+      return {
+        valid: false,
+        backendId: this.capabilities.id,
+        quoteId,
+        payTo: input.payTo,
+        transactionId,
+        reason: "x402 transaction has already been verified.",
+        raw: { ...extraRaw, payload }
+      };
+    }
+    this.seenX402TransactionIds.add(transactionId);
+    let keepReplayMarker = false;
+    try {
+      const receipt = await this.rpc(
+        "eth_getTransactionReceipt",
+        [transactionId]
+      );
+      const raw = { ...extraRaw, payload, receipt };
+      if (!receipt) {
+        return {
+          valid: false,
+          backendId: this.capabilities.id,
+          quoteId,
+          payTo: input.payTo,
+          transactionId,
+          reason: "x402 transaction receipt is not available yet.",
+          raw
+        };
+      }
+      if (receipt.status !== "0x1") {
+        return {
+          valid: false,
+          backendId: this.capabilities.id,
+          quoteId,
+          payTo: input.payTo,
+          transactionId,
+          reason: "x402 transaction failed onchain.",
+          raw
+        };
+      }
+      const blockNumber = parseHexQuantity(receipt.blockNumber ?? "0x0");
+      const currentBlock = blockNumber > 0n ? await this.getCurrentBlockNumber() : 0n;
+      const confirmations = calculateConfirmations(currentBlock, blockNumber);
+      if (confirmations < this.confirmations) {
+        return {
+          valid: false,
+          backendId: this.capabilities.id,
+          quoteId,
+          payTo: input.payTo,
+          transactionId,
+          reason: `x402 transaction has ${confirmations} confirmations; ${this.confirmations} required.`,
+          raw
+        };
+      }
+      const receiptLogs = Array.isArray(receipt.logs) ? receipt.logs : [];
+      const matchingLog = pickBestTransferLog(
+        receiptLogs.filter(
+          (log) => isRecord(log) && safeNormalizeAddress(log.address) === this.usdcContractAddress
+        ),
+        expectedAmountAtomic,
+        input.payTo,
+        "exact"
+      );
+      if (!matchingLog) {
+        return {
+          valid: false,
+          backendId: this.capabilities.id,
+          quoteId,
+          payTo: input.payTo,
+          transactionId,
+          reason: "No exact USDC transfer matching the x402 proof.",
+          raw
+        };
+      }
+      keepReplayMarker = true;
+      trimSeenX402TransactionIds(this.seenX402TransactionIds);
+      return {
+        valid: true,
+        backendId: this.capabilities.id,
+        quoteId,
+        payTo: normalizeAddress(input.payTo),
+        transactionId,
+        payer: parseTransferLog(matchingLog)?.from,
+        amount: decimalToMinorUnitAmount(
+          parseHexQuantity(matchingLog.data),
+          USDC_DECIMALS,
+          "Base USDC x402 amount"
+        ),
+        currency: "USDC",
+        network: input.network ?? BASE_MAINNET_CAIP2,
+        raw
+      };
+    } finally {
+      if (!keepReplayMarker) {
+        this.seenX402TransactionIds.delete(transactionId);
+      }
+    }
+  }
+  async verifyWithFacilitator(input, payload) {
+    const quoteId = normalizeNonEmptyString(input.quoteId, "Base USDC quoteId");
+    if (!this.x402FacilitatorUrl) {
+      throw new PaymentVerificationError("x402 facilitator URL is missing.");
+    }
+    const maxAmountRequired = amountToUsdcAtomicUnits(
+      normalizePositiveMinorUnitAmount(input.amount, "Base USDC x402 amount"),
+      normalizeCurrency(input.currency, "Base USDC x402"),
+      "Base USDC x402 amount"
+    );
+    const response = await this.fetch(`${this.x402FacilitatorUrl}/verify`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        paymentPayload: payload,
+        paymentRequirements: {
+          scheme: input.scheme ?? "exact",
+          network: input.network ?? BASE_MAINNET_CAIP2,
+          asset: this.usdcContractAddress,
+          payTo: normalizeAddress(input.payTo),
+          maxAmountRequired,
+          resource: input.resource,
+          method: input.method
+        }
+      })
+    });
+    const json = await readJsonResponse(
+      response,
+      "x402 facilitator verify"
+    );
+    const valid = readBoolean(json, "valid") ?? readBoolean(json, "isValid");
+    const transactionId = findNestedString(json, [
+      "transactionHash",
+      "txHash"
+    ])?.trim();
+    if (valid !== true) {
+      return {
+        valid: false,
+        backendId: this.capabilities.id,
+        quoteId,
+        payTo: normalizeAddress(input.payTo),
+        transactionId,
+        network: input.network ?? BASE_MAINNET_CAIP2,
+        reason: String(json.reason ?? "facilitator rejected"),
+        raw: json
+      };
+    }
+    if (!transactionId) {
+      return {
+        valid: false,
+        backendId: this.capabilities.id,
+        quoteId,
+        payTo: normalizeAddress(input.payTo),
+        network: input.network ?? BASE_MAINNET_CAIP2,
+        reason: "x402 facilitator did not return a transaction hash.",
+        raw: json
+      };
+    }
+    if (!isEvmTransactionHash(transactionId)) {
+      return {
+        valid: false,
+        backendId: this.capabilities.id,
+        quoteId,
+        payTo: normalizeAddress(input.payTo),
+        transactionId,
+        network: input.network ?? BASE_MAINNET_CAIP2,
+        reason: "x402 facilitator transaction hash was invalid.",
+        raw: json
+      };
+    }
+    const requirementError = validateX402PayloadRequirements(payload, input);
+    if (requirementError) {
+      return {
+        valid: false,
+        backendId: this.capabilities.id,
+        quoteId,
+        payTo: normalizeAddress(input.payTo),
+        transactionId,
+        network: input.network ?? BASE_MAINNET_CAIP2,
+        reason: requirementError,
+        raw: json
+      };
+    }
+    return this.verifyX402Receipt(
+      input,
+      payload,
+      quoteId,
+      transactionId,
+      maxAmountRequired,
+      { facilitator: json }
+    );
+  }
+}
+async function deriveBaseUsdcAddress(input) {
+  const masterXpub = normalizeNonEmptyString(
+    input.masterXpub,
+    "Base USDC masterXpub"
+  );
+  const path = normalizeNonEmptyString(input.path, "Base USDC derivation path");
+  try {
+    const [{ HDKey }, { secp256k1 }, { keccak_256 }] = await Promise.all([
+      import("@scure/bip32"),
+      import("@noble/curves/secp256k1.js"),
+      import("@noble/hashes/sha3.js")
+    ]);
+    const root = HDKey.fromExtendedKey(masterXpub);
+    const child = root.derive(path);
+    if (!child.publicKey) {
+      throw new PaymentConfigurationError(`No public key derived for ${path}.`);
+    }
+    const point = secp256k1.Point.fromBytes(child.publicKey);
+    const { x, y } = point.toAffine();
+    const publicKey = concatBytes(bigintToFixedBytes(x), bigintToFixedBytes(y));
+    const hash = keccak_256(publicKey);
+    return `0x${bytesToHex(hash.slice(-20))}`;
+  } catch (error) {
+    if (error instanceof PaymentConfigurationError) {
+      throw error;
+    }
+    throw new PaymentConfigurationError(
+      "BIP32 xpub address derivation requires @scure/bip32, @noble/curves, and @noble/hashes.",
+      { cause: error }
+    );
+  }
+}
+function quoteIdToDerivationIndex(quoteId) {
+  return quoteIdToDerivationIndexes(quoteId)[0] ?? 0;
+}
+function quoteIdToDerivationIndexes(quoteId) {
+  const normalizedQuoteId = normalizeNonEmptyString(
+    quoteId,
+    "Base USDC quoteId"
+  );
+  const hash = createHash("sha256").update(normalizedQuoteId).digest();
+  return [0, 4, 8, 12].map((offset) => hash.readUInt32BE(offset) & 2147483647);
+}
+function normalizeDerivationIndex(index) {
+  if (!Number.isInteger(index) || index < 0 || index > 2147483647) {
+    throw new PaymentConfigurationError(
+      `BaseUsdcAdapter addressIndexForQuote must return a non-hardened BIP32 child index, received ${String(index)}.`
+    );
+  }
+  return index;
+}
+function normalizeDerivationPathPrefix(value) {
+  if (typeof value !== "string") {
+    throw new PaymentConfigurationError(
+      "BaseUsdcAdapter derivationPathPrefix must be a string."
+    );
+  }
+  const normalized = value.trim().replace(/\/+$/, "");
+  if (!normalized) {
+    throw new PaymentConfigurationError(
+      "BaseUsdcAdapter derivationPathPrefix must not be empty when configured."
+    );
+  }
+  return normalized;
+}
+function normalizeConfirmationCount(value, label) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new PaymentConfigurationError(
+      `${label} must be a non-negative integer, received ${String(value)}.`
+    );
+  }
+  return value;
+}
+function readBoolean(value, key) {
+  const item = value[key];
+  return typeof item === "boolean" ? item : void 0;
+}
+function normalizeFromBlock(value) {
+  if (typeof value === "bigint") {
+    if (value < 0n) {
+      throw new PaymentConfigurationError(
+        `BaseUsdcAdapter fromBlock must be a non-negative JSON-RPC block tag or quantity, received ${String(value)}.`
+      );
+    }
+    return toHexQuantity(value);
+  }
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value) || value < 0) {
+      throw new PaymentConfigurationError(
+        `BaseUsdcAdapter fromBlock must be a non-negative JSON-RPC block tag or quantity, received ${String(value)}.`
+      );
+    }
+    return toHexQuantity(BigInt(value));
+  }
+  if (typeof value !== "string") {
+    throw new PaymentConfigurationError(
+      `BaseUsdcAdapter fromBlock must be a non-negative JSON-RPC block tag or quantity, received ${String(value)}.`
+    );
+  }
+  const normalized = value.trim();
+  if (["earliest", "latest", "pending"].includes(normalized)) {
+    return normalized;
+  }
+  if (/^0x[0-9a-fA-F]+$/.test(normalized)) {
+    return normalized.toLowerCase();
+  }
+  throw new PaymentConfigurationError(
+    `BaseUsdcAdapter fromBlock must be a non-negative JSON-RPC block tag or quantity, received ${String(value)}.`
+  );
+}
+function configuredFromBlockMinBlock(value) {
+  if (value === void 0 || ["earliest", "latest", "pending"].includes(value)) {
+    return 0n;
+  }
+  return parseHexQuantity(value);
+}
+function calculateConfirmations(currentBlock, blockNumber) {
+  if (blockNumber <= 0n || currentBlock < blockNumber) {
+    return 0;
+  }
+  const confirmations = currentBlock - blockNumber + 1n;
+  return confirmations > BigInt(Number.MAX_SAFE_INTEGER) ? Number.MAX_SAFE_INTEGER : Number(confirmations);
+}
+function resolveExpectedUsdcAmount(option, context) {
+  if (option) {
+    return option.expectedAmountAtomic;
+  }
+  if (context.settlementAmount !== void 0) {
+    return String(
+      normalizePositiveMinorUnitAmount(
+        context.settlementAmount,
+        "Base USDC expected amount"
+      )
+    );
+  }
+  if (context.amount === void 0 || context.currency === void 0) {
+    return void 0;
+  }
+  return amountToUsdcAtomicUnits(
+    normalizePositiveMinorUnitAmount(
+      context.amount,
+      "Base USDC expected amount"
+    ),
+    normalizeCurrency(context.currency, "Base USDC expected amount"),
+    "Base USDC expected amount"
+  );
+}
+function amountToUsdcAtomicUnits(amount, currency, context) {
+  const normalizedCurrency = normalizeCurrency(currency, context);
+  if (!["USD", "USDC"].includes(normalizedCurrency)) {
+    throw new PaymentConfigurationError(
+      `${context} currency must be USD or USDC for Base USDC settlement, received ${currency}.`
+    );
+  }
+  const decimalAmount = minorUnitsToDecimal(
+    amount,
+    currencyMinorUnitDecimals(normalizedCurrency)
+  );
+  return decimalToAtomicUnits(decimalAmount, USDC_DECIMALS);
+}
+function pickBestTransferLog(logs, expectedAmountAtomic, payTo, comparison = "atLeast", minBlockNumber = 0n) {
+  const expected = BigInt(expectedAmountAtomic);
+  return logs.find((log) => {
+    const transfer = parseTransferLog(log);
+    if (!transfer || log.removed) {
+      return false;
+    }
+    if (readLogBlockNumber(log) < minBlockNumber) {
+      return false;
+    }
+    if (payTo && transfer.to !== normalizeAddress(payTo)) {
+      return false;
+    }
+    return comparison === "exact" ? transfer.amountAtomic === expected : transfer.amountAtomic >= expected;
+  });
+}
+function pickSingleTransferMatch(logs, expectedAmountAtomic, payTo, minBlockNumber = 0n) {
+  const log = pickBestTransferLog(
+    logs,
+    expectedAmountAtomic,
+    payTo,
+    "atLeast",
+    minBlockNumber
+  );
+  const transfer = log ? parseTransferLog(log) : void 0;
+  return log && transfer ? { amountAtomic: transfer.amountAtomic, latestLog: log } : void 0;
+}
+function pickCumulativeTransferMatch(logs, expectedAmountAtomic, payTo, minBlockNumber = 0n) {
+  const expected = BigInt(expectedAmountAtomic);
+  const matched = logs.map((log) => ({
+    log,
+    transfer: parseTransferLog(log)
+  })).filter(
+    (item) => {
+      if (!item.transfer || item.log.removed) {
+        return false;
+      }
+      if (readLogBlockNumber(item.log) < minBlockNumber) {
+        return false;
+      }
+      return true;
+    }
+  );
+  const byPayer = /* @__PURE__ */ new Map();
+  for (const item of matched) {
+    const existing = byPayer.get(item.transfer.from);
+    const latestLog = existing && compareTransferLogs(existing.latestLog, item.log) >= 0 ? existing.latestLog : item.log;
+    byPayer.set(item.transfer.from, {
+      amountAtomic: (existing?.amountAtomic ?? 0n) + item.transfer.amountAtomic,
+      latestLog
+    });
+  }
+  const candidates = [...byPayer.values()].filter(
+    (item) => item.amountAtomic >= expected
+  );
+  if (candidates.length === 0) {
+    return void 0;
+  }
+  return candidates.reduce(
+    (current, item) => compareTransferLogs(item.latestLog, current.latestLog) > 0 ? item : current
+  );
+}
+function parseTransferLog(log) {
+  if (!isRecord(log) || !Array.isArray(log.topics) || typeof log.data !== "string") {
+    return void 0;
+  }
+  if (log.topics[0]?.toLowerCase() !== TRANSFER_TOPIC || log.topics.length < 3) {
+    return void 0;
+  }
+  try {
+    return {
+      from: topicToAddress(log.topics[1] ?? ""),
+      to: topicToAddress(log.topics[2] ?? ""),
+      amountAtomic: parseHexQuantity(log.data)
+    };
+  } catch {
+    return void 0;
+  }
+}
+function readLogBlockNumber(log) {
+  try {
+    return parseHexQuantity(log.blockNumber ?? "0x0");
+  } catch {
+    return 0n;
+  }
+}
+function compareTransferLogs(left, right) {
+  const leftBlock = readLogBlockNumber(left);
+  const rightBlock = readLogBlockNumber(right);
+  if (leftBlock > rightBlock) {
+    return 1;
+  }
+  if (leftBlock < rightBlock) {
+    return -1;
+  }
+  return (left.transactionHash ?? "").toLowerCase().localeCompare((right.transactionHash ?? "").toLowerCase());
+}
+function trimSeenX402TransactionIds(seenTransactionIds) {
+  while (seenTransactionIds.size > DEFAULT_MAX_SEEN_X402_TRANSACTION_IDS) {
+    const oldest = seenTransactionIds.values().next().value;
+    if (oldest === void 0) {
+      break;
+    }
+    seenTransactionIds.delete(oldest);
+  }
+}
+function buildUsdcPaymentUri(input) {
+  return `ethereum:${input.tokenAddress}@${BASE_MAINNET_CHAIN_ID}/transfer?address=${input.payTo}&uint256=${input.amountAtomic}`;
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeAddress(address) {
+  if (typeof address !== "string") {
+    throw new PaymentConfigurationError(
+      `Invalid EVM address: ${String(address)}`
+    );
+  }
+  const normalized = address.trim();
+  if (!/^0x[a-fA-F0-9]{40}$/.test(normalized)) {
+    throw new PaymentConfigurationError(`Invalid EVM address: ${address}`);
+  }
+  return normalized.toLowerCase();
+}
+function isEvmTransactionHash(value) {
+  return /^0x[a-fA-F0-9]{64}$/.test(value);
+}
+function safeNormalizeAddress(address) {
+  try {
+    return normalizeAddress(address);
+  } catch {
+    return void 0;
+  }
+}
+function addressToTopic(address) {
+  return `0x${normalizeAddress(address).slice(2).padStart(64, "0")}`;
+}
+function topicToAddress(topic) {
+  if (!/^0x[a-fA-F0-9]{64}$/.test(topic)) {
+    throw new PaymentProviderError(`Invalid EVM address topic: ${topic}`);
+  }
+  return normalizeAddress(`0x${topic.slice(-40)}`);
+}
+function parseHexQuantity(value) {
+  if (typeof value === "bigint") {
+    if (value < 0n) {
+      throw new PaymentProviderError(
+        `Invalid JSON-RPC hex quantity: ${String(value)}`
+      );
+    }
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value) || value < 0) {
+      throw new PaymentProviderError(
+        `Invalid JSON-RPC hex quantity: ${String(value)}`
+      );
+    }
+    return BigInt(value);
+  }
+  if (typeof value !== "string") {
+    throw new PaymentProviderError(
+      `Invalid JSON-RPC hex quantity: ${String(value)}`
+    );
+  }
+  const normalized = value.trim();
+  if (!/^0x[0-9a-fA-F]+$/.test(normalized)) {
+    throw new PaymentProviderError(
+      `Invalid JSON-RPC hex quantity: ${String(value)}`
+    );
+  }
+  return BigInt(normalized);
+}
+function toHexQuantity(value) {
+  return `0x${value.toString(16)}`;
+}
+function decodePaymentHeader(value) {
+  const trimmed = value.trim();
+  if (trimmed.length > 65536) {
+    throw new PaymentVerificationError("x402 payment header is too large.");
+  }
+  const decoded = trimmed.startsWith("{") ? JSON.parse(trimmed) : JSON.parse(
+    Buffer.from(
+      trimmed.replace(/-/g, "+").replace(/_/g, "/").padEnd(trimmed.length + (4 - trimmed.length % 4) % 4, "="),
+      "base64"
+    ).toString("utf8")
+  );
+  if (!decoded || typeof decoded !== "object" || Array.isArray(decoded)) {
+    throw new PaymentVerificationError(
+      "x402 payment header must be an object."
+    );
+  }
+  return decoded;
+}
+function validateX402PayloadRequirements(payload, input) {
+  const expectedScheme = input.scheme ?? "exact";
+  const actualScheme = readX402PayloadString(payload, ["scheme"]);
+  if (!actualScheme) {
+    return "x402 proof did not include the payment scheme.";
+  }
+  if (actualScheme && actualScheme !== expectedScheme) {
+    return `x402 proof scheme ${actualScheme} did not match ${expectedScheme}.`;
+  }
+  const expectedNetwork = normalizeX402Network(
+    input.network ?? BASE_MAINNET_CAIP2
+  );
+  const actualNetwork = normalizeX402Network(
+    readX402PayloadString(payload, ["network", "networkId"])
+  );
+  if (!actualNetwork) {
+    return "x402 proof did not include the payment network.";
+  }
+  if (actualNetwork && actualNetwork !== expectedNetwork) {
+    return `x402 proof network ${actualNetwork} did not match ${expectedNetwork}.`;
+  }
+  const expectedResource = input.resource;
+  if (expectedResource !== void 0) {
+    const actualResource = readX402PayloadString(payload, ["resource"]);
+    if (!actualResource) {
+      return "x402 proof did not include the paid resource.";
+    }
+    if (actualResource !== expectedResource) {
+      return "x402 proof resource did not match the requested resource.";
+    }
+  }
+  const expectedMethod = input.method;
+  if (expectedMethod !== void 0) {
+    const actualMethod = readX402PayloadString(payload, ["method"]);
+    if (!actualMethod) {
+      return "x402 proof did not include the HTTP method.";
+    }
+    if (actualMethod.toUpperCase() !== expectedMethod.toUpperCase()) {
+      return "x402 proof method did not match the requested method.";
+    }
+  }
+  const actualExpiry = readX402PayloadString(payload, [
+    "expiresAt",
+    "expires",
+    "validBefore",
+    "deadline"
+  ]);
+  const actualExpiryDate = actualExpiry === void 0 ? void 0 : parseX402ExpiryDate(actualExpiry);
+  if (actualExpiry !== void 0 && !actualExpiryDate) {
+    return "x402 proof expiry was invalid.";
+  }
+  if (actualExpiryDate !== void 0 && actualExpiryDate < /* @__PURE__ */ new Date()) {
+    return "x402 proof is expired.";
+  }
+  if (input.expiresAt !== void 0) {
+    const expectedExpiry = normalizeDate(input.expiresAt);
+    if (expectedExpiry < /* @__PURE__ */ new Date()) {
+      return "x402 proof is expired.";
+    }
+    if (!actualExpiry) {
+      return "x402 proof did not include an expiry.";
+    }
+    if (actualExpiryDate?.getTime() !== expectedExpiry.getTime()) {
+      return "x402 proof expiry did not match the requested expiry.";
+    }
+  }
+  return void 0;
+}
+function parseX402ExpiryDate(value) {
+  try {
+    if (/^\d+$/.test(value)) {
+      const timestamp = Number(value);
+      if (!Number.isSafeInteger(timestamp)) {
+        return void 0;
+      }
+      const date = new Date(
+        timestamp < 1e12 ? timestamp * 1e3 : timestamp
+      );
+      return Number.isNaN(date.getTime()) ? void 0 : date;
+    }
+    return normalizeDate(value);
+  } catch {
+    return void 0;
+  }
+}
+function normalizeX402Network(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (["base", "base-mainnet", BASE_MAINNET_CAIP2].includes(normalized)) {
+    return BASE_MAINNET_CAIP2;
+  }
+  return value;
+}
+function readX402PayloadString(value, keys) {
+  const root = asRecord(value);
+  const nestedPayload = asRecord(root?.payload);
+  const authorization = asRecord(nestedPayload?.authorization);
+  for (const key of keys) {
+    const authorized = readLooseString(authorization, key);
+    if (authorized) {
+      return authorized;
+    }
+    const nested = readLooseString(nestedPayload, key);
+    if (nested) {
+      return nested;
+    }
+    const direct = readLooseString(root, key);
+    if (direct) {
+      return direct;
+    }
+  }
+  return void 0;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function readLooseString(value, key) {
+  const item = value?.[key];
+  if (typeof item === "string") {
+    return item;
+  }
+  if (typeof item === "number") {
+    return String(item);
+  }
+  return void 0;
+}
+function findNestedString(value, keys, depth = 0) {
+  if (!value || typeof value !== "object" || depth > 16) {
+    return void 0;
+  }
+  const record = value;
+  for (const key of keys) {
+    const direct = record[key];
+    if (typeof direct === "string" && direct.length > 0) {
+      return direct;
+    }
+    if (typeof direct === "number" && Number.isFinite(direct)) {
+      return String(direct);
+    }
+  }
+  for (const child of Object.values(record)) {
+    const match = findNestedString(child, keys, depth + 1);
+    if (match) {
+      return match;
+    }
+  }
+  return void 0;
+}
+function bigintToFixedBytes(value) {
+  const hex = value.toString(16).padStart(64, "0");
+  return hexToBytes(hex);
+}
+function concatBytes(...values) {
+  const totalLength = values.reduce((sum, value) => sum + value.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const value of values) {
+    result.set(value, offset);
+    offset += value.length;
+  }
+  return result;
+}
+function bytesToHex(value) {
+  return Array.from(value, (byte) => byte.toString(16).padStart(2, "0")).join(
+    ""
+  );
+}
+function hexToBytes(value) {
+  const bytes = value.match(/.{1,2}/g) ?? [];
+  return Uint8Array.from(bytes.map((byte) => Number.parseInt(byte, 16)));
+}
+export {
+  BASE_MAINNET_CAIP2,
+  BASE_MAINNET_CHAIN_ID,
+  BASE_USDC_BACKEND_ID,
+  BASE_USDC_CONTRACT,
+  BaseUsdcAdapter,
+  USDC_DECIMALS,
+  deriveBaseUsdcAddress,
+  quoteIdToDerivationIndex,
+  quoteIdToDerivationIndexes
+};
+//# sourceMappingURL=base-usdc.js.map