@everestan/protocolbanks-sdk 0.0.0-stage → 0.2.1

package/dist/index.mjs

@@ -0,0 +1,683 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/payment-link.ts
+var PaymentLink = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Create a new payment link
+   */
+  async create(options) {
+    const baseUrl = this.config.baseUrl || "https://protocol-banks.vercel.app";
+    const response = await fetch(`${baseUrl}/api/acquiring/payment-links`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.config.apiKey
+      },
+      body: JSON.stringify({
+        title: options.title,
+        description: options.description,
+        amount: options.amount,
+        token: options.token || this.config.defaultToken || "USDC",
+        recipientAddress: options.recipientAddress,
+        amountType: options.amount ? "fixed" : "customer_input",
+        redirectUrl: options.redirectUrl,
+        expiresAt: options.expiresIn ? new Date(Date.now() + options.expiresIn * 1e3).toISOString() : void 0,
+        brandColor: options.branding?.color,
+        logoUrl: options.branding?.logoUrl,
+        distributeAsset: !!options.assetDistribution,
+        assetType: options.assetDistribution?.type,
+        assetContractAddress: options.assetDistribution?.contractAddress,
+        assetTokenId: options.assetDistribution?.tokenId,
+        assetAmount: options.assetDistribution?.amount,
+        metadata: options.metadata
+      })
+    });
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      return {
+        success: false,
+        id: "",
+        paymentUrl: "",
+        status: "failed",
+        error: data.error || "Failed to create payment link"
+      };
+    }
+    return {
+      success: true,
+      id: data.link.link_id,
+      paymentUrl: data.paymentUrl,
+      shortUrl: data.shortUrl,
+      qrCodeData: data.paymentUrl,
+      status: "pending"
+    };
+  }
+  /**
+   * Get payment link details
+   */
+  async get(linkId) {
+    const baseUrl = this.config.baseUrl || "https://protocol-banks.vercel.app";
+    const response = await fetch(
+      `${baseUrl}/api/acquiring/payment-links?linkId=${linkId}`,
+      {
+        headers: {
+          "X-API-Key": this.config.apiKey
+        }
+      }
+    );
+    return response.json();
+  }
+  /**
+   * List all payment links
+   */
+  async list(merchantId) {
+    const baseUrl = this.config.baseUrl || "https://protocol-banks.vercel.app";
+    const params = merchantId ? `?merchantId=${merchantId}` : "";
+    const response = await fetch(
+      `${baseUrl}/api/acquiring/payment-links${params}`,
+      {
+        headers: {
+          "X-API-Key": this.config.apiKey
+        }
+      }
+    );
+    return response.json();
+  }
+  /**
+   * Update a payment link
+   */
+  async update(linkId, updates) {
+    const baseUrl = this.config.baseUrl || "https://protocol-banks.vercel.app";
+    const response = await fetch(`${baseUrl}/api/acquiring/payment-links`, {
+      method: "PATCH",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.config.apiKey
+      },
+      body: JSON.stringify({ linkId, ...updates })
+    });
+    return response.json();
+  }
+  /**
+   * Delete a payment link
+   */
+  async delete(linkId) {
+    const baseUrl = this.config.baseUrl || "https://protocol-banks.vercel.app";
+    const response = await fetch(
+      `${baseUrl}/api/acquiring/payment-links?linkId=${linkId}`,
+      {
+        method: "DELETE",
+        headers: {
+          "X-API-Key": this.config.apiKey
+        }
+      }
+    );
+    return response.json();
+  }
+};
+
+// src/invoice.ts
+var Invoice = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Create a new invoice
+   */
+  async create(options) {
+    const baseUrl = this.config.baseUrl || "https://protocol-banks.vercel.app";
+    const response = await fetch(`${baseUrl}/api/invoice`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.config.apiKey
+      },
+      body: JSON.stringify({
+        recipientAddress: options.recipientAddress,
+        amount: options.amount,
+        token: options.token || this.config.defaultToken || "USDC",
+        description: options.description,
+        merchantName: options.merchantName,
+        amountFiat: options.amountFiat,
+        fiatCurrency: options.fiatCurrency,
+        expiresIn: (options.expiresInHours || 24) * 60 * 60 * 1e3,
+        metadata: {
+          ...options.metadata,
+          customerName: options.customer?.name,
+          customerEmail: options.customer?.email
+        }
+      })
+    });
+    const data = await response.json();
+    if (!response.ok || !data.success && !data.invoice) {
+      return {
+        success: false,
+        id: "",
+        paymentUrl: "",
+        status: "failed",
+        error: data.error || "Failed to create invoice"
+      };
+    }
+    return {
+      success: true,
+      id: data.invoice.invoice_id,
+      paymentUrl: data.paymentLink,
+      qrCodeData: data.qrCodeData,
+      status: "pending"
+    };
+  }
+  /**
+   * Get invoice details
+   */
+  async get(invoiceId, signature) {
+    const baseUrl = this.config.baseUrl || "https://protocol-banks.vercel.app";
+    const params = new URLSearchParams({ id: invoiceId });
+    if (signature) params.set("sig", signature);
+    const response = await fetch(`${baseUrl}/api/invoice?${params.toString()}`, {
+      headers: {
+        "X-API-Key": this.config.apiKey
+      }
+    });
+    return response.json();
+  }
+  /**
+   * Update invoice status (e.g., after payment)
+   */
+  async updateStatus(invoiceId, status, txHash, paidBy) {
+    const baseUrl = this.config.baseUrl || "https://protocol-banks.vercel.app";
+    const response = await fetch(`${baseUrl}/api/invoice`, {
+      method: "PATCH",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.config.apiKey
+      },
+      body: JSON.stringify({ invoiceId, status, txHash, paidBy })
+    });
+    return response.json();
+  }
+  /**
+   * Get printable invoice export URL
+   */
+  getExportUrl(invoiceId, signature) {
+    const baseUrl = this.config.baseUrl || "https://protocol-banks.vercel.app";
+    const params = new URLSearchParams({ id: invoiceId });
+    if (signature) params.set("sig", signature);
+    return `${baseUrl}/api/invoice/export?${params.toString()}`;
+  }
+  /**
+   * List invoices for a merchant
+   */
+  async list(options) {
+    const baseUrl = this.config.baseUrl || "https://protocol-banks.vercel.app";
+    const params = new URLSearchParams();
+    if (options?.status) params.set("status", options.status);
+    if (options?.limit) params.set("limit", options.limit.toString());
+    if (options?.offset) params.set("offset", options.offset.toString());
+    const response = await fetch(`${baseUrl}/api/invoice/list?${params.toString()}`, {
+      headers: {
+        "X-API-Key": this.config.apiKey
+      }
+    });
+    return response.json();
+  }
+};
+
+// src/checkout.ts
+var Checkout = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Create a new checkout order
+   */
+  async create(options) {
+    const baseUrl = this.config.baseUrl || "https://protocol-banks.vercel.app";
+    const response = await fetch(`${baseUrl}/api/acquiring/orders`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.config.apiKey
+      },
+      body: JSON.stringify({
+        merchant_id: options.merchantId,
+        amount: parseFloat(options.amount),
+        currency: options.currency || "USD",
+        token: options.token || this.config.defaultToken || "USDC",
+        notify_url: options.notifyUrl,
+        return_url: options.returnUrl,
+        metadata: options.metadata
+      })
+    });
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      return {
+        success: false,
+        id: "",
+        paymentUrl: "",
+        status: "failed",
+        error: data.error || "Failed to create checkout"
+      };
+    }
+    const checkoutUrl = `${baseUrl}/checkout?order=${data.order.order_no}`;
+    return {
+      success: true,
+      id: data.order.order_no,
+      paymentUrl: checkoutUrl,
+      qrCodeData: checkoutUrl,
+      status: "pending"
+    };
+  }
+  /**
+   * Get order status
+   */
+  async getStatus(orderNo) {
+    const baseUrl = this.config.baseUrl || "https://protocol-banks.vercel.app";
+    const response = await fetch(`${baseUrl}/api/acquiring/orders/${orderNo}`, {
+      headers: {
+        "X-API-Key": this.config.apiKey
+      }
+    });
+    return response.json();
+  }
+  /**
+   * List orders for a merchant
+   */
+  async listOrders(merchantId, options) {
+    const baseUrl = this.config.baseUrl || "https://protocol-banks.vercel.app";
+    const params = new URLSearchParams();
+    if (merchantId) params.set("merchantId", merchantId);
+    if (options?.limit) params.set("limit", options.limit.toString());
+    if (options?.offset) params.set("offset", options.offset.toString());
+    const response = await fetch(
+      `${baseUrl}/api/acquiring/orders?${params.toString()}`,
+      {
+        headers: {
+          "X-API-Key": this.config.apiKey
+        }
+      }
+    );
+    return response.json();
+  }
+  /**
+   * Open checkout in a popup window
+   */
+  openPopup(options) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const result = await this.create(options);
+        if (!result.success) {
+          reject(new Error(result.error || "Failed to create checkout"));
+          return;
+        }
+        const width = 450;
+        const height = 700;
+        const left = window.screenX + (window.outerWidth - width) / 2;
+        const top = window.screenY + (window.outerHeight - height) / 2;
+        const popup = window.open(
+          result.paymentUrl,
+          "protocol-banks-checkout",
+          `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes`
+        );
+        if (!popup) {
+          reject(new Error("Popup blocked. Please allow popups for this site."));
+          return;
+        }
+        const interval = setInterval(() => {
+          if (popup.closed) {
+            clearInterval(interval);
+            this.getStatus(result.id).then((status) => {
+              if (status.order?.status === "paid") {
+                resolve({
+                  ...result,
+                  status: "paid",
+                  txHash: status.order.tx_hash
+                });
+              } else {
+                resolve({
+                  ...result,
+                  status: "cancelled"
+                });
+              }
+            }).catch(() => {
+              resolve({ ...result, status: "cancelled" });
+            });
+          }
+        }, 500);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+};
+
+// src/webhook.ts
+var Webhook = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Verify an incoming webhook signature (server-side only).
+   *
+   * Use this in your webhook handler to validate that the request
+   * came from Protocol Banks.
+   *
+   * @example
+   * ```ts
+   * const pb = new ProtocolBanks({ apiKey: 'pk_...' });
+   *
+   * app.post('/webhook', (req, res) => {
+   *   const signature = req.headers['x-webhook-signature'];
+   *   const timestamp = req.headers['x-webhook-timestamp'];
+   *   const body = JSON.stringify(req.body);
+   *
+   *   if (!pb.webhooks.verify(body, signature, 'whsec_...')) {
+   *     return res.status(401).send('Invalid signature');
+   *   }
+   *
+   *   // Process event
+   *   const event = req.body;
+   *   console.log('Received event:', event.event);
+   *   res.status(200).send('OK');
+   * });
+   * ```
+   */
+  verify(payload, signature, secret) {
+    try {
+      const crypto2 = __require("crypto");
+      const expectedSignature = crypto2.createHmac("sha256", secret).update(payload).digest("hex");
+      if (signature.length !== expectedSignature.length) {
+        return false;
+      }
+      const sigBuffer = Buffer.from(signature, "hex");
+      const expectedBuffer = Buffer.from(expectedSignature, "hex");
+      if (sigBuffer.length !== expectedBuffer.length) {
+        return false;
+      }
+      return crypto2.timingSafeEqual(sigBuffer, expectedBuffer);
+    } catch {
+      return this.verifyBrowser(payload, signature, secret);
+    }
+  }
+  /**
+   * Browser-compatible signature verification using Web Crypto API
+   */
+  verifyBrowser(payload, signature, secret) {
+    console.warn(
+      "Webhook verification in browser is not recommended. Use server-side verification."
+    );
+    return false;
+  }
+  /**
+   * Async signature verification using Web Crypto API (works in browser and Node.js)
+   */
+  async verifyAsync(payload, signature, secret) {
+    try {
+      const crypto2 = __require("crypto");
+      const expectedSignature = crypto2.createHmac("sha256", secret).update(payload).digest("hex");
+      const sigBuffer = Buffer.from(signature, "hex");
+      const expectedBuffer = Buffer.from(expectedSignature, "hex");
+      if (sigBuffer.length !== expectedBuffer.length) {
+        return false;
+      }
+      return crypto2.timingSafeEqual(sigBuffer, expectedBuffer);
+    } catch {
+      const encoder = new TextEncoder();
+      const keyData = encoder.encode(secret);
+      const payloadData = encoder.encode(payload);
+      const key = await crypto.subtle.importKey(
+        "raw",
+        keyData,
+        { name: "HMAC", hash: "SHA-256" },
+        false,
+        ["sign"]
+      );
+      const signatureBuffer = await crypto.subtle.sign(
+        "HMAC",
+        key,
+        payloadData
+      );
+      const expectedHex = Array.from(new Uint8Array(signatureBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+      if (signature.length !== expectedHex.length) {
+        return false;
+      }
+      let result = 0;
+      for (let i = 0; i < signature.length; i++) {
+        result |= signature.charCodeAt(i) ^ expectedHex.charCodeAt(i);
+      }
+      return result === 0;
+    }
+  }
+  /**
+   * Construct a webhook event from a raw request
+   */
+  constructEvent(payload, signature, secret) {
+    if (!this.verify(payload, signature, secret)) {
+      throw new Error("Invalid webhook signature");
+    }
+    const event = JSON.parse(payload);
+    return event;
+  }
+  /**
+   * Create a new webhook subscription
+   */
+  async create(options) {
+    const baseUrl = this.config.baseUrl || "https://protocol-banks.vercel.app";
+    const response = await fetch(`${baseUrl}/api/webhooks`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.config.apiKey
+      },
+      body: JSON.stringify(options)
+    });
+    return response.json();
+  }
+  /**
+   * List webhook subscriptions
+   */
+  async list() {
+    const baseUrl = this.config.baseUrl || "https://protocol-banks.vercel.app";
+    const response = await fetch(`${baseUrl}/api/webhooks`, {
+      headers: {
+        "X-API-Key": this.config.apiKey
+      }
+    });
+    return response.json();
+  }
+  /**
+   * Delete a webhook subscription
+   */
+  async delete(webhookId) {
+    const baseUrl = this.config.baseUrl || "https://protocol-banks.vercel.app";
+    const response = await fetch(`${baseUrl}/api/webhooks/${webhookId}`, {
+      method: "DELETE",
+      headers: {
+        "X-API-Key": this.config.apiKey
+      }
+    });
+    return response.json();
+  }
+  /**
+   * Get recent webhook deliveries
+   */
+  async getDeliveries(webhookId) {
+    const baseUrl = this.config.baseUrl || "https://protocol-banks.vercel.app";
+    const response = await fetch(
+      `${baseUrl}/api/webhooks/${webhookId}/deliveries`,
+      {
+        headers: {
+          "X-API-Key": this.config.apiKey
+        }
+      }
+    );
+    return response.json();
+  }
+};
+
+// src/agent.ts
+var Agent = class {
+  constructor(config) {
+    this.config = config;
+  }
+  baseUrl() {
+    return this.config.baseUrl || "https://protocolbanks.com";
+  }
+  async call(method, path, body) {
+    const res = await fetch(`${this.baseUrl()}/api/v1/agent${path}`, {
+      method,
+      headers: {
+        ...body === void 0 ? {} : { "Content-Type": "application/json" },
+        Authorization: `Bearer ${this.config.apiKey}`
+      },
+      ...body === void 0 ? {} : { body: JSON.stringify(body) }
+    });
+    const json = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
+    return { ...json, status: res.status };
+  }
+  /** Mode, equity, positions, activity and the key's policy with spentTodayUsd. */
+  async state() {
+    return this.call("GET", "/state");
+  }
+  /** Place one order. Executes through the trading-only agent wallet. */
+  async order(request) {
+    return this.call("POST", "/orders", request);
+  }
+  /** Validate a payment and return the intent the agent signs itself. */
+  async pay(request) {
+    return this.call("POST", "/pay", request);
+  }
+  /** Quote a swap; the agent signs and submits the returned transaction. */
+  async swap(request) {
+    return this.call("POST", "/swap", request);
+  }
+  /** Create a pending invoice and get the payer's paymentLink. */
+  async invoice(request) {
+    return this.call("POST", "/invoice", request);
+  }
+  /**
+   * Read an invoice back with the id and signature from its paymentLink
+   * (`/pay?invoice=<id>&sig=<sig>`). A signed invoice answers 403 without sig.
+   */
+  async invoiceStatus(invoiceId, sig) {
+    const query = new URLSearchParams({ id: invoiceId });
+    if (sig) query.set("sig", sig);
+    const res = await fetch(`${this.baseUrl()}/api/invoice?${query.toString()}`);
+    const json = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
+    return { ok: Boolean(json.success), status: res.status, invoice: json.invoice, error: json.error };
+  }
+};
+
+// src/client.ts
+var ProtocolBanks = class {
+  constructor(config) {
+    this.config = {
+      ...config,
+      baseUrl: config.baseUrl || "https://protocolbanks.com",
+      defaultToken: config.defaultToken || "USDC"
+    };
+    this.paymentLinks = new PaymentLink(this.config);
+    this.invoices = new Invoice(this.config);
+    this.checkout = new Checkout(this.config);
+    this.webhooks = new Webhook(this.config);
+    this.agent = new Agent(this.config);
+  }
+  /**
+   * Create an embeddable payment iframe
+   */
+  embed(options) {
+    const container = typeof options.container === "string" ? document.querySelector(options.container) : options.container;
+    if (!container) {
+      throw new Error("Container element not found");
+    }
+    const params = new URLSearchParams({
+      to: options.to,
+      token: options.token || this.config.defaultToken
+    });
+    if (options.amount) params.set("amount", options.amount);
+    if (options.merchantName) params.set("merchant", options.merchantName);
+    if (options.theme) params.set("theme", options.theme);
+    const iframe = document.createElement("iframe");
+    iframe.src = `${this.config.baseUrl}/embed/pay?${params.toString()}`;
+    iframe.style.width = "100%";
+    iframe.style.height = "500px";
+    iframe.style.border = "none";
+    iframe.style.borderRadius = "12px";
+    iframe.allow = "payment";
+    const handleMessage = (event) => {
+      if (event.origin !== new URL(this.config.baseUrl).origin) return;
+      const data = event.data;
+      if (data.type === "payment_success" && options.onSuccess) {
+        options.onSuccess({
+          success: true,
+          id: data.txHash || "",
+          paymentUrl: "",
+          status: "paid",
+          txHash: data.txHash
+        });
+      }
+      if (data.type === "payment_error" && options.onError) {
+        options.onError(new Error(data.error || "Payment failed"));
+      }
+    };
+    window.addEventListener("message", handleMessage);
+    container.appendChild(iframe);
+    return {
+      destroy: () => {
+        window.removeEventListener("message", handleMessage);
+        iframe.remove();
+      }
+    };
+  }
+  /**
+   * Generate a payment URL for direct redirect
+   */
+  getPaymentUrl(options) {
+    const params = new URLSearchParams({
+      to: options.to,
+      amount: options.amount,
+      token: options.token || this.config.defaultToken
+    });
+    if (options.merchantName) params.set("merchant", options.merchantName);
+    return `${this.config.baseUrl}/pay?${params.toString()}`;
+  }
+  /**
+   * Make an authenticated API request
+   */
+  async request(path, options = {}) {
+    const url = `${this.config.baseUrl}/api${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-API-Key": this.config.apiKey
+    };
+    if (this.config.apiSecret) {
+      headers["X-API-Secret"] = this.config.apiSecret;
+    }
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        ...headers,
+        ...options.headers
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Request failed" }));
+      throw new Error(error.error || `API request failed: ${response.status}`);
+    }
+    return response.json();
+  }
+};
+export {
+  Agent,
+  Checkout,
+  Invoice,
+  PaymentLink,
+  ProtocolBanks,
+  Webhook
+};