npm - @cedros/pay-react - Versions diffs - 1.0.3 → 1.0.5 - Mend

@cedros/pay-react 1.0.3 → 1.0.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (61) hide show

package/README.md +110 -3
package/dist/CedrosContext-CFEXGwQg.mjs +2163 -0
package/dist/CedrosContext-DbndTsTA.js +11 -0
package/dist/components/CryptoSubscribeButton.d.ts +50 -0
package/dist/components/CryptoSubscribeButton.d.ts.map +1 -0
package/dist/components/SubscribeButton.d.ts +55 -0
package/dist/components/SubscribeButton.d.ts.map +1 -0
package/dist/components/SubscriptionManagementPanel.d.ts +67 -0
package/dist/components/SubscriptionManagementPanel.d.ts.map +1 -0
package/dist/components/subscriptionPanelStyles.d.ts +13 -0
package/dist/components/subscriptionPanelStyles.d.ts.map +1 -0
package/dist/context/CedrosContext.d.ts +4 -0
package/dist/context/CedrosContext.d.ts.map +1 -1
package/dist/crypto-only.js +1 -1
package/dist/crypto-only.mjs +2 -2
package/dist/en-C739WV_-.mjs +19 -0
package/dist/en-Cz4OpvN-.js +1 -0
package/dist/hooks/useCryptoSubscription.d.ts +42 -0
package/dist/hooks/useCryptoSubscription.d.ts.map +1 -0
package/dist/hooks/useSubscription.d.ts +42 -0
package/dist/hooks/useSubscription.d.ts.map +1 -0
package/dist/hooks/useSubscriptionManagement.d.ts +88 -0
package/dist/hooks/useSubscriptionManagement.d.ts.map +1 -0
package/dist/i18n/index.d.ts +7 -0
package/dist/i18n/index.d.ts.map +1 -1
package/dist/i18n/useTranslation.d.ts.map +1 -1
package/dist/index.d.ts +12 -2
package/dist/index.d.ts.map +1 -1
package/dist/index.js +1 -1
package/dist/index.mjs +1658 -360
package/dist/managers/ManagerCache.d.ts +4 -0
package/dist/managers/ManagerCache.d.ts.map +1 -1
package/dist/managers/SubscriptionChangeManager.d.ts +42 -0
package/dist/managers/SubscriptionChangeManager.d.ts.map +1 -0
package/dist/managers/SubscriptionManager.d.ts +113 -0
package/dist/managers/SubscriptionManager.d.ts.map +1 -0
package/dist/pay-react.css +1 -1
package/dist/stripe-only.js +1 -1
package/dist/stripe-only.mjs +2 -2
package/dist/{styles-zgmHs6Hs.mjs → styles-DFcRS8Uu.mjs} +303 -278
package/dist/styles-Dup9uK6S.js +1 -0
package/dist/testing/index.js +1 -1
package/dist/testing/index.mjs +1 -1
package/dist/types/index.d.ts +1 -0
package/dist/types/index.d.ts.map +1 -1
package/dist/types/subscription.d.ts +300 -0
package/dist/types/subscription.d.ts.map +1 -0
package/dist/utils/__tests__/couponHelpers.test.d.ts +2 -0
package/dist/utils/__tests__/couponHelpers.test.d.ts.map +1 -0
package/dist/utils/couponHelpers.d.ts +46 -0
package/dist/utils/couponHelpers.d.ts.map +1 -1
package/dist/utils/index.d.ts +1 -1
package/dist/utils/index.d.ts.map +1 -1
package/dist/utils/uuid-shim.d.ts +9 -0
package/dist/utils/uuid-shim.d.ts.map +1 -0
package/package.json +1 -1
package/dist/CedrosContext-B3iCqN6e.js +0 -11
package/dist/CedrosContext-vX9uqZKp.mjs +0 -1796
package/dist/en-CSsJl3nf.mjs +0 -19
package/dist/en-D-uY3ltT.js +0 -1
package/dist/styles-D3XGpsqb.js +0 -1

package/dist/CedrosContext-CFEXGwQg.mjs ADDED Viewed

