spaps-sdk 0.1.0 → 1.0.1

package/dist/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,175 +15,929 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
+// index.ts
 var index_exports = {};
 __export(index_exports, {
-  SPAPS: () => SPAPSClient,
-  SPAPSClient: () => SPAPSClient,
-  SweetPotatoSDK: () => SPAPSClient,
-  default: () => index_default
+  AuthService: () => AuthService,
+  HttpClient: () => HttpClient,
+  PaymentsService: () => PaymentsService,
+  SweetPotatoAPIError: () => SweetPotatoAPIError,
+  SweetPotatoSDK: () => SweetPotatoSDK,
+  TokenManager: () => TokenManager,
+  WalletUtils: () => WalletUtils,
+  createSweetPotatoSDK: () => createSweetPotatoSDK,
+  default: () => SweetPotatoSDK
 });
 module.exports = __toCommonJS(index_exports);
-var import_axios = __toESM(require("axios"));
-var SPAPSClient = class {
-  client;
-  apiKey;
-  accessToken;
-  refreshToken;
-  _isLocalMode = false;
-  constructor(config = {}) {
-    const apiUrl = config.apiUrl || process.env.SPAPS_API_URL || process.env.NEXT_PUBLIC_SPAPS_API_URL;
-    if (!apiUrl || apiUrl.includes("localhost") || apiUrl.includes("127.0.0.1")) {
-      this._isLocalMode = true;
-      this.client = import_axios.default.create({
-        baseURL: apiUrl || "http://localhost:3300",
-        timeout: config.timeout || 1e4,
-        headers: {
-          "Content-Type": "application/json"
-        }
-      });
+
+// types.ts
+var SweetPotatoAPIError = class extends Error {
+  constructor(message, code, status, details) {
+    super(message);
+    this.name = "SweetPotatoAPIError";
+    if (code !== void 0) this.code = code;
+    if (status !== void 0) this.status = status;
+    if (details !== void 0) this.details = details;
+  }
+};
+
+// client.ts
+function detectLocalEnvironment() {
+  var _a;
+  if (typeof process !== "undefined" && process.env) {
+    if (process.env.NODE_ENV === "development" || process.env.SPAPS_LOCAL_MODE === "true") {
+      return true;
+    }
+  }
+  if (typeof globalThis !== "undefined" && ((_a = globalThis.window) == null ? void 0 : _a.location)) {
+    const hostname = globalThis.window.location.hostname;
+    return hostname === "localhost" || hostname === "127.0.0.1" || hostname.endsWith(".local");
+  }
+  return false;
+}
+var HttpClient = class {
+  constructor(config) {
+    var _a, _b;
+    const localMode = (_b = config.localMode) != null ? _b : ((_a = config.apiUrl) == null ? void 0 : _a.includes("localhost")) || detectLocalEnvironment();
+    this.config = {
+      timeout: 3e4,
+      retries: 3,
+      ...config,
+      localMode
+    };
+    this.isLocalMode = this.config.localMode || false;
+    this.accessToken = void 0;
+    if (this.isLocalMode && typeof console !== "undefined") {
+      console.log("[SPAPS SDK] Running in local development mode - authentication will be automatic");
+    }
+  }
+  /**
+   * Set the access token for authenticated requests
+   */
+  setAccessToken(token) {
+    this.accessToken = token;
+  }
+  /**
+   * Clear the access token
+   */
+  clearAccessToken() {
+    this.accessToken = void 0;
+  }
+  /**
+   * Make an HTTP request with automatic retries and error handling
+   */
+  async request(options) {
+    var _a, _b, _c, _d;
+    const { method, url, data, headers = {}, requiresAuth = false } = options;
+    const fullUrl = url.startsWith("http") ? url : `${this.config.apiUrl.replace(/\/$/, "")}${url}`;
+    const requestHeaders = {
+      "Content-Type": "application/json",
+      ...headers
+    };
+    if (this.config.apiKey) {
+      requestHeaders["x-api-key"] = this.config.apiKey;
+    } else if (this.isLocalMode) {
+      requestHeaders["x-local-mode"] = "true";
     } else {
-      if (!config.apiKey && !process.env.SPAPS_API_KEY) {
-        console.warn("\u26A0\uFE0F SPAPS: No API key provided. Some features may not work.");
-      }
-      this.apiKey = config.apiKey || process.env.SPAPS_API_KEY;
-      this.client = import_axios.default.create({
-        baseURL: apiUrl,
-        timeout: config.timeout || 1e4,
-        headers: {
-          "Content-Type": "application/json",
-          ...this.apiKey && { "X-API-Key": this.apiKey }
-        }
-      });
+      console.warn("[SPAPS SDK] No API key provided and not in local mode");
     }
-    this.client.interceptors.request.use((config2) => {
-      if (this.accessToken && !config2.headers.Authorization) {
-        config2.headers.Authorization = `Bearer ${this.accessToken}`;
-      }
-      return config2;
-    });
-    this.client.interceptors.response.use(
-      (response) => response,
-      async (error) => {
-        if (error.response?.status === 401 && this.refreshToken) {
-          try {
-            const { data } = await this.refresh(this.refreshToken);
-            this.accessToken = data.access_token;
-            this.refreshToken = data.refresh_token;
-            if (error.config) {
-              error.config.headers.Authorization = `Bearer ${this.accessToken}`;
-              return this.client.request(error.config);
-            }
-          } catch (refreshError) {
-            this.accessToken = void 0;
-            this.refreshToken = void 0;
+    if (requiresAuth && this.accessToken) {
+      requestHeaders["Authorization"] = `Bearer ${this.accessToken}`;
+    }
+    let lastError = null;
+    for (let attempt = 1; attempt <= this.config.retries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+        const requestInit = {
+          method,
+          headers: requestHeaders,
+          signal: controller.signal
+        };
+        if (data && (method === "POST" || method === "PUT" || method === "PATCH")) {
+          requestInit.body = JSON.stringify(data);
+        }
+        const response = await fetch(fullUrl, requestInit);
+        clearTimeout(timeoutId);
+        if (!response) {
+          throw new Error("No response received");
+        }
+        let responseData;
+        const contentType = (_a = response.headers) == null ? void 0 : _a.get("content-type");
+        if (contentType && contentType.includes("application/json")) {
+          responseData = await response.json();
+        } else {
+          throw new SweetPotatoAPIError(
+            "Invalid response format: expected JSON",
+            "INVALID_RESPONSE_FORMAT",
+            response.status
+          );
+        }
+        if (!(response == null ? void 0 : response.ok)) {
+          throw new SweetPotatoAPIError(
+            ((_b = responseData.error) == null ? void 0 : _b.message) || `HTTP ${response == null ? void 0 : response.status}: ${response == null ? void 0 : response.statusText}`,
+            ((_c = responseData.error) == null ? void 0 : _c.code) || "HTTP_ERROR",
+            response == null ? void 0 : response.status,
+            (_d = responseData.error) == null ? void 0 : _d.details
+          );
+        }
+        return responseData;
+      } catch (error) {
+        lastError = error;
+        if (error instanceof SweetPotatoAPIError) {
+          if (error.status && error.status >= 400 && error.status < 500) {
+            throw error;
           }
         }
-        return Promise.reject(error);
+        if (attempt === this.config.retries) {
+          break;
+        }
+        const delayMs = Math.min(1e3 * Math.pow(2, attempt - 1), 1e4);
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
       }
+    }
+    if (lastError instanceof SweetPotatoAPIError) {
+      throw lastError;
+    }
+    throw new SweetPotatoAPIError(
+      (lastError == null ? void 0 : lastError.message) || "Request failed after all retries",
+      "REQUEST_FAILED",
+      void 0,
+      { originalError: lastError }
     );
   }
-  // Authentication Methods
-  async login(email, password) {
-    const response = await this.client.post("/api/auth/login", {
-      email,
-      password
+  /**
+   * Convenience method for GET requests
+   */
+  async get(url, requiresAuth = false) {
+    return this.request({
+      method: "GET",
+      url,
+      requiresAuth
     });
-    this.accessToken = response.data.access_token;
-    this.refreshToken = response.data.refresh_token;
-    return response;
-  }
-  async register(email, password) {
-    const response = await this.client.post("/api/auth/register", {
-      email,
-      password
+  }
+  /**
+   * Convenience method for POST requests
+   */
+  async post(url, data, requiresAuth = false) {
+    return this.request({
+      method: "POST",
+      url,
+      data,
+      requiresAuth
+    });
+  }
+  /**
+   * Convenience method for PUT requests
+   */
+  async put(url, data, requiresAuth = false) {
+    return this.request({
+      method: "PUT",
+      url,
+      data,
+      requiresAuth
+    });
+  }
+  /**
+   * Convenience method for DELETE requests
+   */
+  async delete(url, requiresAuth = false) {
+    return this.request({
+      method: "DELETE",
+      url,
+      requiresAuth
     });
-    this.accessToken = response.data.access_token;
-    this.refreshToken = response.data.refresh_token;
-    return response;
   }
-  async walletSignIn(walletAddress, signature, message, chainType = "solana") {
-    const response = await this.client.post("/api/auth/wallet-sign-in", {
+};
+
+// auth.ts
+var AuthService = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  /**
+   * Get a nonce for wallet signature
+   * @param walletAddress - The wallet address to generate a nonce for
+   * @returns Promise<NonceResponse>
+   */
+  async getNonce(walletAddress) {
+    var _a;
+    const response = await this.httpClient.post("/api/auth/nonce", {
+      wallet_address: walletAddress
+    });
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to generate nonce");
+    }
+    return response.data;
+  }
+  /**
+   * Sign in with wallet signature
+   * @param request - Wallet sign-in request data
+   * @returns Promise<AuthResponse>
+   */
+  async signInWithWallet(request) {
+    var _a;
+    const response = await this.httpClient.post("/api/auth/wallet-sign-in", request);
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Wallet sign-in failed");
+    }
+    this.httpClient.setAccessToken(response.data.access_token);
+    return response.data;
+  }
+  /**
+   * Complete wallet authentication flow
+   * This is a convenience method that combines getNonce and signInWithWallet
+   * @param walletAddress - The wallet address
+   * @param signatureFunction - Function that signs the auth message
+   * @param chainType - Optional chain type (will be auto-detected if not provided)
+   * @param username - Optional username for new users
+   * @returns Promise<AuthResponse>
+   */
+  async authenticateWallet(walletAddress, signatureFunction, chainType, username) {
+    const nonceData = await this.getNonce(walletAddress);
+    const signature = await signatureFunction(nonceData.message);
+    const request = {
       wallet_address: walletAddress,
       signature,
-      message,
-      chain_type: chainType
-    });
-    this.accessToken = response.data.access_token;
-    this.refreshToken = response.data.refresh_token;
-    return response;
+      message: nonceData.message
+    };
+    if (chainType) {
+      request.chain_type = chainType;
+    }
+    if (username) {
+      request.username = username;
+    }
+    return this.signInWithWallet(request);
   }
-  async refresh(refreshToken) {
-    const response = await this.client.post("/api/auth/refresh", {
-      refresh_token: refreshToken || this.refreshToken
+  /**
+   * Sign in with email and password
+   * @param request - Traditional login request data
+   * @returns Promise<AuthResponse>
+   */
+  async signInWithPassword(request) {
+    var _a;
+    const response = await this.httpClient.post("/api/auth/login", request);
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Login failed");
+    }
+    this.httpClient.setAccessToken(response.data.access_token);
+    return response.data;
+  }
+  /**
+   * Request a magic link for email authentication
+   * @param request - Magic link request data
+   * @returns Promise<void>
+   */
+  async requestMagicLink(request) {
+    var _a;
+    const response = await this.httpClient.post("/api/auth/magic-link", request);
+    if (!response.success) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to send magic link");
+    }
+  }
+  /**
+   * Refresh access token using refresh token
+   * @param refreshToken - The refresh token
+   * @returns Promise<TokenPair>
+   */
+  async refreshToken(refreshToken) {
+    var _a;
+    const response = await this.httpClient.post("/api/auth/refresh", {
+      refresh_token: refreshToken
     });
-    this.accessToken = response.data.access_token;
-    this.refreshToken = response.data.refresh_token;
-    return response;
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Token refresh failed");
+    }
+    this.httpClient.setAccessToken(response.data.access_token);
+    return response.data;
   }
+  /**
+   * Log out and invalidate tokens
+   * @returns Promise<void>
+   */
   async logout() {
-    await this.client.post("/api/auth/logout");
-    this.accessToken = void 0;
-    this.refreshToken = void 0;
+    var _a;
+    try {
+      const response = await this.httpClient.post("/api/auth/logout", {}, true);
+      if (!response.success) {
+        console.warn("Logout API call failed:", ((_a = response.error) == null ? void 0 : _a.message) || "Unknown error");
+      }
+    } catch (error) {
+      console.warn("Logout API call failed:", error);
+    } finally {
+      this.httpClient.clearAccessToken();
+    }
   }
-  async getUser() {
-    return this.client.get("/api/auth/user");
+  /**
+   * Get current user profile
+   * @returns Promise<User>
+   */
+  async getCurrentUser() {
+    var _a;
+    const response = await this.httpClient.get("/api/auth/user", true);
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to get user profile");
+    }
+    return response.data.user;
   }
-  // Stripe Methods
-  async createCheckoutSession(priceId, successUrl, cancelUrl) {
-    return this.client.post("/api/stripe/create-checkout-session", {
-      price_id: priceId,
-      success_url: successUrl,
-      cancel_url: cancelUrl
-    });
+  /**
+   * Check if user is currently authenticated
+   * @returns boolean
+   */
+  isAuthenticated() {
+    return this.httpClient["accessToken"] !== void 0;
+  }
+  /**
+   * Clear authentication state (useful for client-side logout)
+   */
+  clearAuth() {
+    this.httpClient.clearAccessToken();
   }
-  async getSubscription() {
-    return this.client.get("/api/stripe/subscription");
+};
+
+// payments.ts
+var PaymentsService = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  // Checkout Sessions
+  /**
+   * Create a new Stripe checkout session
+   * @param request - Checkout session creation parameters
+   * @returns Promise<CheckoutSession>
+   */
+  async createCheckoutSession(request) {
+    var _a;
+    const response = await this.httpClient.post(
+      "/api/stripe/checkout-sessions",
+      request,
+      true
+    );
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to create checkout session");
+    }
+    return response.data;
   }
-  async cancelSubscription() {
-    await this.client.delete("/api/stripe/subscription");
+  /**
+   * Retrieve a checkout session by ID
+   * @param sessionId - The checkout session ID
+   * @returns Promise<CheckoutSession>
+   */
+  async getCheckoutSession(sessionId) {
+    var _a;
+    const response = await this.httpClient.get(
+      `/api/stripe/checkout-sessions/${sessionId}`,
+      true
+    );
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to retrieve checkout session");
+    }
+    return response.data;
   }
-  // Usage Methods
-  async getUsageBalance() {
-    return this.client.get("/api/usage/balance");
+  /**
+   * Expire a checkout session
+   * @param sessionId - The checkout session ID to expire
+   * @returns Promise<{id: string, status: string, expired: boolean}>
+   */
+  async expireCheckoutSession(sessionId) {
+    var _a;
+    const response = await this.httpClient.post(
+      `/api/stripe/checkout-sessions/${sessionId}/expire`,
+      {},
+      true
+    );
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to expire checkout session");
+    }
+    return response.data;
   }
-  async recordUsage(feature, amount) {
-    await this.client.post("/api/usage/record", {
-      feature,
-      amount
-    });
+  /**
+   * List checkout sessions for the current user
+   * @param options - List options (limit, pagination)
+   * @returns Promise<CheckoutSessionListResponse>
+   */
+  async listCheckoutSessions(options = {}) {
+    var _a;
+    const params = new URLSearchParams();
+    if (options.limit) params.append("limit", options.limit.toString());
+    if (options.starting_after) params.append("starting_after", options.starting_after);
+    const url = `/api/stripe/checkout-sessions${params.toString() ? `?${params.toString()}` : ""}`;
+    const response = await this.httpClient.get(url, true);
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to list checkout sessions");
+    }
+    return response.data;
+  }
+  // Products
+  /**
+   * List available products
+   * @param request - Product list filters
+   * @returns Promise<ProductsListResponse>
+   */
+  async listProducts(request = {}) {
+    var _a;
+    const params = new URLSearchParams();
+    if (request.category) params.append("category", request.category);
+    if (request.active !== void 0) params.append("active", request.active.toString());
+    if (request.limit) params.append("limit", request.limit.toString());
+    if (request.starting_after) params.append("starting_after", request.starting_after);
+    const url = `/api/stripe/products${params.toString() ? `?${params.toString()}` : ""}`;
+    const response = await this.httpClient.get(url, true);
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to list products");
+    }
+    return response.data;
+  }
+  /**
+   * Get a specific product by ID
+   * @param productId - The product ID
+   * @param includePrices - Whether to include associated prices (default: true)
+   * @returns Promise<StripeProduct>
+   */
+  async getProduct(productId, includePrices = true) {
+    var _a;
+    const params = new URLSearchParams();
+    if (!includePrices) params.append("include_prices", "false");
+    const url = `/api/stripe/products/${productId}${params.toString() ? `?${params.toString()}` : ""}`;
+    const response = await this.httpClient.get(url, true);
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to retrieve product");
+    }
+    return response.data;
+  }
+  /**
+   * Create a new product (Admin only)
+   * @param request - Product creation parameters
+   * @returns Promise<StripeProduct>
+   */
+  async createProduct(request) {
+    var _a;
+    const response = await this.httpClient.post(
+      "/api/stripe/products",
+      request,
+      true
+    );
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to create product");
+    }
+    return response.data;
+  }
+  /**
+   * Update an existing product (Admin only)
+   * @param productId - The product ID to update
+   * @param request - Product update parameters
+   * @returns Promise<StripeProduct>
+   */
+  async updateProduct(productId, request) {
+    var _a;
+    const response = await this.httpClient.put(
+      `/api/stripe/products/${productId}`,
+      request,
+      true
+    );
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to update product");
+    }
+    return response.data;
+  }
+  /**
+   * Archive a product (Admin only)
+   * @param productId - The product ID to archive
+   * @returns Promise<{id: string, archived: boolean, active: boolean}>
+   */
+  async archiveProduct(productId) {
+    var _a;
+    const response = await this.httpClient.delete(
+      `/api/stripe/products/${productId}`,
+      true
+    );
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to archive product");
+    }
+    return response.data;
+  }
+  /**
+   * Sync products from Stripe (Admin only)
+   * @returns Promise<{synced_count: number, message: string}>
+   */
+  async syncProducts() {
+    var _a;
+    const response = await this.httpClient.post(
+      "/api/stripe/products/sync",
+      {},
+      true
+    );
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to sync products");
+    }
+    return response.data;
+  }
+  // Prices
+  /**
+   * Create a new price for a product (Admin only)
+   * @param request - Price creation parameters
+   * @returns Promise<StripePrice>
+   */
+  async createPrice(request) {
+    var _a;
+    const response = await this.httpClient.post(
+      "/api/stripe/prices",
+      request,
+      true
+    );
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to create price");
+    }
+    return response.data;
+  }
+  // Subscriptions
+  /**
+   * Create a new subscription
+   * @param request - Subscription creation parameters
+   * @returns Promise<Subscription>
+   */
+  async createSubscription(request) {
+    var _a;
+    const response = await this.httpClient.post(
+      "/api/stripe/subscriptions",
+      request,
+      true
+    );
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to create subscription");
+    }
+    return response.data;
+  }
+  /**
+   * Get a subscription by ID
+   * @param subscriptionId - The subscription ID
+   * @returns Promise<Subscription>
+   */
+  async getSubscription(subscriptionId) {
+    var _a;
+    const response = await this.httpClient.get(
+      `/api/stripe/subscriptions/${subscriptionId}`,
+      true
+    );
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to retrieve subscription");
+    }
+    return response.data;
+  }
+  /**
+   * List subscriptions for the current user
+   * @param options - List options
+   * @returns Promise<{subscriptions: Subscription[], has_more: boolean}>
+   */
+  async listSubscriptions(options = {}) {
+    var _a;
+    const params = new URLSearchParams();
+    if (options.limit) params.append("limit", options.limit.toString());
+    if (options.starting_after) params.append("starting_after", options.starting_after);
+    if (options.status) params.append("status", options.status);
+    const url = `/api/stripe/subscriptions${params.toString() ? `?${params.toString()}` : ""}`;
+    const response = await this.httpClient.get(url, true);
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to list subscriptions");
+    }
+    return response.data;
+  }
+  /**
+   * Cancel a subscription
+   * @param subscriptionId - The subscription ID to cancel
+   * @returns Promise<Subscription>
+   */
+  async cancelSubscription(subscriptionId) {
+    var _a;
+    const response = await this.httpClient.post(
+      `/api/stripe/subscriptions/${subscriptionId}/cancel`,
+      {},
+      true
+    );
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to cancel subscription");
+    }
+    return response.data;
+  }
+  /**
+   * Update a subscription
+   * @param subscriptionId - The subscription ID to update
+   * @param request - Update parameters
+   * @returns Promise<Subscription>
+   */
+  async updateSubscription(subscriptionId, request) {
+    var _a;
+    const response = await this.httpClient.put(
+      `/api/stripe/subscriptions/${subscriptionId}`,
+      request,
+      true
+    );
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to update subscription");
+    }
+    return response.data;
+  }
+  // Customer Portal
+  /**
+   * Create a customer portal session
+   * @param request - Portal session parameters
+   * @returns Promise<CustomerPortalSession>
+   */
+  async createCustomerPortalSession(request) {
+    var _a;
+    const response = await this.httpClient.post(
+      "/api/stripe/customer-portal",
+      request,
+      true
+    );
+    if (!response.success || !response.data) {
+      throw new Error(((_a = response.error) == null ? void 0 : _a.message) || "Failed to create customer portal session");
+    }
+    return response.data;
   }
   // Utility Methods
