@moneymq/sdk 0.3.2 → 0.7.0

package/dist/index.mjs

@@ -1,4 +1,12 @@
 // src/catalog.ts
+var PaymentRequiredError = class extends Error {
+  constructor(message, paymentRequirements, raw) {
+    super(message);
+    this.paymentRequirements = paymentRequirements;
+    this.raw = raw;
+    this.name = "PaymentRequiredError";
+  }
+};
 var ProductsAPI = class {
   constructor(config) {
     this.config = config;
@@ -39,7 +47,15 @@ var ProductsAPI = class {
     if (params?.limit) query.set("limit", String(params.limit));
     if (params?.startingAfter) query.set("starting_after", params.startingAfter);
     const queryString = query.toString();
-    return this.request("GET", `/catalog/v1/products${queryString ? `?${queryString}` : ""}`);
+    const result = await this.request(
+      "GET",
+      `/catalog/v1/products${queryString ? `?${queryString}` : ""}`
+    );
+    result.data = result.data.map((product) => ({
+      ...product,
+      accessUrl: `${this.config.endpoint}/catalog/v1/products/${product.id}/access`
+    }));
+    return result;
   }
   /**
    * Update a product
@@ -53,6 +69,59 @@ var ProductsAPI = class {
   async delete(id) {
     return this.request("DELETE", `/catalog/v1/products/${id}`);
   }
+  /**
+   * Access a product - gated by x402 payment
+   *
+   * This endpoint requires payment. If no payment header is provided (or payment is invalid),
+   * throws a PaymentRequiredError with the payment requirements.
+   *
+   * @example
+   * ```ts
+   * try {
+   *   // First attempt without payment - will throw PaymentRequiredError
+   *   const access = await moneymq.catalog.products.access('surfnet-max');
+   * } catch (error) {
+   *   if (error instanceof PaymentRequiredError) {
+   *     // Get payment requirements and create payment
+   *     const requirements = error.paymentRequirements[0];
+   *     const paymentHeader = await createPayment(requirements);
+   *
+   *     // Retry with payment
+   *     const access = await moneymq.catalog.products.access('surfnet-max', {
+   *       paymentHeader,
+   *     });
+   *   }
+   * }
+   * ```
+   */
+  async access(id, params) {
+    const url = `${this.config.endpoint}/catalog/v1/products/${id}/access`;
+    const headers = { "Content-Type": "application/json" };
+    if (this.config.secret) {
+      headers["Authorization"] = `Bearer ${this.config.secret}`;
+    }
+    if (params?.paymentHeader) {
+      headers["X-Payment"] = params.paymentHeader;
+    }
+    const response = await fetch(url, {
+      method: "GET",
+      headers
+    });
+    if (response.status === 402) {
+      const x402Response = await response.json().catch(() => ({}));
+      const paymentRequirements = x402Response.accepts || [];
+      throw new PaymentRequiredError(
+        "Payment required",
+        paymentRequirements,
+        x402Response
+      );
+    }
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(errorData.message || `Request failed: ${response.status}`);
+    }
+    return response.json();
+  }
 };
 var PricesAPI = class {
   constructor(config) {
@@ -256,15 +325,92 @@ var WebhooksAPI = class {
     return this.request("POST", "/payment/v1/webhooks/test", { event, data });
   }
 };
+var PaymentIntentsAPI = class {
+  constructor(config) {
+    this.request = createRequester(config);
+  }
+  /**
+   * Create a payment intent
+   * Use this for simple payments without the full checkout session flow
+   */
+  async create(params) {
+    return this.request("POST", "/catalog/v1/payment_intents", params);
+  }
+  /**
+   * Retrieve a payment intent
+   */
+  async retrieve(id) {
+    return this.request("GET", `/catalog/v1/payment_intents/${id}`);
+  }
+  /**
+   * Confirm a payment intent
+   * This triggers the actual payment (and x402 flow if required)
+   */
+  async confirm(id) {
+    return this.request("POST", `/catalog/v1/payment_intents/${id}/confirm`, {});
+  }
+  /**
+   * Cancel a payment intent
+   */
+  async cancel(id) {
+    return this.request("POST", `/catalog/v1/payment_intents/${id}/cancel`, {});
+  }
+};
 var PaymentAPI = class {
   constructor(config) {
     this.request = createRequester(config);
     this.checkout = new CheckoutAPI(config);
+    this.intents = new PaymentIntentsAPI(config);
     this.links = new LinksAPI(config);
     this.customers = new CustomersAPI(config);
     this.payouts = new PayoutsAPI(config);
     this.webhooks = new WebhooksAPI(config);
   }
+  /**
+   * Simple one-liner payment - creates a checkout session with inline product data
+   *
+   * @example
+   * ```ts
+   * const result = await moneymq.payment.pay({
+   *   amount: 999,
+   *   currency: 'usd',
+   *   productName: 'Pro Plan',
+   *   productId: 'pro-plan',
+   *   customer: 'wallet_address',
+   * });
+   * ```
+   */
+  async pay(params) {
+    const session = await this.request("POST", "/catalog/v1/checkout/sessions", {
+      line_items: [
+        {
+          price_data: {
+            currency: params.currency,
+            unit_amount: params.amount,
+            product_data: {
+              name: params.productName,
+              description: params.description,
+              metadata: {
+                product_id: params.productId || params.productName.toLowerCase().replace(/\s+/g, "-")
+              }
+            }
+          },
+          quantity: 1
+        }
+      ],
+      customer: params.customer,
+      metadata: params.metadata,
+      mode: "payment"
+    });
+    return {
+      sessionId: session.id,
+      paymentIntentId: session.payment_intent,
+      clientSecret: session.client_secret,
+      amount: session.amount_total,
+      currency: session.currency,
+      status: "requires_confirmation"
+    };
+  }
   /**
    * Retrieve a payment by ID
    */
@@ -285,8 +431,329 @@ var PaymentAPI = class {
   }
 };
 
+// src/config.ts
+async function fetchConfig(apiUrl) {
+  const response = await fetch(`${apiUrl}/config`);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch config: ${response.status}`);
+  }
+  return response.json();
+}
+async function getRpcUrl(apiUrl, fallback = "https://api.devnet.solana.com") {
+  try {
+    const config = await fetchConfig(apiUrl);
+    return config.x402.validator.rpcUrl || fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+// src/x402.ts
+import { createSigner } from "x402-fetch";
+var X402API = class {
+  constructor(config) {
+    this.config = config;
+    this.serverConfig = null;
+    this.sandboxAccounts = null;
+  }
+  /**
+   * Fetch sandbox accounts from the server
+   */
+  async fetchSandboxAccounts() {
+    if (this.sandboxAccounts) {
+      return this.sandboxAccounts;
+    }
+    const response = await fetch(`${this.config.endpoint}/sandbox/accounts`);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch sandbox accounts: ${response.status}`);
+    }
+    this.sandboxAccounts = await response.json();
+    return this.sandboxAccounts;
+  }
+  /**
+   * Get a signer for a sandbox account by tag/label
+   *
+   * @param params - Parameters containing the wallet tag/label
+   * @returns A Signer that can be used directly with wrapFetchWithPayment
+   *
+   * @example
+   * ```typescript
+   * const payer = await moneymq.x402.getSigner({ tag: 'alice' });
+   * ```
+   */
+  async getSigner(params) {
+    const accounts = await this.fetchSandboxAccounts();
+    for (const networkData of Object.values(accounts)) {
+      for (const account of networkData.userAccounts) {
+        if (account.label === params.tag) {
+          if (!account.secretKeyHex) {
+            throw new Error(`Account '${params.tag}' does not have a secret key (not locally managed)`);
+          }
+          return createSigner("solana", account.secretKeyHex);
+        }
+      }
+    }
+    throw new Error(`No sandbox account found with label '${params.tag}'`);
+  }
+  /**
+   * Get x402 configuration for use with wrapFetchWithPayment
+   *
+   * @returns Configuration object compatible with x402-fetch
+   *
+   * @example
+   * ```typescript
+   * const config = await moneymq.x402.getConfig();
+   * const fetchWithPayment = wrapFetchWithPayment(fetch, payer, undefined, undefined, config);
+   * ```
+   */
+  async getConfig() {
+    if (!this.serverConfig) {
+      this.serverConfig = await fetchConfig(this.config.endpoint);
+    }
+    return {
+      svmConfig: {
+        rpcUrl: this.serverConfig.x402.validator.rpcUrl
+      }
+    };
+  }
+  /**
+   * Get the full server configuration
+   *
+   * @returns The complete server configuration including x402 settings
+   */
+  async getServerConfig() {
+    if (!this.serverConfig) {
+      this.serverConfig = await fetchConfig(this.config.endpoint);
+    }
+    return this.serverConfig;
+  }
+};
+
+// src/events.ts
+var EventStream = class {
+  constructor(endpoint, options = {}) {
+    this.eventSource = null;
+    this.state = "disconnected";
+    this.reconnectAttempts = 0;
+    this.lastEventId = null;
+    this.paymentHandlers = /* @__PURE__ */ new Set();
+    this.errorHandlers = /* @__PURE__ */ new Set();
+    this.stateHandlers = /* @__PURE__ */ new Set();
+    this.endpoint = endpoint;
+    console.log("[MoneyMQ SDK] EventStream constructor called with options:", JSON.stringify(options));
+    this.options = {
+      last: options.last ?? 0,
+      cursor: options.cursor ?? "",
+      streamId: options.streamId ?? "",
+      autoReconnect: options.autoReconnect ?? true,
+      reconnectDelay: options.reconnectDelay ?? 1e3,
+      maxReconnectAttempts: options.maxReconnectAttempts ?? 0
+    };
+    console.log("[MoneyMQ SDK] Resolved options:", JSON.stringify(this.options));
+    if (this.options.cursor && !this.options.streamId) {
+      this.lastEventId = this.options.cursor;
+    }
+  }
+  /**
+   * Whether this is a stateful stream (server tracks cursor)
+   */
+  get isStateful() {
+    return this.options.streamId !== "";
+  }
+  /**
+   * The stream ID for stateful streams
+   */
+  get streamId() {
+    return this.options.streamId || null;
+  }
+  /**
+   * Current connection state
+   */
+  get connectionState() {
+    return this.state;
+  }
+  /**
+   * Current cursor (last received event ID)
+   */
+  get cursor() {
+    return this.lastEventId;
+  }
+  /**
+   * Whether the stream is currently connected
+   */
+  get isConnected() {
+    return this.state === "connected";
+  }
+  on(event, handler) {
+    switch (event) {
+      case "payment":
+        this.paymentHandlers.add(handler);
+        return () => this.paymentHandlers.delete(handler);
+      case "error":
+        this.errorHandlers.add(handler);
+        return () => this.errorHandlers.delete(handler);
+      case "stateChange":
+        this.stateHandlers.add(handler);
+        return () => this.stateHandlers.delete(handler);
+    }
+  }
+  off(event, handler) {
+    switch (event) {
+      case "payment":
+        this.paymentHandlers.delete(handler);
+        break;
+      case "error":
+        this.errorHandlers.delete(handler);
+        break;
+      case "stateChange":
+        this.stateHandlers.delete(handler);
+        break;
+    }
+  }
+  /**
+   * Connect to the event stream
+   */
+  connect() {
+    if (this.eventSource) {
+      this.eventSource.close();
+    }
+    this.setState("connecting");
+    const url = this.buildUrl();
+    console.log("[MoneyMQ SDK] Connecting to SSE:", url, "| streamId:", this.options.streamId || "(none)");
+    this.eventSource = new EventSource(url);
+    this.eventSource.onopen = () => {
+      this.setState("connected");
+      this.reconnectAttempts = 0;
+    };
+    this.eventSource.addEventListener("payment", (event) => {
+      try {
+        const cloudEvent = JSON.parse(event.data);
+        this.lastEventId = cloudEvent.id;
+        this.emitPayment(cloudEvent);
+      } catch (e) {
+        this.emitError(new Error(`Failed to parse event: ${e}`));
+      }
+    });
+    this.eventSource.onerror = () => {
+      this.eventSource?.close();
+      this.eventSource = null;
+      if (this.options.autoReconnect && this.shouldReconnect()) {
+        this.scheduleReconnect();
+      } else {
+        this.setState("disconnected");
+        this.emitError(new Error("Connection lost"));
+      }
+    };
+  }
+  /**
+   * Disconnect from the event stream
+   */
+  disconnect() {
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = null;
+    }
+    this.setState("disconnected");
+    this.reconnectAttempts = 0;
+  }
+  /**
+   * Reconnect with a new cursor
+   * Useful for resuming from a stored position
+   */
+  reconnectFrom(cursor) {
+    this.lastEventId = cursor;
+    this.disconnect();
+    this.connect();
+  }
+  buildUrl() {
+    const params = new URLSearchParams();
+    if (this.options.streamId) {
+      params.set("stream_id", this.options.streamId);
+      if (this.options.last > 0) {
+        params.set("last", this.options.last.toString());
+      }
+    } else {
+      if (this.lastEventId) {
+        params.set("cursor", this.lastEventId);
+      } else if (this.options.last > 0) {
+        params.set("last", this.options.last.toString());
+      }
+    }
+    const queryString = params.toString();
+    return queryString ? `${this.endpoint}/events?${queryString}` : `${this.endpoint}/events`;
+  }
+  setState(state) {
+    if (this.state !== state) {
+      this.state = state;
+      this.stateHandlers.forEach((handler) => handler(state));
+    }
+  }
+  shouldReconnect() {
+    if (this.options.maxReconnectAttempts === 0) return true;
+    return this.reconnectAttempts < this.options.maxReconnectAttempts;
+  }
+  scheduleReconnect() {
+    this.setState("reconnecting");
+    this.reconnectAttempts++;
+    setTimeout(() => {
+      if (this.state === "reconnecting") {
+        this.connect();
+      }
+    }, this.options.reconnectDelay);
+  }
+  emitPayment(event) {
+    this.paymentHandlers.forEach((handler) => handler(event));
+  }
+  emitError(error) {
+    this.errorHandlers.forEach((handler) => handler(error));
+  }
+};
+function createEventStream(endpoint, options) {
+  return new EventStream(endpoint, options);
+}
+function isPaymentVerificationSucceeded(event) {
+  return event.type === "mq.money.payment.verification.succeeded";
+}
+function isPaymentVerificationFailed(event) {
+  return event.type === "mq.money.payment.verification.failed";
+}
+function isPaymentSettlementSucceeded(event) {
+  return event.type === "mq.money.payment.settlement.succeeded";
+}
+function isPaymentSettlementFailed(event) {
+  return event.type === "mq.money.payment.settlement.failed";
+}
+function parseCloudEvent(data) {
+  try {
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function buildEventStreamUrl(endpoint, options) {
+  const params = new URLSearchParams();
+  if (options?.streamId) {
+    params.set("stream_id", options.streamId);
+    if (options.last && options.last > 0) {
+      params.set("last", options.last.toString());
+    }
+  } else {
+    if (options?.cursor) {
+      params.set("cursor", options.cursor);
+    } else if (options?.last && options.last > 0) {
+      params.set("last", options.last.toString());
+    }
+  }
+  const queryString = params.toString();
+  return queryString ? `${endpoint}/events?${queryString}` : `${endpoint}/events`;
+}
+
 // src/client.ts
 var MoneyMQ = class {
+  /** MoneyMQ API endpoint */
+  get endpoint() {
+    return this.config.endpoint;
+  }
   constructor(config) {
     this.config = {
       timeout: 3e4,
@@ -294,6 +761,10 @@ var MoneyMQ = class {
     };
     this.catalog = new CatalogAPI(this.config);
     this.payment = new PaymentAPI(this.config);
+    this.x402 = new X402API(this.config);
+    this.events = {
+      stream: (options) => new EventStream(this.config.endpoint, options)
+    };
   }
   /**
    * Make an authenticated request to the MoneyMQ API
@@ -331,26 +802,18 @@ var MoneyMQError = class extends Error {
     this.name = "MoneyMQError";
   }
 };
-
-// src/config.ts
-async function fetchConfig(apiUrl) {
-  const response = await fetch(`${apiUrl}/config`);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch config: ${response.status}`);
-  }
-  return response.json();
-}
-async function getRpcUrl(apiUrl, fallback = "https://api.devnet.solana.com") {
-  try {
-    const config = await fetchConfig(apiUrl);
-    return config.x402.validator.rpcUrl || fallback;
-  } catch {
-    return fallback;
-  }
-}
 export {
+  EventStream,
   MoneyMQ,
+  PaymentRequiredError,
+  buildEventStreamUrl,
+  createEventStream,
   fetchConfig,
-  getRpcUrl
+  getRpcUrl,
+  isPaymentSettlementFailed,
+  isPaymentSettlementSucceeded,
+  isPaymentVerificationFailed,
+  isPaymentVerificationSucceeded,
+  parseCloudEvent
 };
 //# sourceMappingURL=index.mjs.map