@@ -0,0 +1,2163 @@
+import { jsx as X } from "react/jsx-runtime";
+import { createContext as pe, useContext as ye, useState as Q, useRef as me, useEffect as L, useMemo as Y } from "react";
+import { g as k } from "./uuid-UlzrVY8Y.mjs";
+import { clusterApiUrl as je, Connection as $e, Transaction as ae, PublicKey as N, LAMPORTS_PER_SOL as _e } from "@solana/web3.js";
+import { getAssociatedTokenAddress as We, createTransferInstruction as qe } from "@solana/spl-token";
+import { PhantomWalletAdapter as Ke, SolflareWalletAdapter as ze } from "@solana/wallet-adapter-wallets";
+var we = "https://js.stripe.com/v3", Ve = /^https:\/\/js\.stripe\.com\/v3\/?(\?.*)?$/;
+var Ge = function() {
+  for (var e = document.querySelectorAll('script[src^="'.concat(we, '"]')), t = 0; t < e.length; t++) {
+    var n = e[t];
+    if (Ve.test(n.src))
+      return n;
+  }
+  return null;
+}, ie = function(e) {
+  var t = "", n = document.createElement("script");
+  n.src = "".concat(we).concat(t);
+  var a = document.head || document.body;
+  if (!a)
+    throw new Error("Expected document.body not to be null. Stripe.js requires a <body> element.");
+  return a.appendChild(n), n;
+}, He = function(e, t) {
+  !e || !e._registerWrapper || e._registerWrapper({
+    name: "stripe-js",
+    version: "4.6.0",
+    startTime: t
+  });
+}, B = null, W = null, q = null, Je = function(e) {
+  return function() {
+    e(new Error("Failed to load Stripe.js"));
+  };
+}, Xe = function(e, t) {
+  return function() {
+    window.Stripe ? e(window.Stripe) : t(new Error("Stripe.js not available"));
+  };
+}, Qe = function(e) {
+  return B !== null ? B : (B = new Promise(function(t, n) {
+    if (typeof window > "u" || typeof document > "u") {
+      t(null);
+      return;
+    }
+    if (window.Stripe) {
+      t(window.Stripe);
+      return;
+    }
+    try {
+      var a = Ge();
+      if (!(a && e)) {
+        if (!a)
+          a = ie(e);
+        else if (a && q !== null && W !== null) {
+          var i;
+          a.removeEventListener("load", q), a.removeEventListener("error", W), (i = a.parentNode) === null || i === void 0 || i.removeChild(a), a = ie(e);
+        }
+      }
+      q = Xe(t, n), W = Je(n), a.addEventListener("load", q), a.addEventListener("error", W);
+    } catch (o) {
+      n(o);
+      return;
+    }
+  }), B.catch(function(t) {
+    return B = null, Promise.reject(t);
+  }));
+}, Ye = function(e, t, n) {
+  if (e === null)
+    return null;
+  var a = e.apply(void 0, t);
+  return He(a, n), a;
+}, I, ge = !1, be = function() {
+  return I || (I = Qe(null).catch(function(e) {
+    return I = null, Promise.reject(e);
+  }), I);
+};
+Promise.resolve().then(function() {
+  return be();
+}).catch(function(r) {
+  ge || console.warn(r);
+});
+var ve = function() {
+  for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++)
+    t[n] = arguments[n];
+  ge = !0;
+  var a = Date.now();
+  return be().then(function(i) {
+    return Ye(i, t, a);
+  });
+}, Ze = /* @__PURE__ */ ((r) => (r[r.DEBUG = 0] = "DEBUG", r[r.INFO = 1] = "INFO", r[r.WARN = 2] = "WARN", r[r.ERROR = 3] = "ERROR", r[r.SILENT = 4] = "SILENT", r))(Ze || {});
+class Ee {
+  config;
+  constructor(e) {
+    this.config = e;
+  }
+  /**
+   * Update the log level dynamically
+   */
+  setLevel(e) {
+    this.config.level = e;
+  }
+  /**
+   * Get the current log level
+   */
+  getLevel() {
+    return this.config.level;
+  }
+  /**
+   * Debug-level logging (most verbose)
+   * Use for detailed debugging information
+   */
+  debug(...e) {
+    this.config.level <= 0 && this.log("DEBUG", console.log, e);
+  }
+  /**
+   * Info-level logging
+   * Use for general informational messages
+   */
+  info(...e) {
+    this.config.level <= 1 && this.log("INFO", console.info, e);
+  }
+  /**
+   * Warning-level logging
+   * Use for potentially problematic situations
+   */
+  warn(...e) {
+    this.config.level <= 2 && this.log("WARN", console.warn, e);
+  }
+  /**
+   * Error-level logging
+   * Use for error conditions
+   */
+  error(...e) {
+    this.config.level <= 3 && this.log("ERROR", console.error, e);
+  }
+  /**
+   * Internal log method with formatting
+   */
+  log(e, t, n) {
+    const a = this.config.prefix ? `${this.config.prefix} ` : "", i = (/* @__PURE__ */ new Date()).toISOString();
+    t(`[${i}] ${a}[${e}]`, ...n);
+  }
+}
+const et = () => typeof process < "u" && process.env.NODE_ENV === "development" ? 0 : 2;
+let z = null;
+function c() {
+  return z || (z = new Ee({
+    level: et(),
+    prefix: "[CedrosPay]"
+  })), z;
+}
+function tt(r) {
+  z = r;
+}
+function rt(r) {
+  return new Ee(r);
+}
+function D(r, e) {
+  return r instanceof Error ? r.message : typeof r == "string" ? r : e;
+}
+const nt = {
+  service_unavailable: "Service temporarily unavailable. Please try again later or contact support.",
+  server_insufficient_funds: "Service temporarily unavailable. Please try again later or contact support.",
+  insufficient_funds_token: "Insufficient token balance in your wallet. Please add more tokens and try again.",
+  insufficient_funds_sol: "Insufficient SOL for transaction fees. Please add some SOL to your wallet and try again.",
+  insufficient_amount: "Payment amount is insufficient. Please check the required amount.",
+  invalid_signature: "Transaction signature is invalid. Please try again.",
+  send_failed: "Failed to send transaction. Please try again or contact support.",
+  timeout: "Transaction timed out. Please check the blockchain explorer or try again."
+};
+async function v(r, e, t = !1) {
+  try {
+    const n = await r.json();
+    if (t && n.verificationError) {
+      c().debug(`Payment verification failed: ${n.verificationError.code}`);
+      const a = n.verificationError.code;
+      return nt[a] || n.verificationError.message || e;
+    }
+    return typeof n.error == "string" ? n.error : n.error && typeof n.error == "object" && "message" in n.error ? n.error.message : e;
+  } catch {
+    return await r.text() || e;
+  }
+}
+const at = 3e4;
+async function w(r, e = {}, t = at) {
+  const n = new AbortController(), a = e.signal;
+  if (a?.aborted)
+    throw n.abort(), new DOMException("The operation was aborted", "AbortError");
+  const i = setTimeout(() => n.abort(), t);
+  let o = null;
+  a && (o = () => n.abort(), a.addEventListener("abort", o));
+  try {
+    return await fetch(r, {
+      ...e,
+      signal: n.signal
+    });
+  } catch (s) {
+    throw s instanceof Error && s.name === "AbortError" ? a?.aborted ? s : new Error(`Request timeout after ${t}ms`) : s;
+  } finally {
+    clearTimeout(i), a && o && a.removeEventListener("abort", o);
+  }
+}
+function R(r) {
+  const { maxRequests: e, windowMs: t } = r;
+  let n = e, a = Date.now();
+  const i = e / t;
+  function o() {
+    const f = Date.now(), h = f - a;
+    if (h > 0) {
+      const y = h * i;
+      n = Math.min(e, n + y), a = f;
+    }
+  }
+  function s() {
+    return o(), n >= 1 ? (n -= 1, !0) : !1;
+  }
+  function u() {
+    return o(), Math.floor(n);
+  }
+  function l() {
+    if (o(), n >= 1)
+      return 0;
+    const h = (1 - n) / i;
+    return Math.ceil(h);
+  }
+  function d() {
+    n = e, a = Date.now();
+  }
+  return {
+    tryConsume: s,
+    getAvailableTokens: u,
+    getTimeUntilRefill: l,
+    reset: d
+  };
+}
+const A = {
+  /** 10 requests per minute - recommended for payment requests */
+  PAYMENT: { maxRequests: 10, windowMs: 6e4 },
+  /** 30 requests per minute - for quote fetching */
+  QUOTE: { maxRequests: 30, windowMs: 6e4 },
+  /** 5 requests per minute - strict limit for sensitive operations */
+  STRICT: { maxRequests: 5, windowMs: 6e4 },
+  /** 100 requests per minute - permissive for UI interactions */
+  PERMISSIVE: { maxRequests: 100, windowMs: 6e4 }
+};
+var it = /* @__PURE__ */ ((r) => (r.CLOSED = "CLOSED", r.OPEN = "OPEN", r.HALF_OPEN = "HALF_OPEN", r))(it || {});
+class E extends Error {
+  constructor(e) {
+    super(e), this.name = "CircuitBreakerOpenError";
+  }
+}
+function $(r) {
+  const { failureThreshold: e, timeout: t, name: n = "circuit-breaker" } = r;
+  let a = "CLOSED", i = 0, o = 0, s = 0, u = null, l = null, d = null;
+  function f() {
+    a === "OPEN" && d !== null && Date.now() >= d && (c().debug(`[CircuitBreaker:${n}] Transitioning OPEN → HALF_OPEN (timeout expired)`), a = "HALF_OPEN", d = null);
+  }
+  function h() {
+    l = Date.now(), o++, a === "HALF_OPEN" ? (c().debug(`[CircuitBreaker:${n}] Success in HALF_OPEN → CLOSED`), a = "CLOSED", i = 0) : a === "CLOSED" && (i = 0);
+  }
+  function y(S) {
+    u = Date.now(), i++, c().warn(`[CircuitBreaker:${n}] Failure recorded (${i}/${e}):`, S.message), a === "HALF_OPEN" ? (c().warn(`[CircuitBreaker:${n}] Failed in HALF_OPEN → OPEN`), a = "OPEN", d = Date.now() + t) : a === "CLOSED" && i >= e && (c().error(`[CircuitBreaker:${n}] Failure threshold reached (${i}) → OPEN`), a = "OPEN", d = Date.now() + t);
+  }
+  async function p(S) {
+    if (f(), a === "OPEN") {
+      s++;
+      const g = d ? Math.ceil((d - Date.now()) / 1e3) : 0;
+      throw new E(
+        `Circuit breaker is OPEN. Service is unavailable. Retry in ${g}s.`
+      );
+    }
+    try {
+      const g = await S();
+      return h(), g;
+    } catch (g) {
+      throw y(g instanceof Error ? g : new Error(String(g))), g;
+    }
+  }
+  function m() {
+    return f(), a;
+  }
+  function P() {
+    return f(), {
+      state: a,
+      failures: i,
+      successes: o,
+      rejections: s,
+      lastFailureTime: u,
+      lastSuccessTime: l
+    };
+  }
+  function M() {
+    c().debug(`[CircuitBreaker:${n}] Manual reset → CLOSED`), a = "CLOSED", i = 0, o = 0, s = 0, u = null, l = null, d = null;
+  }
+  function T() {
+    c().warn(`[CircuitBreaker:${n}] Manual trip → OPEN`), a = "OPEN", d = Date.now() + t;
+  }
+  return {
+    execute: p,
+    getState: m,
+    getStats: P,
+    reset: M,
+    trip: T
+  };
+}
+const Xt = {
+  /** Strict: Opens quickly (3 failures), long timeout (60s) */
+  STRICT: { failureThreshold: 3, timeout: 6e4 },
+  /** Standard: Balanced settings (5 failures, 30s timeout) */
+  STANDARD: { failureThreshold: 5, timeout: 3e4 },
+  /** Lenient: Tolerates more failures (10 failures, 15s timeout) */
+  LENIENT: { failureThreshold: 10, timeout: 15e3 }
+};
+function ot(r, e) {
+  if (e >= 3)
+    return !1;
+  const t = r.message.toLowerCase();
+  return t.includes("network") || t.includes("timeout") || t.includes("fetch failed") || t.includes("econnrefused") || t.includes("503") || t.includes("502") || t.includes("500") || t.includes("429") ? !0 : (t.includes("400") || t.includes("401") || t.includes("403") || t.includes("404"), !1);
+}
+function st(r, e, t, n, a) {
+  const i = e * Math.pow(t, r), o = Math.min(i, n);
+  if (a) {
+    const s = Math.random() * o;
+    return Math.floor(s);
+  }
+  return Math.floor(o);
+}
+function ct(r) {
+  return new Promise((e) => setTimeout(e, r));
+}
+async function C(r, e = {}) {
+  const {
+    maxRetries: t = 3,
+    initialDelayMs: n = 1e3,
+    backoffFactor: a = 2,
+    maxDelayMs: i = 3e4,
+    jitter: o = !0,
+    shouldRetry: s = ot,
+    name: u = "retry"
+  } = e;
+  let l = null, d = 0;
+  for (let f = 0; f <= t; f++)
+    try {
+      const h = await r();
+      return f > 0 && c().debug(
+        `[Retry:${u}] Succeeded on attempt ${f + 1}/${t + 1} after ${d}ms`
+      ), h;
+    } catch (h) {
+      l = h instanceof Error ? h : new Error(String(h));
+      const y = f === t, p = s(l, f);
+      if (y || !p)
+        throw c().warn(
+          `[Retry:${u}] Failed on attempt ${f + 1}/${t + 1}. ${y ? "No more retries." : "Error not retryable."}`
+        ), l;
+      const m = st(f, n, a, i, o);
+      d += m, c().warn(
+        `[Retry:${u}] Attempt ${f + 1}/${t + 1} failed: ${l.message}. Retrying in ${m}ms...`
+      ), await ct(m);
+    }
+  throw l || new Error("Retry failed with no error");
+}
+const x = {
+  /** Quick retries for transient errors (3 retries, 1s initial, 2x backoff) */
+  QUICK: {
+    maxRetries: 3,
+    initialDelayMs: 1e3,
+    backoffFactor: 2,
+    maxDelayMs: 1e4
+  },
+  /** Standard retries (3 retries, 2s initial, 2x backoff) */
+  STANDARD: {
+    maxRetries: 3,
+    initialDelayMs: 2e3,
+    backoffFactor: 2,
+    maxDelayMs: 3e4
+  },
+  /** Aggressive retries for critical operations (5 retries, 500ms initial) */
+  AGGRESSIVE: {
+    maxRetries: 5,
+    initialDelayMs: 500,
+    backoffFactor: 1.5,
+    maxDelayMs: 15e3
+  },
+  /** Patient retries for slow backends (5 retries, 5s initial) */
+  PATIENT: {
+    maxRetries: 5,
+    initialDelayMs: 5e3,
+    backoffFactor: 2,
+    maxDelayMs: 6e4
+  }
+};
+class lt {
+  stripe = null;
+  publicKey;
+  routeDiscovery;
+  rateLimiter = R(A.PAYMENT);
+  circuitBreaker = $({
+    failureThreshold: 5,
+    timeout: 1e4,
+    // 10 seconds for faster recovery in payment flows
+    name: "stripe-manager"
+  });
+  constructor(e, t) {
+    this.publicKey = e, this.routeDiscovery = t;
+  }
+  /**
+   * Initialize Stripe.js library
+   */
+  async initialize() {
+    if (!this.stripe && (this.stripe = await ve(this.publicKey), !this.stripe))
+      throw new Error("Failed to initialize Stripe");
+  }
+  /**
+   * Create a Stripe checkout session
+   */
+  async createSession(e) {
+    if (!this.rateLimiter.tryConsume())
+      throw new Error("Rate limit exceeded for Stripe session creation. Please try again later.");
+    try {
+      return await this.circuitBreaker.execute(async () => await C(
+        async () => {
+          const t = await this.routeDiscovery.buildUrl("/paywall/v1/stripe-session");
+          c().debug("[StripeManager] Creating session with request:", e), e.couponCode ? c().debug("[StripeManager] Coupon code included:", e.couponCode) : c().debug("[StripeManager] No coupon code in request");
+          const n = await w(t, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Idempotency-Key": k()
+            },
+            body: JSON.stringify(e)
+          });
+          if (!n.ok) {
+            const a = await v(n, "Failed to create Stripe session");
+            throw new Error(a);
+          }
+          return n.json();
+        },
+        { ...x.STANDARD, name: "stripe-create-session" }
+      ));
+    } catch (t) {
+      throw t instanceof E ? (c().error("[StripeManager] Circuit breaker is OPEN - Stripe service unavailable"), new Error("Stripe payment service is temporarily unavailable. Please try again in a few moments.")) : t;
+    }
+  }
+  /**
+   * Redirect to Stripe checkout
+   */
+  async redirectToCheckout(e) {
+    if (this.stripe || await this.initialize(), !this.stripe)
+      return {
+        success: !1,
+        error: "Stripe not initialized"
+      };
+    const t = await this.stripe.redirectToCheckout({ sessionId: e });
+    return t.error ? {
+      success: !1,
+      error: t.error.message
+    } : { success: !0 };
+  }
+  /**
+   * Handle complete payment flow: create session and redirect
+   */
+  async processPayment(e) {
+    try {
+      const t = await this.createSession(e);
+      return await this.redirectToCheckout(t.sessionId);
+    } catch (t) {
+      return {
+        success: !1,
+        error: D(t, "Unknown error")
+      };
+    }
+  }
+  /**
+   * Create a Stripe cart checkout session for multiple items
+   */
+  async processCartCheckout(e) {
+    const { items: t, successUrl: n, cancelUrl: a, metadata: i, customerEmail: o, couponCode: s } = e;
+    if (!this.rateLimiter.tryConsume())
+      return {
+        success: !1,
+        error: "Rate limit exceeded for cart checkout. Please try again later."
+      };
+    try {
+      const u = await this.circuitBreaker.execute(async () => await C(
+        async () => {
+          const l = await this.routeDiscovery.buildUrl("/paywall/v1/cart/checkout"), d = {
+            items: t,
+            successUrl: n,
+            cancelUrl: a,
+            metadata: i,
+            customerEmail: o,
+            couponCode: s
+          }, f = await w(l, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Idempotency-Key": k()
+            },
+            body: JSON.stringify(d)
+          });
+          if (!f.ok) {
+            const h = await v(f, "Failed to create cart checkout session");
+            throw new Error(h);
+          }
+          return await f.json();
+        },
+        { ...x.STANDARD, name: "stripe-cart-checkout" }
+      ));
+      return await this.redirectToCheckout(u.sessionId);
+    } catch (u) {
+      return u instanceof E ? {
+        success: !1,
+        error: "Stripe payment service is temporarily unavailable. Please try again in a few moments."
+      } : {
+        success: !1,
+        error: D(u, "Cart checkout failed")
+      };
+    }
+  }
+}
+const Se = "3.7.8", ut = Se, O = typeof Buffer == "function", oe = typeof TextDecoder == "function" ? new TextDecoder() : void 0, se = typeof TextEncoder == "function" ? new TextEncoder() : void 0, dt = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=", F = Array.prototype.slice.call(dt), K = ((r) => {
+  let e = {};
+  return r.forEach((t, n) => e[t] = n), e;
+})(F), ft = /^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/, b = String.fromCharCode.bind(String), ce = typeof Uint8Array.from == "function" ? Uint8Array.from.bind(Uint8Array) : (r) => new Uint8Array(Array.prototype.slice.call(r, 0)), Ce = (r) => r.replace(/=/g, "").replace(/[+\/]/g, (e) => e == "+" ? "-" : "_"), xe = (r) => r.replace(/[^A-Za-z0-9\+\/]/g, ""), Pe = (r) => {
+  let e, t, n, a, i = "";
+  const o = r.length % 3;
+  for (let s = 0; s < r.length; ) {
+    if ((t = r.charCodeAt(s++)) > 255 || (n = r.charCodeAt(s++)) > 255 || (a = r.charCodeAt(s++)) > 255)
+      throw new TypeError("invalid character found");
+    e = t << 16 | n << 8 | a, i += F[e >> 18 & 63] + F[e >> 12 & 63] + F[e >> 6 & 63] + F[e & 63];
+  }
+  return o ? i.slice(0, o - 3) + "===".substring(o) : i;
+}, re = typeof btoa == "function" ? (r) => btoa(r) : O ? (r) => Buffer.from(r, "binary").toString("base64") : Pe, Z = O ? (r) => Buffer.from(r).toString("base64") : (r) => {
+  let t = [];
+  for (let n = 0, a = r.length; n < a; n += 4096)
+    t.push(b.apply(null, r.subarray(n, n + 4096)));
+  return re(t.join(""));
+}, V = (r, e = !1) => e ? Ce(Z(r)) : Z(r), ht = (r) => {
+  if (r.length < 2) {
+    var e = r.charCodeAt(0);
+    return e < 128 ? r : e < 2048 ? b(192 | e >>> 6) + b(128 | e & 63) : b(224 | e >>> 12 & 15) + b(128 | e >>> 6 & 63) + b(128 | e & 63);
+  } else {
+    var e = 65536 + (r.charCodeAt(0) - 55296) * 1024 + (r.charCodeAt(1) - 56320);
+    return b(240 | e >>> 18 & 7) + b(128 | e >>> 12 & 63) + b(128 | e >>> 6 & 63) + b(128 | e & 63);
+  }
+}, pt = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g, Te = (r) => r.replace(pt, ht), le = O ? (r) => Buffer.from(r, "utf8").toString("base64") : se ? (r) => Z(se.encode(r)) : (r) => re(Te(r)), U = (r, e = !1) => e ? Ce(le(r)) : le(r), ue = (r) => U(r, !0), yt = /[\xC0-\xDF][\x80-\xBF]|[\xE0-\xEF][\x80-\xBF]{2}|[\xF0-\xF7][\x80-\xBF]{3}/g, mt = (r) => {
+  switch (r.length) {
+    case 4:
+      var e = (7 & r.charCodeAt(0)) << 18 | (63 & r.charCodeAt(1)) << 12 | (63 & r.charCodeAt(2)) << 6 | 63 & r.charCodeAt(3), t = e - 65536;
+      return b((t >>> 10) + 55296) + b((t & 1023) + 56320);
+    case 3:
+      return b((15 & r.charCodeAt(0)) << 12 | (63 & r.charCodeAt(1)) << 6 | 63 & r.charCodeAt(2));
+    default:
+      return b((31 & r.charCodeAt(0)) << 6 | 63 & r.charCodeAt(1));
+  }
+}, Re = (r) => r.replace(yt, mt), ke = (r) => {
+  if (r = r.replace(/\s+/g, ""), !ft.test(r))
+    throw new TypeError("malformed base64.");
+  r += "==".slice(2 - (r.length & 3));
+  let e, t, n, a = [];
+  for (let i = 0; i < r.length; )
+    e = K[r.charAt(i++)] << 18 | K[r.charAt(i++)] << 12 | (t = K[r.charAt(i++)]) << 6 | (n = K[r.charAt(i++)]), t === 64 ? a.push(b(e >> 16 & 255)) : n === 64 ? a.push(b(e >> 16 & 255, e >> 8 & 255)) : a.push(b(e >> 16 & 255, e >> 8 & 255, e & 255));
+  return a.join("");
+}, ne = typeof atob == "function" ? (r) => atob(xe(r)) : O ? (r) => Buffer.from(r, "base64").toString("binary") : ke, Ae = O ? (r) => ce(Buffer.from(r, "base64")) : (r) => ce(ne(r).split("").map((e) => e.charCodeAt(0))), Me = (r) => Ae(Ue(r)), wt = O ? (r) => Buffer.from(r, "base64").toString("utf8") : oe ? (r) => oe.decode(Ae(r)) : (r) => Re(ne(r)), Ue = (r) => xe(r.replace(/[-_]/g, (e) => e == "-" ? "+" : "/")), ee = (r) => wt(Ue(r)), gt = (r) => {
+  if (typeof r != "string")
+    return !1;
+  const e = r.replace(/\s+/g, "").replace(/={0,2}$/, "");
+  return !/[^\s0-9a-zA-Z\+/]/.test(e) || !/[^\s0-9a-zA-Z\-_]/.test(e);
+}, De = (r) => ({
+  value: r,
+  enumerable: !1,
+  writable: !0,
+  configurable: !0
+}), Oe = function() {
+  const r = (e, t) => Object.defineProperty(String.prototype, e, De(t));
+  r("fromBase64", function() {
+    return ee(this);
+  }), r("toBase64", function(e) {
+    return U(this, e);
+  }), r("toBase64URI", function() {
+    return U(this, !0);
+  }), r("toBase64URL", function() {
+    return U(this, !0);
+  }), r("toUint8Array", function() {
+    return Me(this);
+  });
+}, Ne = function() {
+  const r = (e, t) => Object.defineProperty(Uint8Array.prototype, e, De(t));
+  r("toBase64", function(e) {
+    return V(this, e);
+  }), r("toBase64URI", function() {
+    return V(this, !0);
+  }), r("toBase64URL", function() {
+    return V(this, !0);
+  });
+}, bt = () => {
+  Oe(), Ne();
+}, j = {
+  version: Se,
+  VERSION: ut,
+  atob: ne,
+  atobPolyfill: ke,
+  btoa: re,
+  btoaPolyfill: Pe,
+  fromBase64: ee,
+  toBase64: U,
+  encode: U,
+  encodeURI: ue,
+  encodeURL: ue,
+  utob: Te,
+  btou: Re,
+  decode: ee,
+  isValid: gt,
+  fromUint8Array: V,
+  toUint8Array: Me,
+  extendString: Oe,
+  extendUint8Array: Ne,
+  extendBuiltins: bt
+};
+class vt {
+  routeDiscovery;
+  quoteRateLimiter = R(A.QUOTE);
+  verifyRateLimiter = R(A.PAYMENT);
+  circuitBreaker = $({
+    failureThreshold: 5,
+    timeout: 1e4,
+    // 10 seconds for faster recovery in payment flows
+    name: "x402-manager"
+  });
+  constructor(e) {
+    this.routeDiscovery = e;
+  }
+  /**
+   * Request a protected resource and get x402 requirement
+   * SECURITY: Resource ID and coupon codes sent in request body to prevent leakage
+   * Prevents exposure of product IDs, SKUs, and business-sensitive identifiers in logs
+   */
+  async requestQuote(e) {
+    const { resource: t, couponCode: n } = e;
+    if (!this.quoteRateLimiter.tryConsume())
+      throw new Error("Rate limit exceeded for quote requests. Please try again later.");
+    try {
+      return await this.circuitBreaker.execute(async () => await C(
+        async () => {
+          const a = "/paywall/v1/quote";
+          c().debug(
+            "[X402Manager] Requesting quote",
+            n ? "with coupon" : "without coupon"
+          );
+          const i = await this.routeDiscovery.buildUrl(a), o = await w(i, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              resource: t,
+              couponCode: n || null
+            })
+          });
+          if (o.status !== 402)
+            throw new Error(`Expected 402 status, got ${o.status}`);
+          const s = await o.json();
+          if (!s.accepts || s.accepts.length === 0)
+            throw new Error("Invalid x402 response: missing accepts array");
+          return s.accepts[0];
+        },
+        { ...x.QUICK, name: "x402-quote" }
+      ));
+    } catch (a) {
+      throw a instanceof E ? (c().error("[X402Manager] Circuit breaker is OPEN - x402 service unavailable"), new Error("Payment service is temporarily unavailable. Please try again in a few moments.")) : a;
+    }
+  }
+  /**
+   * Request a cart quote for multiple items
+   */
+  async requestCartQuote(e) {
+    const { items: t, metadata: n, couponCode: a } = e;
+    if (!this.quoteRateLimiter.tryConsume())
+      throw new Error("Rate limit exceeded for cart quote requests. Please try again later.");
+    try {
+      return await this.circuitBreaker.execute(async () => await C(
+        async () => {
+          const i = await this.routeDiscovery.buildUrl("/paywall/v1/cart/quote"), o = {
+            items: t,
+            metadata: n,
+            couponCode: a
+          }, s = await w(i, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Idempotency-Key": k()
+            },
+            body: JSON.stringify(o)
+          });
+          if (s.status !== 402 && !s.ok) {
+            const u = await v(s, "Failed to get cart quote");
+            throw new Error(u);
+          }
+          return s.json();
+        },
+        { ...x.QUICK, name: "x402-cart-quote" }
+      ));
+    } catch (i) {
+      throw i instanceof E ? (c().error("[X402Manager] Circuit breaker is OPEN - cart quote service unavailable"), new Error("Payment service is temporarily unavailable. Please try again in a few moments.")) : i;
+    }
+  }
+  /**
+   * Build X-PAYMENT header from payment payload (base64 encoded)
+   */
+  buildPaymentHeader(e) {
+    const t = JSON.stringify(e);
+    return j.encode(t);
+  }
+  /**
+   * Parse X-PAYMENT-RESPONSE header (base64 encoded settlement response)
+   */
+  parseSettlementResponse(e) {
+    const t = e.headers.get("X-PAYMENT-RESPONSE");
+    if (!t)
+      return null;
+    try {
+      const n = j.decode(t), a = JSON.parse(n);
+      return typeof a.success != "boolean" ? (c().error("Invalid settlement response: missing success field"), null) : a;
+    } catch (n) {
+      return c().error("Failed to parse settlement response:", n), null;
+    }
+  }
+  /**
+   * Retry request with payment proof
+   * SECURITY: Coupon and metadata sent in X-PAYMENT header payload, NOT query strings
+   */
+  async submitPayment(e) {
+    const {
+      resource: t,
+      payload: n,
+      couponCode: a,
+      metadata: i,
+      resourceType: o = "regular"
+    } = e;
+    if (!this.verifyRateLimiter.tryConsume())
+      return {
+        success: !1,
+        error: "Rate limit exceeded for payment verification. Please try again later."
+      };
+    try {
+      return await this.circuitBreaker.execute(async () => await C(
+        async () => {
+          const u = {
+            ...n,
+            payload: {
+              ...n.payload,
+              resource: t,
+              resourceType: o,
+              metadata: {
+                ...n.payload.metadata || {},
+                // Preserve existing metadata
+                ...i || {},
+                // Layer in new metadata
+                ...a ? { couponCode: a } : {}
+                // Add coupon if present
+              }
+            }
+          }, l = this.buildPaymentHeader(u), d = "/paywall/v1/verify";
+          c().debug("[X402Manager] Submitting payment", {
+            resourceType: o,
+            hasCoupon: !!a,
+            hasMetadata: !!i
+          });
+          const f = await this.routeDiscovery.buildUrl(d), h = await w(f, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "X-PAYMENT": l,
+              "Idempotency-Key": k()
+            }
+          });
+          if (h.ok) {
+            const { settlement: p, transactionId: m } = await this.handlePaymentVerification(
+              h,
+              n.payload.signature
+            );
+            return {
+              success: !0,
+              transactionId: m,
+              settlement: p || void 0
+            };
+          }
+          return {
+            success: !1,
+            error: await v(h, "Payment verification failed", !0)
+          };
+        },
+        { ...x.STANDARD, name: "x402-verify" }
+      ));
+    } catch (s) {
+      return s instanceof E ? {
+        success: !1,
+        error: "Payment verification service is temporarily unavailable. Please try again in a few moments."
+      } : {
+        success: !1,
+        error: D(s, "Unknown error")
+      };
+    }
+  }
+  /**
+   * Build a complete gasless transaction on the backend
+   * Returns an unsigned transaction with all instructions (compute budget, transfer, memo)
+   */
+  async buildGaslessTransaction(e) {
+    const { resourceId: t, userWallet: n, feePayer: a, couponCode: i } = e;
+    if (!this.quoteRateLimiter.tryConsume())
+      throw new Error("Rate limit exceeded for gasless transaction requests. Please try again later.");
+    try {
+      return await this.circuitBreaker.execute(async () => await C(
+        async () => {
+          const o = await this.routeDiscovery.buildUrl(
+            "/paywall/v1/gasless-transaction"
+          ), s = await w(o, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              resourceId: t,
+              userWallet: n,
+              feePayer: a,
+              couponCode: i
+            })
+          });
+          if (!s.ok) {
+            const u = await v(s, "Failed to build gasless transaction");
+            throw new Error(u);
+          }
+          return s.json();
+        },
+        { ...x.QUICK, name: "x402-gasless-build" }
+      ));
+    } catch (o) {
+      throw o instanceof E ? (c().error("[X402Manager] Circuit breaker is OPEN - gasless transaction service unavailable"), new Error("Gasless transaction service is temporarily unavailable. Please try again in a few moments.")) : o;
+    }
+  }
+  /**
+   * Submit gasless partial transaction for co-signing
+   * Sends the partially-signed transaction in X-Payment header for backend co-signing
+   * SECURITY: Coupon and metadata sent in X-PAYMENT header payload, NOT query strings
+   */
+  async submitGaslessTransaction(e) {
+    const {
+      resource: t,
+      partialTx: n,
+      couponCode: a,
+      metadata: i,
+      resourceType: o = "regular",
+      requirement: s
+    } = e;
+    if (!this.verifyRateLimiter.tryConsume())
+      return {
+        success: !1,
+        error: "Rate limit exceeded for gasless transaction verification. Please try again later."
+      };
+    try {
+      return await this.circuitBreaker.execute(async () => await C(
+        async () => {
+          const l = {
+            x402Version: 0,
+            scheme: s?.scheme || "solana-spl-transfer",
+            network: s?.network || "mainnet-beta",
+            payload: {
+              signature: "",
+              // Placeholder - backend will finalize after co-signing
+              transaction: n,
+              feePayer: s?.extra?.feePayer || "",
+              resource: t,
+              resourceType: o,
+              metadata: {
+                ...i || {},
+                ...a ? { couponCode: a } : {}
+              }
+            }
+          }, d = this.buildPaymentHeader(l), h = await this.routeDiscovery.buildUrl("/paywall/v1/verify"), y = await w(h, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "X-PAYMENT": d,
+              "Idempotency-Key": k()
+            }
+          });
+          if (y.ok) {
+            const { settlement: m, transactionId: P } = await this.handlePaymentVerification(
+              y,
+              "gasless-tx"
+            );
+            return {
+              success: !0,
+              transactionId: P,
+              settlement: m || void 0
+            };
+          }
+          return {
+            success: !1,
+            error: await v(y, "Gasless transaction failed", !0)
+          };
+        },
+        { ...x.STANDARD, name: "x402-gasless-verify" }
+      ));
+    } catch (u) {
+      return u instanceof E ? {
+        success: !1,
+        error: "Gasless transaction verification service is temporarily unavailable. Please try again in a few moments."
+      } : {
+        success: !1,
+        error: D(u, "Unknown error")
+      };
+    }
+  }
+  /**
+   * Handle payment verification response (shared logic for both submitPayment and submitGaslessTransaction)
+   * Parses settlement header and extracts transaction ID from response body
+   * @param response - HTTP response from payment verification endpoint
+   * @param defaultTxId - Fallback transaction ID if JSON parsing fails
+   * @returns Settlement data and transaction ID
+   */
+  async handlePaymentVerification(e, t) {
+    const n = this.parseSettlementResponse(e), a = e.headers.get("Content-Type") || "";
+    let i = t;
+    if (a.includes("application/json"))
+      try {
+        i = (await e.json()).signature || t;
+      } catch (o) {
+        c().warn("Failed to parse JSON response body:", o);
+      }
+    return { settlement: n, transactionId: i };
+  }
+  /**
+   * Validate x402 requirement structure
+   */
+  validateRequirement(e) {
+    return !!(e.scheme && e.network && e.maxAmountRequired && e.resource && e.payTo && e.asset && e.maxTimeoutSeconds > 0);
+  }
+}
+function Et(r) {
+  if (r.length >= 255)
+    throw new TypeError("Alphabet too long");
+  const e = new Uint8Array(256);
+  for (let l = 0; l < e.length; l++)
+    e[l] = 255;
+  for (let l = 0; l < r.length; l++) {
+    const d = r.charAt(l), f = d.charCodeAt(0);
+    if (e[f] !== 255)
+      throw new TypeError(d + " is ambiguous");
+    e[f] = l;
+  }
+  const t = r.length, n = r.charAt(0), a = Math.log(t) / Math.log(256), i = Math.log(256) / Math.log(t);
+  function o(l) {
+    if (l instanceof Uint8Array || (ArrayBuffer.isView(l) ? l = new Uint8Array(l.buffer, l.byteOffset, l.byteLength) : Array.isArray(l) && (l = Uint8Array.from(l))), !(l instanceof Uint8Array))
+      throw new TypeError("Expected Uint8Array");
+    if (l.length === 0)
+      return "";
+    let d = 0, f = 0, h = 0;
+    const y = l.length;
+    for (; h !== y && l[h] === 0; )
+      h++, d++;
+    const p = (y - h) * i + 1 >>> 0, m = new Uint8Array(p);
+    for (; h !== y; ) {
+      let T = l[h], S = 0;
+      for (let g = p - 1; (T !== 0 || S < f) && g !== -1; g--, S++)
+        T += 256 * m[g] >>> 0, m[g] = T % t >>> 0, T = T / t >>> 0;
+      if (T !== 0)
+        throw new Error("Non-zero carry");
+      f = S, h++;
+    }
+    let P = p - f;
+    for (; P !== p && m[P] === 0; )
+      P++;
+    let M = n.repeat(d);
+    for (; P < p; ++P)
+      M += r.charAt(m[P]);
+    return M;
+  }
+  function s(l) {
+    if (typeof l != "string")
+      throw new TypeError("Expected String");
+    if (l.length === 0)
+      return new Uint8Array();
+    let d = 0, f = 0, h = 0;
+    for (; l[d] === n; )
+      f++, d++;
+    const y = (l.length - d) * a + 1 >>> 0, p = new Uint8Array(y);
+    for (; d < l.length; ) {
+      const T = l.charCodeAt(d);
+      if (T > 255)
+        return;
+      let S = e[T];
+      if (S === 255)
+        return;
+      let g = 0;
+      for (let _ = y - 1; (S !== 0 || g < h) && _ !== -1; _--, g++)
+        S += t * p[_] >>> 0, p[_] = S % 256 >>> 0, S = S / 256 >>> 0;
+      if (S !== 0)
+        throw new Error("Non-zero carry");
+      h = g, d++;
+    }
+    let m = y - h;
+    for (; m !== y && p[m] === 0; )
+      m++;
+    const P = new Uint8Array(f + (y - m));
+    let M = f;
+    for (; m !== y; )
+      P[M++] = p[m++];
+    return P;
+  }
+  function u(l) {
+    const d = s(l);
+    if (d)
+      return d;
+    throw new Error("Non-base" + t + " character");
+  }
+  return {
+    encode: o,
+    decodeUnsafe: s,
+    decode: u
+  };
+}
+var St = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const de = Et(St), te = {
+  CASHx9KJUStyftLFWGvEVf59SGeG9sh5FfcnZMVPCASH: "CASH",
+  EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v: "USDC",
+  Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB: "USDT",
+  "2b1kV6DkPAnxd5ixfnxCpjxmKwqjjaYmCZfHsFu24GXo": "PYUSD"
+};
+function Ct(r) {
+  return r in te;
+}
+function Be(r, e = "token mint", t = !1) {
+  if (!r || r.trim().length === 0)
+    return {
+      isValid: !0,
+      isKnownStablecoin: !1
+    };
+  const n = r.trim();
+  if (Ct(n))
+    return {
+      isValid: !0,
+      isKnownStablecoin: !0,
+      symbol: te[n]
+    };
+  const a = Object.entries(te).map(([i, o]) => `  ${o}: ${i}`).join(`
+`);
+  return t ? {
+    isValid: !0,
+    // Allow but warn
+    isKnownStablecoin: !1,
+    warning: [
+      `Warning: Unrecognized token mint address in ${e}`,
+      `  Provided: ${n}`,
+      "",
+      "This token mint does not match any known stablecoin addresses.",
+      "You have set dangerouslyAllowUnknownMint=true, so this will proceed.",
+      "If this is a typo, payments will be sent to the wrong token and funds will be PERMANENTLY LOST.",
+      "",
+      "Known stablecoin mints (mainnet-beta):",
+      a,
+      "",
+      "Double-check your token mint address before deploying to production."
+    ].join(`
+`)
+  } : {
+    isValid: !1,
+    isKnownStablecoin: !1,
+    error: [
+      `SAFETY ERROR: Unrecognized token mint address in ${e}`,
+      `  Provided: ${n}`,
+      "",
+      "This token mint does not match any known stablecoin addresses.",
+      "Using an unknown token mint can result in PERMANENT LOSS OF FUNDS if it's a typo.",
+      "",
+      "Known stablecoin mints (mainnet-beta):",
+      a,
+      "",
+      "If you are CERTAIN this is the correct mint address (custom token, testnet, or new stablecoin),",
+      "set dangerouslyAllowUnknownMint={true} in your CedrosProvider config:",
+      "",
+      "  <CedrosProvider",
+      "    config={{",
+      "      ...",
+      '      tokenMint: "' + n + '",',
+      "      dangerouslyAllowUnknownMint: true, // ⚠️ I have verified this mint address",
+      "    }}",
+      "  />",
+      "",
+      "⚠️ WARNING: Only enable dangerouslyAllowUnknownMint if you have TRIPLE-CHECKED the mint address."
+    ].join(`
+`)
+  };
+}
+function xt(r, e = "unknown", t = !1) {
+  return Be(r, `X402Requirement (resource: ${e})`, t);
+}
+class Pt {
+  connection;
+  cluster;
+  endpoint;
+  allowUnknownMint;
+  rpcRateLimiter = R({
+    maxRequests: 50,
+    windowMs: 6e4
+    // 50 requests per minute for RPC calls
+  });
+  rpcCircuitBreaker = $({
+    failureThreshold: 5,
+    timeout: 1e4,
+    // 10 seconds for faster recovery in payment flows
+    name: "solana-rpc"
+  });
+  constructor(e = "mainnet-beta", t, n = !1) {
+    this.cluster = e, this.endpoint = t, this.allowUnknownMint = n, this.connection = this.createConnection();
+  }
+  /**
+   * Create Solana RPC connection
+   */
+  createConnection() {
+    const e = this.endpoint ?? je(this.cluster);
+    return new $e(e, "confirmed");
+  }
+  /**
+   * Transform RPC errors into user-friendly messages
+   */
+  transformRpcError(e) {
+    const t = e instanceof Error ? e.message : typeof e == "string" ? e : String(e);
+    return t.includes("403") || t.includes("Access forbidden") ? new Error(
+      "Public Solana RPC access denied. Please configure a custom RPC endpoint (e.g., from Helius, QuickNode, or Alchemy) in your CedrosProvider config using the solanaEndpoint option."
+    ) : t.includes("429") || t.includes("Too Many Requests") ? new Error(
+      "Solana RPC rate limit exceeded. Please configure a custom RPC endpoint with higher limits in your CedrosProvider config using the solanaEndpoint option."
+    ) : e instanceof Error ? e : new Error(t);
+  }
+  /**
+   * Build transaction from x402 requirement
+   */
+  async buildTransaction(e) {
+    const { requirement: t, payerPublicKey: n, blockhash: a } = e;
+    if (!t || !t.payTo)
+      throw new Error("Invalid requirement: missing payTo");
+    console.log("🔨 [WalletManager] Building NEW transaction for resource:", t.resource);
+    const i = new ae(), o = this.resolveAmountInMinorUnits(t), s = t.asset;
+    if (!s)
+      throw new Error("asset is required in x402 requirement");
+    const u = xt(s, t.resource, this.allowUnknownMint);
+    if (!u.isValid && u.error)
+      throw new Error(u.error);
+    u.warning && c().warn(u.warning);
+    const l = new N(s), d = await We(
+      l,
+      n
+    );
+    if (!this.rpcRateLimiter.tryConsume())
+      throw new Error("RPC rate limit exceeded. Please try again in a moment.");
+    let f;
+    try {
+      f = await this.rpcCircuitBreaker.execute(async () => await C(
+        async () => await this.connection.getAccountInfo(d),
+        { ...x.QUICK, name: "rpc-get-account-info" }
+      ));
+    } catch (p) {
+      throw p instanceof E ? new Error("Solana RPC service is temporarily unavailable. Please try again in a few moments.") : this.transformRpcError(p);
+    }
+    if (!f)
+      throw new Error("Payer is missing an associated token account for this mint");
+    let h;
+    try {
+      h = t.extra?.recipientTokenAccount ? new N(t.extra.recipientTokenAccount) : new N(t.payTo);
+    } catch {
+      throw new Error("We are currently unable to process payment, please try again later");
+    }
+    if (i.add(
+      qe(
+        d,
+        h,
+        n,
+        o
+      )
+    ), t.extra?.memo) {
+      const { TransactionInstruction: p } = await import("@solana/web3.js"), m = new p({
+        keys: [],
+        programId: new N("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr"),
+        data: Buffer.from(t.extra.memo, "utf8")
+      });
+      i.add(m);
+    }
+    let y;
+    if (a)
+      y = a;
+    else {
+      if (!this.rpcRateLimiter.tryConsume())
+        throw new Error("RPC rate limit exceeded. Please try again in a moment.");
+      try {
+        y = (await this.rpcCircuitBreaker.execute(async () => await C(
+          async () => await this.connection.getLatestBlockhash(),
+          { ...x.QUICK, name: "rpc-get-blockhash" }
+        ))).blockhash;
+      } catch (p) {
+        throw p instanceof E ? new Error("Solana RPC service is temporarily unavailable. Please try again in a few moments.") : this.transformRpcError(p);
+      }
+    }
+    return i.recentBlockhash = y, t.extra?.feePayer ? i.feePayer = new N(t.extra.feePayer) : i.feePayer = n, i;
+  }
+  /**
+   * Parse amount from x402 requirement (already in atomic units as string)
+   */
+  resolveAmountInMinorUnits(e) {
+    const t = parseInt(e.maxAmountRequired, 10);
+    if (Number.isNaN(t) || t <= 0)
+      throw new Error("Invalid maxAmountRequired in requirement");
+    return t;
+  }
+  /**
+   * Build payment payload from signed transaction (x402 spec)
+   */
+  buildPaymentPayload(e) {
+    const { requirement: t, signedTx: n, payerPublicKey: a } = e;
+    return {
+      x402Version: 0,
+      scheme: t.scheme,
+      network: t.network,
+      payload: {
+        signature: n.signature,
+        transaction: n.serialized,
+        payer: a.toString(),
+        memo: t.extra?.memo,
+        recipientTokenAccount: t.extra?.recipientTokenAccount
+      }
+    };
+  }
+  /**
+   * Sign transaction using wallet adapter (fully signed for regular mode)
+   */
+  async signTransaction(e) {
+    const { transaction: t, signTransaction: n } = e;
+    console.log("✍️ [WalletManager] Requesting wallet to sign transaction");
+    const a = await n(t), i = a.serialize(), o = a.signatures[0]?.signature;
+    if (!o)
+      throw new Error("Signed transaction missing signature");
+    const s = de.encode(o);
+    return console.log("✅ [WalletManager] Transaction signed with signature:", s.substring(0, 20) + "..."), {
+      serialized: j.fromUint8Array(i),
+      signature: s
+    };
+  }
+  /**
+   * Deserialize a base64-encoded transaction from the backend
+   * Used for gasless flow where backend builds the complete transaction
+   */
+  deserializeTransaction(e) {
+    try {
+      const t = j.toUint8Array(e);
+      return ae.from(t);
+    } catch (t) {
+      throw new Error(
+        `Failed to deserialize transaction: ${D(t, "Unknown error")}`
+      );
+    }
+  }
+  /**
+   * Partially sign transaction for gasless mode
+   * User signs their authority, server will co-sign as fee payer
+   */
+  async partiallySignTransaction(e) {
+    const { transaction: t, signTransaction: n, blockhash: a } = e;
+    a && t.recentBlockhash !== a && (t.recentBlockhash = a);
+    const i = await n(t), o = i.signatures[0]?.signature;
+    if (o) {
+      const u = de.encode(o);
+      console.log("✅ [WalletManager] Partially signed with signature:", u.substring(0, 20) + "...");
+    }
+    const s = i.serialize({
+      requireAllSignatures: !1,
+      verifySignatures: !1
+    });
+    return j.fromUint8Array(s);
+  }
+  /**
+   * Get wallet balance
+   */
+  async getBalance(e) {
+    if (!this.rpcRateLimiter.tryConsume())
+      throw new Error("RPC rate limit exceeded. Please try again in a moment.");
+    try {
+      return await this.rpcCircuitBreaker.execute(async () => await C(
+        async () => await this.connection.getBalance(e),
+        { ...x.QUICK, name: "rpc-get-balance" }
+      )) / _e;
+    } catch (t) {
+      throw t instanceof E ? new Error("Solana RPC service is temporarily unavailable. Please try again in a few moments.") : this.transformRpcError(t);
+    }
+  }
+  /**
+   * Verify transaction on-chain
+   */
+  async verifyTransaction(e) {
+    if (!this.rpcRateLimiter.tryConsume())
+      return c().warn("[WalletManager] RPC rate limit exceeded for transaction verification"), !1;
+    try {
+      return !!(await this.rpcCircuitBreaker.execute(async () => await C(
+        async () => await this.connection.getSignatureStatus(e),
+        { ...x.QUICK, name: "rpc-verify-tx" }
+      ))).value?.confirmationStatus;
+    } catch (t) {
+      return t instanceof E && c().warn("[WalletManager] Circuit breaker OPEN - cannot verify transaction"), !1;
+    }
+  }
+}
+class Tt {
+  stripe = null;
+  publicKey;
+  routeDiscovery;
+  // Separate rate limiters for different operation types
+  sessionRateLimiter = R(A.PAYMENT);
+  statusRateLimiter = R(A.QUOTE);
+  circuitBreaker = $({
+    failureThreshold: 5,
+    timeout: 1e4,
+    // 10 seconds for faster recovery
+    name: "subscription-manager"
+  });
+  constructor(e, t) {
+    this.publicKey = e, this.routeDiscovery = t;
+  }
+  /** Initialize Stripe.js library */
+  async initialize() {
+    if (!this.stripe && (this.stripe = await ve(this.publicKey), !this.stripe))
+      throw new Error("Failed to initialize Stripe");
+  }
+  /** Internal helper: execute with rate limiting, circuit breaker, and retry */
+  async executeWithResilience(e, t, n, a) {
+    if (!e.tryConsume())
+      throw new Error("Rate limit exceeded. Please try again later.");
+    try {
+      return await this.circuitBreaker.execute(
+        () => C(t, { ...x.STANDARD, name: n })
+      );
+    } catch (i) {
+      throw i instanceof E ? (c().error(`[SubscriptionManager] Circuit breaker OPEN for ${a}`), new Error("Service temporarily unavailable. Please try again in a few moments.")) : i;
+    }
+  }
+  /**
+   * Create a Stripe subscription checkout session
+   */
+  async createSubscriptionSession(e) {
+    if (!this.sessionRateLimiter.tryConsume())
+      throw new Error("Rate limit exceeded for subscription session creation. Please try again later.");
+    try {
+      return await this.circuitBreaker.execute(async () => await C(
+        async () => {
+          const t = await this.routeDiscovery.buildUrl("/paywall/v1/subscription/stripe-session");
+          c().debug("[SubscriptionManager] Creating subscription session:", {
+            resource: e.resource,
+            interval: e.interval,
+            trialDays: e.trialDays
+          });
+          const n = await w(t, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Idempotency-Key": k()
+            },
+            body: JSON.stringify(e)
+          });
+          if (!n.ok) {
+            const a = await v(
+              n,
+              "Failed to create subscription session"
+            );
+            throw new Error(a);
+          }
+          return n.json();
+        },
+        { ...x.STANDARD, name: "subscription-create-session" }
+      ));
+    } catch (t) {
+      throw t instanceof E ? (c().error("[SubscriptionManager] Circuit breaker is OPEN - service unavailable"), new Error(
+        "Subscription service is temporarily unavailable. Please try again in a few moments."
+      )) : t;
+    }
+  }
+  /**
+   * Redirect to Stripe checkout
+   */
+  async redirectToCheckout(e) {
+    if (this.stripe || await this.initialize(), !this.stripe)
+      return {
+        success: !1,
+        error: "Stripe not initialized"
+      };
+    const t = await this.stripe.redirectToCheckout({ sessionId: e });
+    return t.error ? {
+      success: !1,
+      error: t.error.message
+    } : { success: !0, transactionId: e };
+  }
+  /**
+   * Complete subscription flow: create session and redirect
+   */
+  async processSubscription(e) {
+    try {
+      const t = await this.createSubscriptionSession(e);
+      return await this.redirectToCheckout(t.sessionId);
+    } catch (t) {
+      return {
+        success: !1,
+        error: D(t, "Subscription failed")
+      };
+    }
+  }
+  /**
+   * Check subscription status (for x402 gating)
+   */
+  async checkSubscriptionStatus(e) {
+    if (!this.statusRateLimiter.tryConsume())
+      throw new Error("Rate limit exceeded for subscription status check. Please try again later.");
+    try {
+      return await this.circuitBreaker.execute(async () => await C(
+        async () => {
+          const t = new URLSearchParams({
+            resource: e.resource,
+            userId: e.userId
+          }), n = await this.routeDiscovery.buildUrl(
+            `/paywall/v1/subscription/status?${t.toString()}`
+          );
+          c().debug("[SubscriptionManager] Checking subscription status:", e);
+          const a = await w(n, {
+            method: "GET",
+            headers: {
+              "Content-Type": "application/json"
+            }
+          });
+          if (!a.ok) {
+            const i = await v(
+              a,
+              "Failed to check subscription status"
+            );
+            throw new Error(i);
+          }
+          return a.json();
+        },
+        { ...x.STANDARD, name: "subscription-status-check" }
+      ));
+    } catch (t) {
+      throw t instanceof E ? (c().error("[SubscriptionManager] Circuit breaker is OPEN for status check"), new Error(
+        "Subscription status service is temporarily unavailable. Please try again in a few moments."
+      )) : t;
+    }
+  }
+  /**
+   * Request a subscription quote for x402 crypto payment
+   */
+  async requestSubscriptionQuote(e, t, n) {
+    if (!this.statusRateLimiter.tryConsume())
+      throw new Error("Rate limit exceeded for subscription quote. Please try again later.");
+    try {
+      return await this.circuitBreaker.execute(async () => await C(
+        async () => {
+          const a = await this.routeDiscovery.buildUrl("/paywall/v1/subscription/quote"), i = {
+            resource: e,
+            interval: t,
+            couponCode: n?.couponCode,
+            intervalDays: n?.intervalDays
+          };
+          c().debug("[SubscriptionManager] Requesting subscription quote:", i);
+          const o = await w(a, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify(i)
+          });
+          if (o.status !== 402 && !o.ok) {
+            const s = await v(
+              o,
+              "Failed to get subscription quote"
+            );
+            throw new Error(s);
+          }
+          return o.json();
+        },
+        { ...x.STANDARD, name: "subscription-quote" }
+      ));
+    } catch (a) {
+      throw a instanceof E ? (c().error("[SubscriptionManager] Circuit breaker is OPEN for quote"), new Error(
+        "Subscription quote service is temporarily unavailable. Please try again in a few moments."
+      )) : a;
+    }
+  }
+  /** Cancel a subscription */
+  async cancelSubscription(e) {
+    return this.executeWithResilience(
+      this.sessionRateLimiter,
+      async () => {
+        const t = await this.routeDiscovery.buildUrl("/paywall/v1/subscription/cancel");
+        c().debug("[SubscriptionManager] Canceling subscription:", e);
+        const n = await w(t, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(e)
+        });
+        if (!n.ok) throw new Error(await v(n, "Failed to cancel"));
+        return n.json();
+      },
+      "subscription-cancel",
+      "cancellation"
+    );
+  }
+  /** Get Stripe billing portal URL for subscription management */
+  async getBillingPortalUrl(e) {
+    return this.executeWithResilience(
+      this.statusRateLimiter,
+      async () => {
+        const t = await this.routeDiscovery.buildUrl("/paywall/v1/subscription/portal");
+        c().debug("[SubscriptionManager] Getting billing portal URL:", e);
+        const n = await w(t, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(e)
+        });
+        if (!n.ok) throw new Error(await v(n, "Failed to get portal"));
+        return n.json();
+      },
+      "subscription-portal",
+      "portal"
+    );
+  }
+  /** Activate x402 subscription after payment verification */
+  async activateX402Subscription(e) {
+    return this.executeWithResilience(
+      this.sessionRateLimiter,
+      async () => {
+        const t = await this.routeDiscovery.buildUrl("/paywall/v1/subscription/x402/activate");
+        c().debug("[SubscriptionManager] Activating x402 subscription:", e);
+        const n = await w(t, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(e)
+        });
+        if (!n.ok) throw new Error(await v(n, "Failed to activate"));
+        return n.json();
+      },
+      "subscription-activate",
+      "activation"
+    );
+  }
+}
+class Rt {
+  routeDiscovery;
+  rateLimiter = R(A.PAYMENT);
+  queryRateLimiter = R(A.QUOTE);
+  circuitBreaker = $({
+    failureThreshold: 5,
+    timeout: 1e4,
+    name: "subscription-change-manager"
+  });
+  constructor(e) {
+    this.routeDiscovery = e;
+  }
+  /** Internal helper: execute with rate limiting, circuit breaker, and retry */
+  async executeWithResilience(e, t, n, a) {
+    if (!e.tryConsume())
+      throw new Error("Rate limit exceeded. Please try again later.");
+    try {
+      return await this.circuitBreaker.execute(
+        () => C(t, { ...x.STANDARD, name: n })
+      );
+    } catch (i) {
+      throw i instanceof E ? (c().error(`[SubscriptionChangeManager] Circuit breaker OPEN for ${a}`), new Error("Service temporarily unavailable. Please try again in a few moments.")) : i;
+    }
+  }
+  /** Change subscription plan (upgrade or downgrade) */
+  async changeSubscription(e) {
+    return this.executeWithResilience(
+      this.rateLimiter,
+      async () => {
+        const t = await this.routeDiscovery.buildUrl("/paywall/v1/subscription/change");
+        c().debug("[SubscriptionChangeManager] Changing subscription:", e);
+        const n = await w(t, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Idempotency-Key": k() },
+          body: JSON.stringify(e)
+        });
+        if (!n.ok)
+          throw new Error(await v(n, "Failed to change subscription"));
+        return n.json();
+      },
+      "subscription-change",
+      "plan change"
+    );
+  }
+  /** Preview subscription change (get proration details) */
+  async previewChange(e) {
+    return this.executeWithResilience(
+      this.queryRateLimiter,
+      async () => {
+        const t = await this.routeDiscovery.buildUrl("/paywall/v1/subscription/change/preview");
+        c().debug("[SubscriptionChangeManager] Previewing subscription change:", e);
+        const n = await w(t, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(e)
+        });
+        if (!n.ok)
+          throw new Error(await v(n, "Failed to preview change"));
+        return n.json();
+      },
+      "subscription-preview",
+      "change preview"
+    );
+  }
+  /** Get full subscription details */
+  async getDetails(e, t) {
+    return this.executeWithResilience(
+      this.queryRateLimiter,
+      async () => {
+        const n = new URLSearchParams({ resource: e, userId: t }), a = await this.routeDiscovery.buildUrl(`/paywall/v1/subscription/details?${n}`);
+        c().debug("[SubscriptionChangeManager] Getting subscription details:", { resource: e, userId: t });
+        const i = await w(a, {
+          method: "GET",
+          headers: { "Content-Type": "application/json" }
+        });
+        if (!i.ok)
+          throw new Error(await v(i, "Failed to get subscription details"));
+        return i.json();
+      },
+      "subscription-details",
+      "details"
+    );
+  }
+  /** Cancel a subscription */
+  async cancel(e) {
+    return this.executeWithResilience(
+      this.rateLimiter,
+      async () => {
+        const t = await this.routeDiscovery.buildUrl("/paywall/v1/subscription/cancel");
+        c().debug("[SubscriptionChangeManager] Canceling subscription:", e);
+        const n = await w(t, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(e)
+        });
+        if (!n.ok)
+          throw new Error(await v(n, "Failed to cancel subscription"));
+        return n.json();
+      },
+      "subscription-cancel",
+      "cancellation"
+    );
+  }
+  /** Get Stripe billing portal URL */
+  async getBillingPortalUrl(e) {
+    return this.executeWithResilience(
+      this.queryRateLimiter,
+      async () => {
+        const t = await this.routeDiscovery.buildUrl("/paywall/v1/subscription/portal");
+        c().debug("[SubscriptionChangeManager] Getting billing portal URL:", e);
+        const n = await w(t, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(e)
+        });
+        if (!n.ok)
+          throw new Error(await v(n, "Failed to get billing portal URL"));
+        return n.json();
+      },
+      "subscription-portal",
+      "portal"
+    );
+  }
+}
+class kt {
+  serverUrl;
+  routePrefix = null;
+  discoveryPromise = null;
+  maxRetries = 3;
+  baseDelayMs = 1e3;
+  constructor(e) {
+    this.serverUrl = e;
+  }
+  /**
+   * Discover route prefix from backend health endpoint
+   *
+   * DEDUPLICATION: Multiple concurrent calls share the same in-flight request
+   * SECURITY FIX: Only cache on success, retry on failures with exponential backoff
+   * This prevents permanent bricking of payments due to transient failures
+   */
+  async discoverPrefix() {
+    if (this.routePrefix !== null)
+      return this.routePrefix;
+    if (this.discoveryPromise)
+      return this.discoveryPromise;
+    const e = (async () => {
+      let t = 0;
+      for (; t < this.maxRetries; )
+        try {
+          const n = await w(`${this.serverUrl}/cedros-health`);
+          if (!n.ok) {
+            if (n.status >= 400 && n.status < 500)
+              return c().warn(`Route discovery received ${n.status} - not retrying client error`), this.routePrefix = "", "";
+            throw new Error(`Health check returned ${n.status}`);
+          }
+          const i = (await n.json()).routePrefix || "";
+          return this.routePrefix = i, c().debug("Route discovery successful, prefix:", i || "(empty)"), i;
+        } catch (n) {
+          if (t++, t >= this.maxRetries)
+            return c().warn(
+              `Route discovery failed after ${t} attempts, using empty prefix for this request:`,
+              n
+            ), "";
+          const a = this.baseDelayMs * Math.pow(2, t - 1);
+          c().warn(
+            `Route discovery failed (attempt ${t}/${this.maxRetries}), retrying in ${a}ms:`,
+            n
+          ), await new Promise((i) => setTimeout(i, a));
+        }
+      return "";
+    })();
+    this.discoveryPromise = e;
+    try {
+      return await this.discoveryPromise;
+    } finally {
+      this.discoveryPromise = null;
+    }
+  }
+  /**
+   * Build API URL with discovered prefix
+   */
+  async buildUrl(e) {
+    const t = await this.discoverPrefix(), n = e.startsWith("/") ? e : `/${e}`;
+    return `${this.serverUrl}${t}${n}`;
+  }
+  /**
+   * Reset cached prefix (useful for testing or reconnecting)
+   */
+  reset() {
+    this.routePrefix = null, this.discoveryPromise = null;
+  }
+}
+const G = /* @__PURE__ */ new Map();
+function Ie(r, e, t, n, a) {
+  return JSON.stringify({
+    stripePublicKey: r,
+    serverUrl: e,
+    solanaCluster: t,
+    solanaEndpoint: n || "",
+    dangerouslyAllowUnknownMint: a || !1
+  });
+}
+function At(r, e, t, n, a) {
+  const i = Ie(
+    r,
+    e,
+    t,
+    n,
+    a
+  );
+  let o = G.get(i);
+  if (o)
+    return o.refCount++, c().debug(
+      `[ManagerCache] Reusing cached managers (refCount: ${o.refCount}):`,
+      { stripePublicKey: r.slice(0, 10) + "...", serverUrl: e }
+    ), o;
+  c().debug(
+    "[ManagerCache] Creating new manager instances:",
+    { stripePublicKey: r.slice(0, 10) + "...", serverUrl: e }
+  );
+  const s = new kt(e), u = new lt(r, s), l = new vt(s), d = new Pt(
+    t,
+    n,
+    a ?? !1
+  ), f = new Tt(r, s), h = new Rt(s);
+  return o = {
+    stripeManager: u,
+    x402Manager: l,
+    walletManager: d,
+    subscriptionManager: f,
+    subscriptionChangeManager: h,
+    routeDiscovery: s,
+    refCount: 1
+  }, G.set(i, o), o;
+}
+function Mt(r, e, t, n, a) {
+  const i = Ie(
+    r,
+    e,
+    t,
+    n,
+    a
+  ), o = G.get(i);
+  if (!o) {
+    c().warn("[ManagerCache] Attempted to release non-existent managers:", { cacheKey: i });
+    return;
+  }
+  o.refCount--, c().debug(
+    `[ManagerCache] Released manager reference (refCount: ${o.refCount}):`,
+    { stripePublicKey: r.slice(0, 10) + "...", serverUrl: e }
+  ), o.refCount <= 0 && (G.delete(i), c().debug("[ManagerCache] Removed managers from cache (refCount reached 0)"));
+}
+const Ut = [
+  "stripePublicKey"
+], fe = /* @__PURE__ */ new Set(["mainnet-beta", "devnet", "testnet"]);
+function Dt() {
+  if (typeof window < "u" && window.location)
+    return window.location.origin;
+  throw new Error(
+    "serverUrl is required in SSR/Node environments. In browser environments, it defaults to window.location.origin"
+  );
+}
+function Ot(r) {
+  const e = [];
+  Ut.forEach((n) => {
+    const a = r[n];
+    (typeof a != "string" || a.trim().length === 0) && e.push({
+      field: n,
+      message: "must be a non-empty string"
+    });
+  });
+  let t;
+  if (r.serverUrl !== void 0)
+    typeof r.serverUrl != "string" || r.serverUrl.trim().length === 0 ? (e.push({
+      field: "serverUrl",
+      message: "must be a non-empty string when provided"
+    }), t = "") : t = r.serverUrl;
+  else
+    try {
+      t = Dt();
+    } catch (n) {
+      e.push({
+        field: "serverUrl",
+        message: n instanceof Error ? n.message : "failed to determine default"
+      }), t = "";
+    }
+  if (fe.has(r.solanaCluster) || e.push({
+    field: "solanaCluster",
+    message: `must be one of ${Array.from(fe).join(", ")}`
+  }), r.solanaEndpoint !== void 0 && (typeof r.solanaEndpoint != "string" ? e.push({
+    field: "solanaEndpoint",
+    message: "must be a string when provided"
+  }) : r.solanaEndpoint.trim().length === 0 ? e.push({
+    field: "solanaEndpoint",
+    message: 'must be a non-empty string when provided (e.g., "https://api.mainnet-beta.solana.com")'
+  }) : !r.solanaEndpoint.startsWith("http://") && !r.solanaEndpoint.startsWith("https://") && e.push({
+    field: "solanaEndpoint",
+    message: 'must start with "http://" or "https://" (e.g., "https://api.mainnet-beta.solana.com")'
+  })), r.tokenMint && typeof r.tokenMint != "string" && e.push({
+    field: "tokenMint",
+    message: "must be a string when provided"
+  }), e.length > 0) {
+    const n = e.map((a) => `- ${a.field} ${a.message}`).join(`
+`);
+    throw new Error(`Invalid Cedros configuration:
+${n}`);
+  }
+  if (r.tokenMint) {
+    const n = r.dangerouslyAllowUnknownMint === !0, a = Be(r.tokenMint, "CedrosConfig.tokenMint", n);
+    if (!a.isValid && a.error)
+      throw new Error(a.error);
+    a.warning && c().warn(a.warning);
+  }
+  return {
+    ...r,
+    serverUrl: t
+  };
+}
+class Nt {
+  adapters = null;
+  poolId;
+  isCleanedUp = !1;
+  constructor(e) {
+    this.poolId = e ?? `pool_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`, c().debug(`[WalletPool] Created pool: ${this.poolId}`);
+  }
+  /**
+   * Get wallet adapters for this pool
+   *
+   * Lazy initialization: adapters are created on first access.
+   * Returns empty array in SSR environments.
+   */
+  getAdapters() {
+    return typeof window > "u" ? [] : this.isCleanedUp ? (c().warn(`[WalletPool] Attempted to use pool after cleanup: ${this.poolId}`), []) : this.adapters !== null ? this.adapters : (c().debug(`[WalletPool] Initializing adapters for pool: ${this.poolId}`), this.adapters = [
+      new Ke(),
+      new ze()
+    ], this.adapters);
+  }
+  /**
+   * Cleanup wallet adapters
+   *
+   * Disconnects all wallets and clears the adapter cache.
+   * Called automatically when CedrosProvider unmounts.
+   *
+   * IMPORTANT: After cleanup, getAdapters() will return empty array.
+   */
+  async cleanup() {
+    if (this.isCleanedUp) {
+      c().debug(`[WalletPool] Pool already cleaned up: ${this.poolId}`);
+      return;
+    }
+    if (c().debug(`[WalletPool] Cleaning up pool: ${this.poolId}`), this.isCleanedUp = !0, this.adapters === null)
+      return;
+    const e = this.adapters.map(async (t) => {
+      try {
+        t.connected && (c().debug(`[WalletPool] Disconnecting wallet: ${t.name}`), await t.disconnect());
+      } catch (n) {
+        c().warn(`[WalletPool] Failed to disconnect wallet ${t.name}:`, n);
+      }
+    });
+    await Promise.allSettled(e), this.adapters = null, c().debug(`[WalletPool] Pool cleanup complete: ${this.poolId}`);
+  }
+  /**
+   * Check if this pool has been initialized
+   *
+   * Useful for testing or debugging.
+   */
+  isInitialized() {
+    return this.adapters !== null;
+  }
+  /**
+   * Get pool ID (for debugging/logging)
+   */
+  getId() {
+    return this.poolId;
+  }
+}
+function Bt(r) {
+  return new Nt(r);
+}
+const It = Object.freeze({
+  surfaceBackground: "rgba(255, 255, 255, 0)",
+  surfaceText: "#111827",
+  surfaceBorder: "rgba(15, 23, 42, 0.08)",
+  stripeBackground: "linear-gradient(135deg, #635bff 0%, #4f46e5 100%)",
+  stripeText: "#ffffff",
+  stripeShadow: "rgba(79, 70, 229, 0.25)",
+  cryptoBackground: "linear-gradient(135deg, #14f195 0%, #9945ff 100%)",
+  cryptoText: "#ffffff",
+  cryptoShadow: "rgba(99, 102, 241, 0.25)",
+  errorBackground: "#fee2e2",
+  errorBorder: "#fca5a5",
+  errorText: "#b91c1c",
+  successBackground: "#dcfce7",
+  successBorder: "#86efac",
+  successText: "#166534",
+  modalOverlay: "rgba(0, 0, 0, 0.5)",
+  modalBackground: "#ffffff",
+  modalBorder: "rgba(15, 23, 42, 0.08)",
+  buttonBorderRadius: "8px",
+  buttonPadding: "0.75rem 1.5rem",
+  buttonFontSize: "1rem",
+  buttonFontWeight: "600"
+}), Lt = Object.freeze({
+  surfaceBackground: "rgba(17, 24, 39, 0.6)",
+  surfaceText: "#f9fafb",
+  surfaceBorder: "rgba(148, 163, 184, 0.25)",
+  stripeBackground: "linear-gradient(135deg, #4f46e5 0%, #3730a3 100%)",
+  stripeText: "#f5f3ff",
+  stripeShadow: "rgba(99, 102, 241, 0.35)",
+  cryptoBackground: "linear-gradient(135deg, #1dd4a6 0%, #6d28d9 100%)",
+  cryptoText: "#ecfeff",
+  cryptoShadow: "rgba(75, 85, 99, 0.35)",
+  errorBackground: "#7f1d1d",
+  errorBorder: "#fca5a5",
+  errorText: "#fecaca",
+  successBackground: "#14532d",
+  successBorder: "#4ade80",
+  successText: "#bbf7d0",
+  modalOverlay: "rgba(0, 0, 0, 0.75)",
+  modalBackground: "#1f2937",
+  modalBorder: "rgba(148, 163, 184, 0.25)",
+  buttonBorderRadius: "8px",
+  buttonPadding: "0.75rem 1.5rem",
+  buttonFontSize: "1rem",
+  buttonFontWeight: "600"
+}), Ft = {
+  surfaceBackground: "--cedros-surface-bg",
+  surfaceText: "--cedros-surface-text",
+  surfaceBorder: "--cedros-surface-border",
+  stripeBackground: "--cedros-stripe-bg",
+  stripeText: "--cedros-stripe-text",
+  stripeShadow: "--cedros-stripe-shadow",
+  cryptoBackground: "--cedros-crypto-bg",
+  cryptoText: "--cedros-crypto-text",
+  cryptoShadow: "--cedros-crypto-shadow",
+  errorBackground: "--cedros-error-bg",
+  errorBorder: "--cedros-error-border",
+  errorText: "--cedros-error-text",
+  successBackground: "--cedros-success-bg",
+  successBorder: "--cedros-success-border",
+  successText: "--cedros-success-text",
+  modalOverlay: "--cedros-modal-overlay",
+  modalBackground: "--cedros-modal-bg",
+  modalBorder: "--cedros-modal-border",
+  buttonBorderRadius: "--cedros-button-radius",
+  buttonPadding: "--cedros-button-padding",
+  buttonFontSize: "--cedros-button-font-size",
+  buttonFontWeight: "--cedros-button-font-weight"
+}, Le = pe(null);
+function jt(r, e) {
+  return {
+    ...r === "dark" ? Lt : It,
+    ...e
+  };
+}
+function $t(r) {
+  const e = Object.entries(r).map(([t, n]) => [
+    Ft[t],
+    n
+  ]);
+  return Object.fromEntries(e);
+}
+function _t({
+  initialMode: r = "light",
+  overrides: e,
+  unstyled: t = !1,
+  children: n
+}) {
+  const [a, i] = Q(r), [o, s] = Q(e), u = me(e);
+  L(() => {
+    if (e === u.current)
+      return;
+    (!e || !u.current ? e !== u.current : Object.keys({ ...e, ...u.current }).some(
+      (f) => e[f] !== u.current?.[f]
+    )) && (u.current = e, s(e));
+  }, [e]);
+  const l = Y(() => {
+    const d = jt(a, o), f = t ? {} : $t(d), h = t ? "" : `cedros-theme-root cedros-theme cedros-theme--${a}`;
+    return {
+      mode: a,
+      setMode: i,
+      tokens: d,
+      className: h,
+      style: f,
+      unstyled: t
+    };
+  }, [a, o, t]);
+  return /* @__PURE__ */ X(Le.Provider, { value: l, children: n });
+}
+function Qt() {
+  const r = ye(Le);
+  if (!r)
+    throw new Error("useCedrosTheme must be used within CedrosProvider");
+  return r;
+}
+let H = !1, J = !1;
+async function Wt() {
+  if (H)
+    return J ? { available: !0 } : {
+      available: !1,
+      error: he()
+    };
+  try {
+    return await import("@solana/web3.js"), H = !0, J = !0, { available: !0 };
+  } catch {
+    return H = !0, J = !1, {
+      available: !1,
+      error: he()
+    };
+  }
+}
+function he() {
+  return `Solana dependencies not installed. To use crypto payments, install them with:
+npm install @solana/web3.js @solana/spl-token @solana/wallet-adapter-react @solana/wallet-adapter-react-ui @solana/wallet-adapter-wallets @solana/wallet-adapter-base
+Or if you only need Stripe payments, hide the crypto button with:
+<CedrosPay showCrypto={false} />`;
+}
+function qt() {
+  return typeof process < "u" && process.env.NODE_ENV === "development" ? 0 : 2;
+}
+const Fe = pe(null);
+function Yt({ config: r, children: e }) {
+  const t = Y(() => Ot(r), [r]), n = me(null);
+  n.current === null && (n.current = Bt());
+  const [a, i] = Q(null);
+  L(() => {
+    let s = !1;
+    return Wt().then((u) => {
+      s || (u.available ? i(void 0) : i(u.error || "Solana dependencies not available"));
+    }), () => {
+      s = !0;
+    };
+  }, []), L(() => {
+    const s = t.logLevel ?? qt(), u = rt({
+      level: s,
+      prefix: "[CedrosPay]"
+    });
+    tt(u);
+  }, [t.logLevel]), L(() => {
+    const s = n.current;
+    return () => {
+      s && s.cleanup().catch((u) => {
+        c().warn("[CedrosProvider] Wallet pool cleanup failed:", u);
+      });
+    };
+  }, []), L(() => {
+    const s = t.stripePublicKey, u = t.serverUrl ?? "", l = t.solanaCluster, d = t.solanaEndpoint, f = t.dangerouslyAllowUnknownMint;
+    return () => {
+      Mt(s, u, l, d, f);
+    };
+  }, [
+    t.stripePublicKey,
+    t.serverUrl,
+    t.solanaCluster,
+    t.solanaEndpoint,
+    t.dangerouslyAllowUnknownMint
+  ]);
+  const o = Y(() => {
+    const { stripeManager: s, x402Manager: u, walletManager: l, subscriptionManager: d, subscriptionChangeManager: f } = At(
+      t.stripePublicKey,
+      t.serverUrl ?? "",
+      t.solanaCluster,
+      t.solanaEndpoint,
+      t.dangerouslyAllowUnknownMint
+    );
+    return {
+      config: t,
+      stripeManager: s,
+      x402Manager: u,
+      walletManager: l,
+      subscriptionManager: d,
+      subscriptionChangeManager: f,
+      walletPool: n.current,
+      solanaError: a
+    };
+  }, [t, a]);
+  return /* @__PURE__ */ X(Fe.Provider, { value: o, children: /* @__PURE__ */ X(
+    _t,
+    {
+      initialMode: t.theme ?? "light",
+      overrides: t.themeOverrides,
+      unstyled: t.unstyled ?? !1,
+      children: e
+    }
+  ) });
+}
+function Zt() {
+  const r = ye(Fe);
+  if (!r)
+    throw new Error("useCedrosContext must be used within CedrosProvider");
+  return r;
+}
+export {
+  Yt as C,
+  te as K,
+  Ze as L,
+  A as R,
+  Nt as W,
+  Qt as a,
+  Ee as b,
+  R as c,
+  rt as d,
+  Be as e,
+  D as f,
+  c as g,
+  $ as h,
+  it as i,
+  E as j,
+  Xt as k,
+  x as l,
+  Bt as m,
+  C as r,
+  Zt as u,
+  Ot as v
+};