-  isAuthenticated() {
-    return !!this.accessToken;
+  /**
+   * Create a one-time payment checkout session
+   * Convenience method for simple one-time payments
+   * @param params - Payment parameters
+   * @returns Promise<CheckoutSession>
+   */
+  async createPaymentCheckout(params) {
+    const lineItems = [];
+    if (params.price_id) {
+      lineItems.push({
+        price_id: params.price_id,
+        quantity: params.quantity || 1
+      });
+    } else if (params.product_name && params.amount && params.currency) {
+      lineItems.push({
+        quantity: params.quantity || 1,
+        price_data: {
+          currency: params.currency,
+          unit_amount: params.amount,
+          product_data: {
+            name: params.product_name
+          }
+        }
+      });
+    } else {
+      throw new Error("Either price_id or (product_name, amount, currency) must be provided");
+    }
+    return this.createCheckoutSession({
+      mode: "payment",
+      line_items: lineItems,
+      success_url: params.success_url,
+      cancel_url: params.cancel_url,
+      ...params.metadata && { metadata: params.metadata }
+    });
   }
-  getAccessToken() {
-    return this.accessToken;
+  /**
+   * Create a subscription checkout session
+   * Convenience method for subscription creation
+   * @param params - Subscription parameters
+   * @returns Promise<CheckoutSession>
+   */
+  async createSubscriptionCheckout(params) {
+    return this.createCheckoutSession({
+      mode: "subscription",
+      line_items: [{
+        price_id: params.price_id,
+        quantity: 1
+      }],
+      success_url: params.success_url,
+      cancel_url: params.cancel_url,
+      subscription_data: {
+        ...params.trial_period_days !== void 0 && { trial_period_days: params.trial_period_days },
+        ...params.metadata && { metadata: params.metadata }
+      }
+    });
   }
+};
+
+// index.ts
+var SweetPotatoSDK = class {
+  constructor(config) {
+    if (!config.apiUrl) {
+      throw new Error("apiUrl is required");
+    }
+    this.httpClient = new HttpClient(config);
+    this.auth = new AuthService(this.httpClient);
+    this.payments = new PaymentsService(this.httpClient);
+    this.isLocalMode = this.httpClient["isLocalMode"] || false;
+    if (this.isLocalMode) {
+      console.log("[SPAPS SDK] Initialized in local development mode");
+      console.log("[SPAPS SDK] API URL:", config.apiUrl);
+      console.log("[SPAPS SDK] Authentication will be automatic");
+    }
+  }
+  /**
+   * Set access token for authenticated requests
+   * @param token - Access token
+   */
   setAccessToken(token) {
-    this.accessToken = token;
+    this.httpClient.setAccessToken(token);
+  }
+  /**
+   * Clear access token
+   */
+  clearAccessToken() {
+    this.httpClient.clearAccessToken();
+  }
+  /**
+   * Get SDK configuration
+   */
+  getConfig() {
+    return {
+      apiUrl: this.httpClient["config"].apiUrl,
+      timeout: this.httpClient["config"].timeout,
+      retries: this.httpClient["config"].retries
+    };
+  }
+  /**
+   * Health check endpoint
+   * @returns Promise<boolean>
+   */
+  async healthCheck() {
+    try {
+      const response = await this.httpClient.get("/api/health");
+      return response.success;
+    } catch (e) {
+      return false;
+    }
+  }
+  /**
+   * Make a custom authenticated request
+   * This allows advanced users to make direct API calls not covered by the SDK
+   */
+  async request(method, url, data, requiresAuth = false) {
+    return this.httpClient.request({
+      method,
+      url,
+      data,
+      requiresAuth
+    });
+  }
+};
+function createSweetPotatoSDK(config) {
+  return new SweetPotatoSDK(config);
+}
+var _TokenManager = class _TokenManager {
+  /**
+   * Get localStorage instance (browser or test environment)
+   */
+  static getStorage() {
+    var _a, _b;
+    if (typeof globalThis !== "undefined" && globalThis.localStorage) {
+      return globalThis.localStorage;
+    }
+    if (typeof globalThis !== "undefined" && ((_a = globalThis.window) == null ? void 0 : _a.localStorage)) {
+      return globalThis.window.localStorage;
+    }
+    if (typeof global !== "undefined" && ((_b = global.window) == null ? void 0 : _b.localStorage)) {
+      return global.window.localStorage;
+    }
+    return null;
+  }
+  /**
+   * Store tokens in localStorage (browser only)
+   */
+  static storeTokens(tokens) {
+    const localStorage = _TokenManager.getStorage();
+    if (localStorage) {
+      localStorage.setItem(_TokenManager.ACCESS_TOKEN_KEY, tokens.access_token);
+      localStorage.setItem(_TokenManager.REFRESH_TOKEN_KEY, tokens.refresh_token);
+      localStorage.setItem(_TokenManager.USER_KEY, JSON.stringify(tokens.user));
+    }
+  }
+  /**
+   * Get stored access token (browser only)
+   */
+  static getAccessToken() {
+    const localStorage = _TokenManager.getStorage();
+    return localStorage ? localStorage.getItem(_TokenManager.ACCESS_TOKEN_KEY) : null;
   }
-  isLocalMode() {
-    return this._isLocalMode;
+  /**
+   * Get stored refresh token (browser only)
+   */
+  static getRefreshToken() {
+    const localStorage = _TokenManager.getStorage();
+    return localStorage ? localStorage.getItem(_TokenManager.REFRESH_TOKEN_KEY) : null;
   }
-  async health() {
-    return this.client.get("/health");
+  /**
+   * Get stored user data (browser only)
+   */
+  static getStoredUser() {
+    const localStorage = _TokenManager.getStorage();
+    if (localStorage) {
+      const userData = localStorage.getItem(_TokenManager.USER_KEY);
+      return userData ? JSON.parse(userData) : null;
+    }
+    return null;
+  }
+  /**
+   * Clear all stored tokens and user data (browser only)
+   */
+  static clearTokens() {
+    const localStorage = _TokenManager.getStorage();
+    if (localStorage) {
+      localStorage.removeItem(_TokenManager.ACCESS_TOKEN_KEY);
+      localStorage.removeItem(_TokenManager.REFRESH_TOKEN_KEY);
+      localStorage.removeItem(_TokenManager.USER_KEY);
+    }
+  }
+  /**
+   * Check if access token is expired (basic check, doesn't verify signature)
+   */
+  static isTokenExpired(token) {
+    try {
+      const parts = token.split(".");
+      if (parts.length !== 3 || !parts[1]) return true;
+      const payload = JSON.parse(atob(parts[1]));
+      const currentTime = Math.floor(Date.now() / 1e3);
+      return payload.exp < currentTime;
+    } catch (e) {
+      return true;
+    }
+  }
+  /**
+   * Auto-refresh token if needed
+   */
+  static async autoRefreshToken(sdk) {
+    const accessToken = _TokenManager.getAccessToken();
+    const refreshToken = _TokenManager.getRefreshToken();
+    if (!accessToken || !refreshToken) {
+      return false;
+    }
+    if (!_TokenManager.isTokenExpired(accessToken)) {
+      sdk.setAccessToken(accessToken);
+      return true;
+    }
+    try {
+      const newTokens = await sdk.auth.refreshToken(refreshToken);
+      _TokenManager.storeTokens(newTokens);
+      return true;
+    } catch (e) {
+      _TokenManager.clearTokens();
+      return false;
+    }
+  }
+};
+_TokenManager.ACCESS_TOKEN_KEY = "sweet_potato_access_token";
+_TokenManager.REFRESH_TOKEN_KEY = "sweet_potato_refresh_token";
+_TokenManager.USER_KEY = "sweet_potato_user";
+var TokenManager = _TokenManager;
+var WalletUtils = class _WalletUtils {
+  /**
+   * Detect chain type from wallet address
+   */
+  static detectChainType(address) {
+    if (/^0x[a-fA-F0-9]{40}$/.test(address)) {
+      return "ethereum";
+    }
+    if (/^bc1[a-z0-9]{39,59}$/.test(address)) {
+      return "bitcoin";
+    }
+    if (/^[1-9A-HJ-NP-Za-km-z]{32}$/.test(address) || /^[1-9A-HJ-NP-Za-km-z]{44}$/.test(address)) {
+      return "solana";
+    }
+    if (/^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$/.test(address) && address.length >= 26 && address.length <= 35) {
+      return "bitcoin";
+    }
+    if (/^[1-9A-HJ-NP-Za-km-z]{35,44}$/.test(address)) {
+      return "solana";
+    }
+    return null;
+  }
+  /**
+   * Validate wallet address format
+   */
+  static isValidAddress(address, chainType) {
+    if (!chainType) {
+      chainType = _WalletUtils.detectChainType(address) || "ethereum";
+    }
+    switch (chainType) {
+      case "solana":
+        return /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address);
+      case "ethereum":
+      case "base":
+        return /^0x[a-fA-F0-9]{40}$/.test(address);
+      case "bitcoin":
+        return /^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$/.test(address) || /^bc1[a-z0-9]{39,59}$/.test(address);
+      default:
+        return false;
+    }
   }
 };
-var index_default = SPAPSClient;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  SPAPS,
-  SPAPSClient,
-  SweetPotatoSDK
+  AuthService,
+  HttpClient,
+  PaymentsService,
+  SweetPotatoAPIError,
+  SweetPotatoSDK,
+  TokenManager,
+  WalletUtils,
+  createSweetPotatoSDK
 });