@t402/core 2.5.0 → 2.6.1

package/dist/cjs/http/index.js

@@ -23,7 +23,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 var http_exports = {};
 __export(http_exports, {
   HTTPFacilitatorClient: () => HTTPFacilitatorClient,
+  IntentClient: () => IntentClient,
   RouteConfigurationError: () => RouteConfigurationError,
+  StreamingClient: () => StreamingClient,
   decodePaymentRequiredHeader: () => decodePaymentRequiredHeader,
   decodePaymentResponseHeader: () => decodePaymentResponseHeader,
   decodePaymentSignatureHeader: () => decodePaymentSignatureHeader,
@@ -115,6 +117,38 @@ function safeBase64Decode(data) {
   return Buffer.from(data, "base64").toString("utf-8");
 }
 
+// src/errors.ts
+var T402PaymentError = class _T402PaymentError extends Error {
+  constructor(message, options) {
+    super(message);
+    __publicField(this, "cause");
+    __publicField(this, "phase");
+    __publicField(this, "retryable");
+    __publicField(this, "code");
+    this.name = "T402PaymentError";
+    this.cause = options?.cause;
+    this.phase = options?.phase ?? "unknown";
+    this.retryable = options?.retryable ?? false;
+    this.code = options?.code;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _T402PaymentError);
+    }
+  }
+  isRetryable() {
+    return this.retryable;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      phase: this.phase,
+      retryable: this.retryable,
+      code: this.code,
+      cause: this.cause?.message
+    };
+  }
+};
+
 // src/index.ts
 var t402Version = 2;
 
@@ -627,7 +661,11 @@ var HTTPFacilitatorClient = class {
     });
     if (!response.ok) {
       const errorText = await response.text().catch(() => response.statusText);
-      throw new Error(`Facilitator verify failed (${response.status}): ${errorText}`);
+      throw new T402PaymentError(`Facilitator verify failed (${response.status}): ${errorText}`, {
+        phase: "verification",
+        code: response.status,
+        retryable: response.status >= 500 || response.status === 429
+      });
     }
     return await response.json();
   }
@@ -636,12 +674,16 @@ var HTTPFacilitatorClient = class {
    *
    * @param paymentPayload - The payment to settle
    * @param paymentRequirements - The requirements for settlement
+   * @param options - Optional settings including idempotency key
    * @returns Settlement response
    */
-  async settle(paymentPayload, paymentRequirements) {
+  async settle(paymentPayload, paymentRequirements, options) {
     let headers = {
       "Content-Type": "application/json"
     };
+    if (options?.idempotencyKey) {
+      headers["Idempotency-Key"] = options.idempotencyKey;
+    }
     if (this._createAuthHeaders) {
       const authHeaders = await this.createAuthHeaders("settle");
       headers = { ...headers, ...authHeaders.headers };
@@ -657,7 +699,11 @@ var HTTPFacilitatorClient = class {
     });
     if (!response.ok) {
       const errorText = await response.text().catch(() => response.statusText);
-      throw new Error(`Facilitator settle failed (${response.status}): ${errorText}`);
+      throw new T402PaymentError(`Facilitator settle failed (${response.status}): ${errorText}`, {
+        phase: "settlement",
+        code: response.status,
+        retryable: response.status >= 500 || response.status === 429
+      });
     }
     return await response.json();
   }
@@ -680,7 +726,14 @@ var HTTPFacilitatorClient = class {
     });
     if (!response.ok) {
       const errorText = await response.text().catch(() => response.statusText);
-      throw new Error(`Facilitator getSupported failed (${response.status}): ${errorText}`);
+      throw new T402PaymentError(
+        `Facilitator getSupported failed (${response.status}): ${errorText}`,
+        {
+          phase: "unknown",
+          code: response.status,
+          retryable: response.status >= 500 || response.status === 429
+        }
+      );
     }
     return await response.json();
   }
@@ -742,8 +795,9 @@ var t402HTTPClient = class {
           "X-PAYMENT": encodePaymentSignatureHeader(paymentPayload)
         };
       default:
-        throw new Error(
-          `Unsupported t402 version: ${paymentPayload.t402Version}`
+        throw new T402PaymentError(
+          `Unsupported t402 version: ${paymentPayload.t402Version}`,
+          { phase: "submission" }
         );
     }
   }
