@t402/core 2.6.0 → 2.7.0

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,
@@ -672,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 };
@@ -845,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));
@@ -882,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,