@closeloop/sdk 0.1.0

package/dist/nextjs.js

@@ -0,0 +1,955 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/nextjs.ts
+var nextjs_exports = {};
+__export(nextjs_exports, {
+  AuthenticationError: () => AuthenticationError,
+  CloseLoop: () => CloseLoop,
+  CloseLoopError: () => CloseLoopError,
+  CreditsExpiredError: () => CreditsExpiredError,
+  InsufficientCreditsError: () => InsufficientCreditsError,
+  NetworkError: () => NetworkError,
+  NotFoundError: () => NotFoundError,
+  RateLimitError: () => RateLimitError,
+  ValidationError: () => ValidationError,
+  consumeCreditsAfterRequest: () => consumeCreditsAfterRequest,
+  creditGate: () => creditGate
+});
+module.exports = __toCommonJS(nextjs_exports);
+var import_server = require("next/server");
+
+// src/schemas/validation.ts
+var import_zod = require("zod");
+var walletAddressSchema = import_zod.z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum wallet address");
+var planIdSchema = import_zod.z.string().min(1, "Plan ID is required").max(100, "Plan ID too long");
+var balanceIdSchema = import_zod.z.string().min(1, "Balance ID is required").max(100, "Balance ID too long");
+var creditAmountSchema = import_zod.z.number().int("Amount must be an integer").positive("Amount must be positive").max(1e9, "Amount exceeds maximum");
+var paginationLimitSchema = import_zod.z.number().int().positive().max(100, "Limit cannot exceed 100");
+var transactionTypeSchema = import_zod.z.enum([
+  "PURCHASE",
+  "CONSUMPTION",
+  "REFUND",
+  "EXPIRATION"
+]);
+var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function sanitizeMetadata(metadata) {
+  if (!metadata) return void 0;
+  const clean = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of Object.entries(metadata)) {
+    if (DANGEROUS_KEYS.has(key)) continue;
+    clean[key] = value;
+  }
+  return Object.freeze(clean);
+}
+var verifyCreditsSchema = import_zod.z.object({
+  walletAddress: walletAddressSchema,
+  planId: planIdSchema,
+  amount: creditAmountSchema
+});
+var consumeCreditsSchema = import_zod.z.object({
+  walletAddress: walletAddressSchema,
+  planId: planIdSchema,
+  amount: creditAmountSchema,
+  consumedBy: import_zod.z.string().max(100).optional(),
+  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
+  idempotencyKey: import_zod.z.string().max(100).optional()
+});
+var batchConsumeSchema = import_zod.z.object({
+  operations: import_zod.z.array(
+    import_zod.z.object({
+      walletAddress: walletAddressSchema,
+      planId: planIdSchema,
+      amount: creditAmountSchema,
+      consumedBy: import_zod.z.string().max(100).optional(),
+      metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+    })
+  ).min(1, "At least one operation required").max(100, "Maximum 100 operations per batch"),
+  atomic: import_zod.z.boolean().optional()
+});
+var getBalanceSchema = import_zod.z.object({
+  walletAddress: walletAddressSchema,
+  planId: planIdSchema
+});
+var listBalancesSchema = import_zod.z.object({
+  walletAddress: walletAddressSchema,
+  activeOnly: import_zod.z.boolean().optional(),
+  limit: paginationLimitSchema.optional(),
+  cursor: import_zod.z.string().max(200).optional()
+});
+var listTransactionsSchema = import_zod.z.object({
+  balanceId: balanceIdSchema,
+  type: transactionTypeSchema.optional(),
+  limit: paginationLimitSchema.optional(),
+  cursor: import_zod.z.string().max(200).optional()
+});
+var webhookEventTypeSchema = import_zod.z.enum([
+  "payment.success",
+  "credits.low",
+  "credits.expired"
+]);
+var webhookEventSchema = import_zod.z.object({
+  type: webhookEventTypeSchema,
+  id: import_zod.z.string().min(1),
+  createdAt: import_zod.z.string(),
+  data: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())
+});
+var paymentSuccessPayloadSchema = import_zod.z.object({
+  transactionId: import_zod.z.string(),
+  planId: import_zod.z.string(),
+  planName: import_zod.z.string(),
+  amount: import_zod.z.number(),
+  requests: import_zod.z.number().nullable(),
+  creditAmount: import_zod.z.number().nullable(),
+  transactionHash: import_zod.z.string(),
+  payerAddress: import_zod.z.string(),
+  accessType: import_zod.z.string()
+});
+var creditsLowPayloadSchema = import_zod.z.object({
+  walletAddress: import_zod.z.string(),
+  planId: import_zod.z.string(),
+  remainingCredits: import_zod.z.number(),
+  threshold: import_zod.z.number()
+});
+var creditsExpiredPayloadSchema = import_zod.z.object({
+  walletAddress: import_zod.z.string(),
+  planId: import_zod.z.string(),
+  expiredCredits: import_zod.z.number(),
+  expiresAt: import_zod.z.string()
+});
+
+// src/utils/errors.ts
+var CloseLoopError = class extends Error {
+  constructor(message, code, statusCode, details) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "CloseLoopError";
+  }
+};
+var InsufficientCreditsError = class extends CloseLoopError {
+  constructor(remainingCredits, requiredCredits) {
+    super(
+      `Insufficient credits: ${remainingCredits} available, ${requiredCredits} required`,
+      "INSUFFICIENT_CREDITS",
+      402
+    );
+    this.remainingCredits = remainingCredits;
+    this.requiredCredits = requiredCredits;
+    this.name = "InsufficientCreditsError";
+  }
+};
+var CreditsExpiredError = class extends CloseLoopError {
+  constructor(expiresAt) {
+    super(
+      `Credits expired at ${expiresAt.toISOString()}`,
+      "CREDITS_EXPIRED",
+      410
+    );
+    this.expiresAt = expiresAt;
+    this.name = "CreditsExpiredError";
+  }
+};
+var AuthenticationError = class extends CloseLoopError {
+  constructor(message = "Invalid API key") {
+    super(message, "AUTHENTICATION_ERROR", 401);
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends CloseLoopError {
+  constructor(retryAfter) {
+    super("Rate limit exceeded", "RATE_LIMIT", 429);
+    this.retryAfter = retryAfter;
+    this.name = "RateLimitError";
+  }
+};
+var NetworkError = class extends CloseLoopError {
+  constructor(message, cause) {
+    super(message, "NETWORK_ERROR");
+    this.cause = cause;
+    this.name = "NetworkError";
+  }
+};
+var NotFoundError = class extends CloseLoopError {
+  constructor(resource) {
+    super(`${resource} not found`, "NOT_FOUND", 404);
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends CloseLoopError {
+  constructor(message, field) {
+    super(message, "VALIDATION_ERROR", 400);
+    this.field = field;
+    this.name = "ValidationError";
+  }
+};
+
+// src/constants.ts
+var DEFAULT_BASE_URL = "https://closeloop.app";
+var DEFAULT_TIMEOUT = 3e4;
+var SDK_VERSION = "0.1.0";
+var USER_AGENT = `closeloop-node/${SDK_VERSION}`;
+
+// src/utils/validation.ts
+function validateInput(schema, data) {
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    throw new CloseLoopError(
+      `Validation error: ${result.error?.message || "Invalid input"}`,
+      "VALIDATION_ERROR",
+      400
+    );
+  }
+  return result.data;
+}
+
+// src/resources/balances.ts
+var ENDPOINTS = {
+  BALANCE: "/api/credit/balance",
+  BALANCES: "/api/credit/balances",
+  STATS: "/api/credit/stats"
+};
+var Balances = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get a specific credit balance for a wallet and plan.
+   *
+   * @example
+   * ```typescript
+   * const balance = await client.balances.get({
+   *   walletAddress: "0x1234...",
+   *   planId: "plan_abc123"
+   * })
+   *
+   * if (balance) {
+   *   console.log(`Credits: ${balance.remainingCredits}/${balance.totalCredits}`)
+   * }
+   * ```
+   *
+   * @returns The credit balance, or null if not found
+   * @throws {CloseLoopError} When input validation fails
+   */
+  async get(params) {
+    const validated = validateInput(getBalanceSchema, params);
+    const query = this.buildQueryString({
+      wallet: validated.walletAddress,
+      plan: validated.planId
+    });
+    try {
+      return await this.http.request({
+        method: "GET",
+        path: `${ENDPOINTS.BALANCE}?${query}`
+      });
+    } catch (error) {
+      if (error instanceof NotFoundError) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * List all credit balances for a wallet.
+   *
+   * @example
+   * ```typescript
+   * const { balances, nextCursor } = await client.balances.list({
+   *   walletAddress: "0x1234...",
+   *   activeOnly: true,
+   *   limit: 10
+   * })
+   *
+   * for (const balance of balances) {
+   *   console.log(`${balance.planName}: ${balance.remainingCredits} credits`)
+   * }
+   *
+   * // Paginate if needed
+   * if (nextCursor) {
+   *   const nextPage = await client.balances.list({
+   *     walletAddress: "0x1234...",
+   *     cursor: nextCursor
+   *   })
+   * }
+   * ```
+   *
+   * @throws {CloseLoopError} When input validation fails
+   */
+  async list(params) {
+    const validated = validateInput(listBalancesSchema, params);
+    const query = this.buildQueryString({
+      wallet: validated.walletAddress,
+      activeOnly: validated.activeOnly,
+      limit: validated.limit,
+      cursor: validated.cursor
+    });
+    return this.http.request({
+      method: "GET",
+      path: `${ENDPOINTS.BALANCES}?${query}`
+    });
+  }
+  /**
+   * Get transaction history for a balance.
+   *
+   * @example
+   * ```typescript
+   * const { transactions } = await client.balances.transactions({
+   *   balanceId: "bal_xyz",
+   *   type: "CONSUMPTION",
+   *   limit: 50
+   * })
+   *
+   * for (const tx of transactions) {
+   *   console.log(`${tx.type}: ${tx.amount} - ${tx.description}`)
+   * }
+   * ```
+   *
+   * @throws {CloseLoopError} When input validation fails
+   */
+  async transactions(params) {
+    const validated = validateInput(listTransactionsSchema, params);
+    const query = this.buildQueryString({
+      type: validated.type,
+      limit: validated.limit,
+      cursor: validated.cursor
+    });
+    const basePath = `${ENDPOINTS.BALANCE}/${encodeURIComponent(validated.balanceId)}/transactions`;
+    const path = query ? `${basePath}?${query}` : basePath;
+    return this.http.request({
+      method: "GET",
+      path
+    });
+  }
+  /**
+   * Get aggregated stats for a wallet's credits.
+   *
+   * @example
+   * ```typescript
+   * const stats = await client.balances.stats("0x1234...")
+   * console.log(`Total: ${stats.totalCredits}, Used: ${stats.totalUsed}`)
+   * ```
+   *
+   * @throws {CloseLoopError} When input validation fails
+   */
+  async stats(walletAddress) {
+    validateInput(walletAddressSchema, walletAddress);
+    const query = this.buildQueryString({ wallet: walletAddress });
+    return this.http.request({
+      method: "GET",
+      path: `${ENDPOINTS.STATS}?${query}`
+    });
+  }
+  // ==========================================================================
+  // Private Helpers
+  // ==========================================================================
+  /**
+   * Build URL query string from params, filtering out undefined values
+   */
+  buildQueryString(params) {
+    const query = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0) {
+        query.set(key, String(value));
+      }
+    }
+    return query.toString();
+  }
+};
+
+// src/resources/credits.ts
+var ENDPOINTS2 = {
+  VERIFY: "/api/credit/verify",
+  CONSUME: "/api/credit/consume",
+  BATCH_CONSUME: "/api/credit/consume/batch"
+};
+var Credits = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Verify if a user has enough credits without consuming them.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.credits.verify({
+   *   walletAddress: "0x1234...",
+   *   planId: "plan_abc123",
+   *   amount: 10
+   * })
+   *
+   * if (result.hasEnoughCredits) {
+   *   // Proceed with service
+   * }
+   * ```
+   *
+   * @throws {CloseLoopError} When input validation fails
+   */
+  async verify(params) {
+    const validated = validateInput(verifyCreditsSchema, params);
+    return this.http.request({
+      method: "POST",
+      path: ENDPOINTS2.VERIFY,
+      body: validated
+    });
+  }
+  /**
+   * Consume credits from a user's balance.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.credits.consume({
+   *   walletAddress: "0x1234...",
+   *   planId: "plan_abc123",
+   *   amount: 1,
+   *   consumedBy: "ai-generation",
+   *   metadata: { requestId: "req_xyz" }
+   * })
+   *
+   * console.log(`Remaining: ${result.remainingCredits}`)
+   * ```
+   *
+   * @throws {InsufficientCreditsError} When user doesn't have enough credits
+   * @throws {CreditsExpiredError} When credits have expired
+   * @throws {CloseLoopError} When input validation fails
+   */
+  async consume(params) {
+    const validated = validateInput(consumeCreditsSchema, params);
+    return this.http.request({
+      method: "POST",
+      path: ENDPOINTS2.CONSUME,
+      body: this.buildConsumeBody(validated),
+      headers: this.buildIdempotencyHeaders(validated.idempotencyKey)
+    });
+  }
+  /**
+   * Verify and consume credits in a single atomic operation.
+   * This is useful when you want to ensure credits are available
+   * before consuming them, without race conditions.
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   const result = await client.credits.verifyAndConsume({
+   *     walletAddress: "0x1234...",
+   *     planId: "plan_abc123",
+   *     amount: 5,
+   *     consumedBy: "batch-processing"
+   *   })
+   *   // Credits were verified and consumed
+   * } catch (error) {
+   *   if (error instanceof InsufficientCreditsError) {
+   *     // Handle insufficient credits
+   *   }
+   * }
+   * ```
+   *
+   * @throws {InsufficientCreditsError} When user doesn't have enough credits
+   * @throws {CreditsExpiredError} When credits have expired
+   * @throws {CloseLoopError} When input validation fails
+   */
+  async verifyAndConsume(params) {
+    const validated = validateInput(consumeCreditsSchema, params);
+    const verification = await this.http.request({
+      method: "POST",
+      path: ENDPOINTS2.VERIFY,
+      body: {
+        walletAddress: validated.walletAddress,
+        planId: validated.planId,
+        amount: validated.amount
+      }
+    });
+    this.assertCreditsAvailable(verification, validated.amount);
+    return this.http.request({
+      method: "POST",
+      path: ENDPOINTS2.CONSUME,
+      body: this.buildConsumeBody(validated),
+      headers: this.buildIdempotencyHeaders(validated.idempotencyKey)
+    });
+  }
+  /**
+   * Consume credits in batch.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.credits.batchConsume({
+   *   operations: [
+   *     { walletAddress: "0x1234...", planId: "plan_a", amount: 1 },
+   *     { walletAddress: "0x5678...", planId: "plan_b", amount: 2 }
+   *   ],
+   *   atomic: false // Allow partial success
+   * })
+   *
+   * console.log(`Success: ${result.successCount}, Failed: ${result.failedCount}`)
+   * ```
+   *
+   * @throws {CloseLoopError} When input validation fails
+   */
+  async batchConsume(params) {
+    const validated = validateInput(batchConsumeSchema, params);
+    const sanitizedOperations = validated.operations.map((op) => ({
+      ...op,
+      metadata: sanitizeMetadata(op.metadata)
+    }));
+    return this.http.request({
+      method: "POST",
+      path: ENDPOINTS2.BATCH_CONSUME,
+      body: {
+        operations: sanitizedOperations,
+        atomic: validated.atomic
+      }
+    });
+  }
+  // ==========================================================================
+  // Private Helpers
+  // ==========================================================================
+  /**
+   * Build consumption request body with sanitized metadata
+   */
+  buildConsumeBody(validated) {
+    return {
+      walletAddress: validated.walletAddress,
+      planId: validated.planId,
+      amount: validated.amount,
+      consumedBy: validated.consumedBy,
+      metadata: sanitizeMetadata(validated.metadata)
+    };
+  }
+  /**
+   * Build idempotency headers if key is provided
+   */
+  buildIdempotencyHeaders(idempotencyKey) {
+    if (!idempotencyKey) return {};
+    return { "Idempotency-Key": idempotencyKey };
+  }
+  /**
+   * Assert credits are available, throw typed errors if not
+   */
+  assertCreditsAvailable(verification, requiredAmount) {
+    if (!verification.hasEnoughCredits) {
+      throw new InsufficientCreditsError(
+        verification.remainingCredits,
+        requiredAmount
+      );
+    }
+    if (verification.expiresAt) {
+      const expirationDate = new Date(verification.expiresAt);
+      if (expirationDate < /* @__PURE__ */ new Date()) {
+        throw new CreditsExpiredError(expirationDate);
+      }
+    }
+  }
+};
+
+// src/utils/crypto.ts
+var import_crypto = require("crypto");
+function generateSignature(payload, secret) {
+  return (0, import_crypto.createHmac)("sha256", secret).update(payload).digest("hex");
+}
+function verifySignature(payload, signature, secret) {
+  const expectedSignature = generateSignature(payload, secret);
+  if (signature.length !== expectedSignature.length) {
+    return false;
+  }
+  return (0, import_crypto.timingSafeEqual)(Buffer.from(signature), Buffer.from(expectedSignature));
+}
+
+// src/resources/webhooks.ts
+var ERROR_CODES = {
+  VALIDATION: "VALIDATION_ERROR",
+  INVALID_SIGNATURE: "INVALID_SIGNATURE",
+  INVALID_PAYLOAD: "INVALID_PAYLOAD"
+};
+var Webhooks = class {
+  /**
+   * Verify a webhook signature and parse the event.
+   *
+   * @example
+   * ```typescript
+   * // Express handler
+   * app.post("/webhook", (req, res) => {
+   *   try {
+   *     const event = client.webhooks.verify({
+   *       payload: req.body,
+   *       signature: req.headers["x-closeloop-signature"],
+   *       secret: process.env.WEBHOOK_SECRET!
+   *     })
+   *
+   *     if (client.webhooks.isPaymentSuccess(event)) {
+   *       const { creditAmount, payerAddress } = event.data
+   *       // Handle credit purchase
+   *     }
+   *
+   *     res.json({ received: true })
+   *   } catch (error) {
+   *     res.status(400).json({ error: "Invalid signature" })
+   *   }
+   * })
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Next.js App Router
+   * export async function POST(request: Request) {
+   *   const payload = await request.text()
+   *   const signature = request.headers.get("x-closeloop-signature")!
+   *
+   *   const event = client.webhooks.verify({
+   *     payload,
+   *     signature,
+   *     secret: process.env.WEBHOOK_SECRET!
+   *   })
+   *
+   *   // Handle event...
+   *   return Response.json({ received: true })
+   * }
+   * ```
+   *
+   * @throws {CloseLoopError} When signature is invalid or payload is malformed
+   */
+  verify(params) {
+    this.validateRequiredParams(params);
+    const payloadString = this.normalizePayload(params.payload);
+    this.verifySignatureOrThrow(payloadString, params.signature, params.secret);
+    const parsed = this.parseJsonOrThrow(payloadString);
+    return this.validateEventStructure(parsed);
+  }
+  /**
+   * Type guard for payment.success events
+   * Also validates the payload structure
+   *
+   * @example
+   * ```typescript
+   * if (client.webhooks.isPaymentSuccess(event)) {
+   *   // TypeScript knows event.data is PaymentSuccessPayload
+   *   console.log(event.data.creditAmount)
+   * }
+   * ```
+   */
+  isPaymentSuccess(event) {
+    return event.type === "payment.success" && paymentSuccessPayloadSchema.safeParse(event.data).success;
+  }
+  /**
+   * Type guard for credits.low events
+   * Also validates the payload structure
+   *
+   * @example
+   * ```typescript
+   * if (client.webhooks.isCreditsLow(event)) {
+   *   // TypeScript knows event.data is CreditsLowPayload
+   *   console.log(`Low balance: ${event.data.remainingCredits}`)
+   * }
+   * ```
+   */
+  isCreditsLow(event) {
+    return event.type === "credits.low" && creditsLowPayloadSchema.safeParse(event.data).success;
+  }
+  /**
+   * Type guard for credits.expired events
+   * Also validates the payload structure
+   *
+   * @example
+   * ```typescript
+   * if (client.webhooks.isCreditsExpired(event)) {
+   *   // TypeScript knows event.data is CreditsExpiredPayload
+   *   console.log(`Expired: ${event.data.expiredCredits} credits`)
+   * }
+   * ```
+   */
+  isCreditsExpired(event) {
+    return event.type === "credits.expired" && creditsExpiredPayloadSchema.safeParse(event.data).success;
+  }
+  // ==========================================================================
+  // Private Helpers
+  // ==========================================================================
+  /**
+   * Validate that all required parameters are present
+   */
+  validateRequiredParams(params) {
+    if (!params.payload) {
+      throw new CloseLoopError(
+        "Webhook payload is required",
+        ERROR_CODES.VALIDATION,
+        400
+      );
+    }
+    if (!params.signature) {
+      throw new CloseLoopError(
+        "Webhook signature is required",
+        ERROR_CODES.VALIDATION,
+        400
+      );
+    }
+    if (!params.secret) {
+      throw new CloseLoopError(
+        "Webhook secret is required",
+        ERROR_CODES.VALIDATION,
+        400
+      );
+    }
+  }
+  /**
+   * Convert payload to string regardless of input type
+   */
+  normalizePayload(payload) {
+    return typeof payload === "string" ? payload : payload.toString("utf8");
+  }
+  /**
+   * Verify HMAC signature or throw error
+   */
+  verifySignatureOrThrow(payload, signature, secret) {
+    if (!verifySignature(payload, signature, secret)) {
+      throw new CloseLoopError(
+        "Invalid webhook signature",
+        ERROR_CODES.INVALID_SIGNATURE,
+        401
+      );
+    }
+  }
+  /**
+   * Parse JSON payload or throw error
+   */
+  parseJsonOrThrow(payload) {
+    try {
+      return JSON.parse(payload);
+    } catch {
+      throw new CloseLoopError(
+        "Invalid webhook payload: could not parse JSON",
+        ERROR_CODES.INVALID_PAYLOAD,
+        400
+      );
+    }
+  }
+  /**
+   * Validate event structure using Zod schema
+   */
+  validateEventStructure(parsed) {
+    const result = webhookEventSchema.safeParse(parsed);
+    if (!result.success) {
+      throw new CloseLoopError(
+        "Invalid webhook payload structure",
+        ERROR_CODES.INVALID_PAYLOAD,
+        400
+      );
+    }
+    return result.data;
+  }
+};
+
+// src/utils/http.ts
+var HttpClient = class {
+  baseUrl;
+  apiKey;
+  timeout;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.apiKey = options.apiKey;
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+  }
+  /**
+   * Make an HTTP request to the CloseLoop API
+   */
+  async request(options) {
+    const url = `${this.baseUrl}${options.path}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: options.method,
+        headers: {
+          "Content-Type": "application/json",
+          "User-Agent": USER_AGENT,
+          "X-API-Key": this.apiKey,
+          ...options.headers
+        },
+        body: options.body ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        await this.handleErrorResponse(response);
+      }
+      if (response.status === 204) {
+        return {};
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof CloseLoopError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new NetworkError("Request timeout");
+      }
+      throw new NetworkError(
+        error instanceof Error ? error.message : "Network request failed",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  async handleErrorResponse(response) {
+    let errorData = {};
+    try {
+      const json = await response.json();
+      errorData = json;
+    } catch {
+    }
+    const message = errorData.message || `Request failed with status ${response.status}`;
+    switch (response.status) {
+      case 401:
+        throw new AuthenticationError(message);
+      case 404:
+        throw new NotFoundError(message);
+      case 429: {
+        const retryAfter = response.headers.get("Retry-After");
+        throw new RateLimitError(
+          retryAfter ? parseInt(retryAfter, 10) : void 0
+        );
+      }
+      default:
+        throw new CloseLoopError(
+          message,
+          errorData.code || "API_ERROR",
+          response.status,
+          errorData.details
+        );
+    }
+  }
+};
+
+// src/client.ts
+var CloseLoop = class {
+  httpClient;
+  /**
+   * Credit consumption and verification operations
+   */
+  credits;
+  /**
+   * Credit balance queries
+   */
+  balances;
+  /**
+   * Webhook signature verification utilities
+   */
+  webhooks;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error("CloseLoop API key is required");
+    }
+    const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+    this.httpClient = new HttpClient({
+      baseUrl,
+      apiKey: options.apiKey,
+      timeout: options.timeout
+    });
+    this.credits = new Credits(this.httpClient);
+    this.balances = new Balances(this.httpClient);
+    this.webhooks = new Webhooks();
+  }
+};
+
+// src/nextjs.ts
+function errorResponse(error, status, extra) {
+  return import_server.NextResponse.json({ error, ...extra }, { status });
+}
+function handleCreditError(error) {
+  if (error instanceof InsufficientCreditsError) {
+    return errorResponse("Insufficient credits", 402, {
+      required: error.requiredCredits,
+      remaining: error.remainingCredits
+    });
+  }
+  if (error instanceof CreditsExpiredError) {
+    return errorResponse("Credits expired", 410, {
+      expiredAt: error.expiresAt.toISOString()
+    });
+  }
+  if (error instanceof CloseLoopError) {
+    return errorResponse(error.message, error.statusCode || 500);
+  }
+  return null;
+}
+function creditGate(options) {
+  validateOptions(options);
+  const creditsRequired = options.creditsPerRequest ?? 1;
+  return async function middleware(request) {
+    const walletAddress = await options.getWalletAddress(request);
+    if (!walletAddress) {
+      return errorResponse("Wallet address required", 401);
+    }
+    if (!walletAddressSchema.safeParse(walletAddress).success) {
+      return errorResponse("Invalid wallet address format", 400);
+    }
+    try {
+      const verification = await options.client.credits.verify({
+        walletAddress,
+        planId: options.planId,
+        amount: creditsRequired
+      });
+      if (!verification.hasEnoughCredits) {
+        return errorResponse("Insufficient credits", 402, {
+          required: creditsRequired,
+          remaining: verification.remainingCredits
+        });
+      }
+      return createSuccessResponse(verification);
+    } catch (error) {
+      const handledResponse = handleCreditError(error);
+      if (handledResponse) return handledResponse;
+      throw error;
+    }
+  };
+}
+function validateOptions(options) {
+  if (!options.planId?.length) {
+    throw new Error("creditGate: planId is required");
+  }
+  if (!options.client) {
+    throw new Error("creditGate: CloseLoop client is required");
+  }
+  if (!options.getWalletAddress) {
+    throw new Error("creditGate: getWalletAddress function is required");
+  }
+}
+function createSuccessResponse(verification) {
+  const response = import_server.NextResponse.next();
+  response.headers.set(
+    "X-Credits-Remaining",
+    String(verification.remainingCredits)
+  );
+  return response;
+}
+async function consumeCreditsAfterRequest(client, params) {
+  await client.credits.consume(params);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthenticationError,
+  CloseLoop,
+  CloseLoopError,
+  CreditsExpiredError,
+  InsufficientCreditsError,
+  NetworkError,
+  NotFoundError,
+  RateLimitError,
+  ValidationError,
+  consumeCreditsAfterRequest,
+  creditGate
+});
+//# sourceMappingURL=nextjs.js.map