aipp-node 1.2.0 → 1.2.1

package/dist/index.mjs

@@ -1,226 +0,0 @@
-// src/client.ts
-var Aipp = class {
-  apiKey;
-  baseUrl;
-  constructor(config) {
-    if (!config.apiKey) {
-      throw new Error("AIPP: apiKey is required");
-    }
-    this.apiKey = config.apiKey;
-    this.baseUrl = config.baseUrl || "https://aipp.dev";
-  }
-  async request(endpoint, options = {}) {
-    const url = `${this.baseUrl}${endpoint}`;
-    const headers = {
-      "Content-Type": "application/json",
-      "X-Api-Key": this.apiKey,
-      ...options.headers
-    };
-    const response = await fetch(url, { ...options, headers });
-    if (!response.ok) {
-      let errorData;
-      try {
-        errorData = await response.json();
-      } catch (err) {
-        throw new Error(`AIPP API Error: ${response.status} ${response.statusText}`);
-      }
-      throw new Error(`AIPP API Error: ${errorData.error || response.statusText}`);
-    }
-    return response.json();
-  }
-  /**
-   * Creates a new Invoice (either L402 or x402)
-   */
-  async createCharge(params) {
-    if (!params.amountSats && !params.amountUsd) {
-      throw new Error("AIPP: Either amountSats or amountUsd is required");
-    }
-    const body = { memo: params.memo };
-    if (params.amountSats) body.amount_sats = params.amountSats;
-    if (params.amountUsd) body.amount_usd = params.amountUsd;
-    if (params.protocol) body.protocol = params.protocol;
-    return this.request("/invoice/create", {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
-  }
-  /**
-   * Checks the status of an existing charge
-   */
-  async getCharge(paymentHash, txHash) {
-    if (!paymentHash) {
-      throw new Error("AIPP: paymentHash is required");
-    }
-    const query = txHash ? `?tx_hash=${txHash}` : "";
-    return this.request(`/invoice/status/${paymentHash}${query}`, {
-      method: "GET"
-    });
-  }
-  /**
-   * Triggers a manual withdrawal of your merchant balance
-   */
-  async payout() {
-    return this.request("/merchant/payout", {
-      method: "POST"
-    });
-  }
-};
-
-// src/middleware.ts
-import crypto2 from "crypto";
-
-// src/jwt.ts
-import crypto from "crypto";
-function base64urlEncode(str) {
-  const buf = Buffer.isBuffer(str) ? str : Buffer.from(str);
-  return buf.toString("base64url");
-}
-function base64urlDecode(str) {
-  return Buffer.from(str, "base64url").toString("utf8");
-}
-function signJwt(payload, secret) {
-  const header = { alg: "HS256", typ: "JWT" };
-  const encodedHeader = base64urlEncode(JSON.stringify(header));
-  const encodedPayload = base64urlEncode(JSON.stringify(payload));
-  const data = `${encodedHeader}.${encodedPayload}`;
-  const signature = crypto.createHmac("sha256", secret).update(data).digest("base64url");
-  return `${data}.${signature}`;
-}
-function verifyJwt(token, secret) {
-  const parts = token.split(".");
-  if (parts.length !== 3) {
-    throw new Error("Invalid JWT format");
-  }
-  const [encodedHeader, encodedPayload, signature] = parts;
-  const data = `${encodedHeader}.${encodedPayload}`;
-  const expectedSignature = crypto.createHmac("sha256", secret).update(data).digest("base64url");
-  const signatureBuffer = Buffer.from(signature);
-  const expectedBuffer = Buffer.from(expectedSignature);
-  if (signatureBuffer.length !== expectedBuffer.length || !crypto.timingSafeEqual(signatureBuffer, expectedBuffer)) {
-    throw new Error("Invalid JWT signature");
-  }
-  const payload = JSON.parse(base64urlDecode(encodedPayload));
-  if (payload.exp && Date.now() >= payload.exp * 1e3) {
-    throw new Error("JWT expired");
-  }
-  return payload;
-}
-
-// src/middleware.ts
-function l402Paywall(options) {
-  if (!options.amountSats && !options.amountUsd) {
-    throw new Error("Either amountSats or amountUsd must be provided for l402Paywall");
-  }
-  return async (req, res, next) => {
-    const authHeader = req.headers.authorization || req.headers.Authorization;
-    let valid = false;
-    if (authHeader && typeof authHeader === "string" && authHeader.startsWith("L402 ")) {
-      const parts = authHeader.substring(5).split(":");
-      if (parts.length === 2) {
-        const [macaroonStr, preimage] = parts;
-        try {
-          const payload = verifyJwt(macaroonStr, options.jwtSecret);
-          if (payload.resource_id !== options.resourceId) {
-            throw new Error("Invalid resource");
-          }
-          const preimageHash = crypto2.createHash("sha256").update(Buffer.from(preimage, "hex")).digest("hex");
-          const expectedHash = payload.payment_hash;
-          if (typeof expectedHash === "string" && expectedHash.length === preimageHash.length && crypto2.timingSafeEqual(Buffer.from(preimageHash, "hex"), Buffer.from(expectedHash, "hex"))) {
-            valid = true;
-          }
-        } catch (e) {
-        }
-      }
-    }
-    if (valid) {
-      return next();
-    }
-    try {
-      const charge = await options.client.createCharge({
-        amountSats: options.amountSats,
-        amountUsd: options.amountUsd,
-        memo: `L402 Payment for ${options.resourceId}`
-      });
-      const expiresIn = options.expiresInSeconds || 3600;
-      const payload = {
-        payment_hash: charge.payment_hash,
-        resource_id: options.resourceId,
-        exp: Math.floor(Date.now() / 1e3) + expiresIn
-      };
-      const jwtToken = signJwt(payload, options.jwtSecret);
-      res.status(402);
-      res.setHeader("Www-Authenticate", `L402 macaroon="${jwtToken}" invoice="${charge.payment_request}"`);
-      res.json({
-        error: "Payment Required",
-        code: "L402",
-        payment_request: charge.payment_request,
-        macaroon: jwtToken
-      });
-    } catch (err) {
-      res.status(500).json({ error: "Failed to generate L402 challenge", details: err.message || err });
-    }
-  };
-}
-function x402Paywall(options) {
-  return async (req, res, next) => {
-    const authHeader = req.headers.authorization || req.headers.Authorization;
-    let txHash = req.query.tx_hash || req.headers["payment-signature"] || req.headers["x-payment-signature"];
-    let paymentHash = req.query.payment_hash || req.headers["x-payment-hash"];
-    if (!txHash && authHeader && typeof authHeader === "string") {
-      if (authHeader.startsWith("Bearer ")) {
-        txHash = authHeader.substring(7).trim();
-      } else if (authHeader.startsWith("x402 ")) {
-        txHash = authHeader.substring(5).trim();
-      } else if (authHeader.startsWith("L402 ")) {
-        const parts = authHeader.substring(5).split(":");
-        if (parts.length === 2) {
-          paymentHash = parts[0];
-          txHash = parts[1];
-        }
-      }
-    }
-    if (paymentHash && txHash) {
-      try {
-        const chargeStatus = await options.client.getCharge(paymentHash, txHash);
-        if (chargeStatus.status === "settled") {
-          return next();
-        }
-      } catch (e) {
-      }
-    }
-    try {
-      const charge = await options.client.createCharge({
-        amountUsd: options.amountUsd,
-        protocol: "x402",
-        memo: `x402 Payment for ${options.resourceId}`
-      });
-      const challengeObj = {
-        scheme: "exact",
-        network: "base",
-        payTo: charge.pay_to || "",
-        price: options.amountUsd.toFixed(2),
-        token: charge.token || "",
-        payment_hash: charge.payment_hash
-      };
-      const challengeBase64 = Buffer.from(JSON.stringify(challengeObj), "utf8").toString("base64");
-      res.setHeader("PAYMENT-REQUIRED", challengeBase64);
-      res.status(402);
-      res.json({
-        error: "Payment Required",
-        code: "x402",
-        payment_hash: charge.payment_hash,
-        pay_to: challengeObj.payTo,
-        price: challengeObj.price,
-        token: challengeObj.token,
-        network: challengeObj.network
-      });
-    } catch (err) {
-      res.status(500).json({ error: "Failed to generate x402 challenge", details: err.message || err });
-    }
-  };
-}
-export {
-  Aipp,
-  l402Paywall,
-  x402Paywall
-};