@@ -762,7 +816,9 @@ var t402HTTPClient = class {
     if (body && body instanceof Object && "t402Version" in body && body.t402Version === 1) {
       return body;
     }
-    throw new Error("Invalid payment required response");
+    throw new T402PaymentError("Invalid payment required response", {
+      phase: "submission"
+    });
   }
   /**
    * Extracts payment settlement response from HTTP headers.
@@ -779,7 +835,9 @@ var t402HTTPClient = class {
     if (xPaymentResponse) {
       return decodePaymentResponseHeader(xPaymentResponse);
     }
-    throw new Error("Payment response header not found");
+    throw new T402PaymentError("Payment response header not found", {
+      phase: "settlement"
+    });
   }
   /**
    * Creates a payment payload for the given payment requirements.
@@ -793,6 +851,247 @@ var t402HTTPClient = class {
   }
 };
 
+// src/http/streamingClient.ts
+var DEFAULT_FACILITATOR_URL2 = "https://facilitator.t402.io";
+var StreamingClient = class {
+  constructor(config) {
+    __publicField(this, "url");
+    __publicField(this, "apiKey");
+    __publicField(this, "requesterAddress");
+    this.url = config?.url || DEFAULT_FACILITATOR_URL2;
+    this.apiKey = config?.apiKey;
+    this.requesterAddress = config?.requesterAddress;
+  }
+  /**
+   * Open a new payment stream
+   */
+  async openStream(params) {
+    return this.post("/v1/stream/open", params);
+  }
+  /**
+   * Update a stream with a new cumulative amount
+   */
+  async updateStream(params) {
+    return this.post("/v1/stream/update", params);
+  }
+  /**
+   * Close a stream and settle the final amount
+   */
+  async closeStream(params) {
+    return this.post("/v1/stream/close", params);
+  }
+  /**
+   * Get stream details by ID
+   */
+  async getStream(id, options) {
+    const params = new URLSearchParams();
+    if (options?.includeUpdates) params.set("include_updates", "true");
+    if (options?.includeStats) params.set("include_stats", "true");
+    const query = params.toString();
+    const path = `/v1/stream/${encodeURIComponent(id)}${query ? `?${query}` : ""}`;
+    return this.get(path);
+  }
+  /**
+   * Pause an active stream
+   */
+  async pauseStream(id) {
+    return this.post(`/v1/stream/${encodeURIComponent(id)}/pause`, {});
+  }
+  /**
+   * Resume a paused stream
+   */
+  async resumeStream(id) {
+    return this.post(`/v1/stream/${encodeURIComponent(id)}/resume`, {});
+  }
+  /**
+   * List streams with optional filters
+   */
+  async listStreams(filters) {
+    const params = new URLSearchParams();
+    if (filters?.network) params.set("network", filters.network);
+    if (filters?.payer) params.set("payer", filters.payer);
+    if (filters?.payee) params.set("payee", filters.payee);
+    if (filters?.status) {
+      for (const s of filters.status) params.append("status", s);
+    }
+    if (filters?.limit !== void 0) params.set("limit", String(filters.limit));
+    if (filters?.offset !== void 0) params.set("offset", String(filters.offset));
+    if (filters?.orderBy) params.set("orderBy", filters.orderBy);
+    if (filters?.orderDesc) params.set("orderDesc", "true");
+    const query = params.toString();
+    return this.get(`/v1/stream${query ? `?${query}` : ""}`);
+  }
+  // ============================================================================
+  // Internal HTTP helpers
+  // ============================================================================
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    if (this.requesterAddress) {
+      headers["X-Requester-Address"] = this.requesterAddress;
+    }
+    return headers;
+  }
+  async post(path, body) {
+    const response = await fetch(`${this.url}${path}`, {
+      method: "POST",
+      headers: this.buildHeaders(),
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => response.statusText);
+      throw new T402PaymentError(`Streaming API ${path} failed (${response.status}): ${errorText}`, {
+        phase: "unknown",
+        code: response.status,
+        retryable: response.status >= 500 || response.status === 429
+      });
+    }
+    return await response.json();
+  }
+  async get(path) {
+    const response = await fetch(`${this.url}${path}`, {
+      method: "GET",
+      headers: this.buildHeaders()
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => response.statusText);
+      throw new T402PaymentError(`Streaming API ${path} failed (${response.status}): ${errorText}`, {
+        phase: "unknown",
+        code: response.status,
+        retryable: response.status >= 500 || response.status === 429
+      });
+    }
+    return await response.json();
+  }
+};
+
+// src/http/intentClient.ts
+var DEFAULT_FACILITATOR_URL3 = "https://facilitator.t402.io";
+var IntentClient = class {
+  constructor(config) {
+    __publicField(this, "url");
+    __publicField(this, "apiKey");
+    this.url = config?.url || DEFAULT_FACILITATOR_URL3;
+    this.apiKey = config?.apiKey;
+  }
+  /**
+   * Create a new payment intent and get available routes
+   */
+  async createIntent(params) {
+    return this.post("/v1/intent", params);
+  }
+  /**
+   * Get intent details by ID
+   */
+  async getIntent(id) {
+    return this.get(`/v1/intent/${encodeURIComponent(id)}`);
+  }
+  /**
+   * Select a route for an intent
+   */
+  async selectRoute(id, params) {
+    return this.post(
+      `/v1/intent/${encodeURIComponent(id)}/route`,
+      params
+    );
+  }
+  /**
+   * Execute an intent with a signed authorization
+   */
+  async executeIntent(id, params) {
+    return this.post(
+      `/v1/intent/${encodeURIComponent(id)}/execute`,
+      params
+    );
+  }
+  /**
+   * Cancel a pending intent
+   */
+  async cancelIntent(id, params) {
+    return this.post(
+      `/v1/intent/${encodeURIComponent(id)}/cancel`,
+      params ?? {}
+    );
+  }
+  /**
+   * Refresh available routes for an intent
+   */
+  async refreshRoutes(id) {
+    return this.post(
+      `/v1/intent/${encodeURIComponent(id)}/refresh`,
+      {}
+    );
+  }
+  /**
+   * List intents with optional filters
+   */
+  async listIntents(filters) {
+    const params = new URLSearchParams();
+    if (filters?.payer) params.set("payer", filters.payer);
+    if (filters?.payee) params.set("payee", filters.payee);
+    if (filters?.status) {
+      for (const s of filters.status) params.append("status", s);
+    }
+    if (filters?.limit !== void 0) params.set("limit", String(filters.limit));
+    if (filters?.offset !== void 0) params.set("offset", String(filters.offset));
+    const query = params.toString();
+    return this.get(`/v1/intent${query ? `?${query}` : ""}`);
+  }
+  /**
+   * Get intent statistics (counts by status)
+   */
+  async getIntentStats() {
+    return this.get("/v1/intent/stats");
+  }
+  // ============================================================================
+  // Internal HTTP helpers
+  // ============================================================================
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    return headers;
+  }
+  async post(path, body) {
+    const response = await fetch(`${this.url}${path}`, {
+      method: "POST",
+      headers: this.buildHeaders(),
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => response.statusText);
+      throw new T402PaymentError(`Intent API ${path} failed (${response.status}): ${errorText}`, {
+        phase: "unknown",
+        code: response.status,
+        retryable: response.status >= 500 || response.status === 429
+      });
+    }
+    return await response.json();
+  }
+  async get(path) {
+    const response = await fetch(`${this.url}${path}`, {
+      method: "GET",
+      headers: this.buildHeaders()
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => response.statusText);
+      throw new T402PaymentError(`Intent API ${path} failed (${response.status}): ${errorText}`, {
+        phase: "unknown",
+        code: response.status,
+        retryable: response.status >= 500 || response.status === 429
+      });
+    }
+    return await response.json();
+  }
+};
+
 // src/http/index.ts
 function encodePaymentSignatureHeader(paymentPayload) {
   return safeBase64Encode(JSON.stringify(paymentPayload));
@@ -830,7 +1129,9 @@ function decodePaymentResponseHeader(paymentResponseHeader) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   HTTPFacilitatorClient,
+  IntentClient,
   RouteConfigurationError,
+  StreamingClient,
   decodePaymentRequiredHeader,
   decodePaymentResponseHeader,
   decodePaymentSignatureHeader,