aipp-node 1.1.0 → 1.2.1

package/package.json

@@ -1,32 +1,32 @@
-{
-  "name": "aipp-node",
-  "version": "1.1.0",
-  "description": "Official Node.js SDK for AIPP - The Lightning Network Split-Payment Gateway",
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts",
-    "test": "vitest run"
-  },
-  "keywords": [
-    "aipp",
-    "bitcoin",
-    "lightning",
-    "payments",
-    "l402",
-    "ai"
-  ],
-  "author": "AIPP",
-  "license": "MIT",
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "tsup": "^8.0.0",
-    "typescript": "^5.0.0",
-    "vitest": "^1.0.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/aippde/aipp-key.git"
-  }
-}
+{
+  "name": "aipp-node",
+  "version": "1.2.1",
+  "description": "Official Node.js SDK for AIPP - The Lightning Network Split-Payment Gateway",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "aipp",
+    "bitcoin",
+    "lightning",
+    "payments",
+    "l402",
+    "ai"
+  ],
+  "author": "AIPP",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aippde/aipp-key.git"
+  }
+}

package/src/client.ts

@@ -1,76 +1,101 @@
-import { AippConfig, ChargeParams, ChargeResponse, ChargeStatus, AippErrorResponse } from './types';
-
-export class Aipp {
-  private apiKey: string;
-  private baseUrl: string;
-
-  constructor(config: AippConfig) {
-    if (!config.apiKey) {
-      throw new Error('AIPP: apiKey is required');
-    }
-    this.apiKey = config.apiKey;
-    this.baseUrl = config.baseUrl || 'https://aipp.dev';
-  }
-
-  private async request<T>(endpoint: string, options: RequestInit = {}): Promise<T> {
-    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: AippErrorResponse;
-      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() as Promise<T>;
-  }
-
-  /**
-   * Creates a new Lightning Invoice
-   */
-  async createCharge(params: ChargeParams): Promise<ChargeResponse> {
-    if (!params.amountSats && !params.amountUsd) {
-      throw new Error('AIPP: Either amountSats or amountUsd is required');
-    }
-    
-    const body: any = { memo: params.memo };
-    if (params.amountSats) body.amount_sats = params.amountSats;
-    if (params.amountUsd) body.amount_usd = params.amountUsd;
-
-    return this.request<ChargeResponse>('/invoice/create', {
-      method: 'POST',
-      body: JSON.stringify(body),
-    });
-  }
-
-  /**
-   * Checks the status of an existing charge
-   */
-  async getCharge(paymentHash: string): Promise<ChargeStatus> {
-    if (!paymentHash) {
-      throw new Error('AIPP: paymentHash is required');
-    }
-    return this.request<ChargeStatus>(`/invoice/status/${paymentHash}`, {
-      method: 'GET',
-    });
-  }
-
-  /**
-   * Triggers a manual withdrawal of your merchant balance
-   */
-  async payout(): Promise<import('./types').PayoutResponse> {
-    return this.request<import('./types').PayoutResponse>('/merchant/payout', {
-      method: 'POST',
-    });
-  }
-}
+import { AippConfig, ChargeParams, ChargeResponse, ChargeStatus, AippErrorResponse, ReceiptResponse, MarketplaceManifest } from './types';
+
+export class Aipp {
+  private apiKey: string;
+  private baseUrl: string;
+
+  constructor(config: AippConfig) {
+    if (!config.apiKey) {
+      throw new Error('AIPP: apiKey is required');
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl || 'https://aipp.dev';
+  }
+
+  private async request<T>(endpoint: string, options: RequestInit = {}): Promise<T> {
+    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: AippErrorResponse;
+      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() as Promise<T>;
+  }
+
+  /**
+   * Creates a new Invoice (either L402 or x402)
+   */
+  async createCharge(params: ChargeParams): Promise<ChargeResponse> {
+    if (!params.amountSats && !params.amountUsd) {
+      throw new Error('AIPP: Either amountSats or amountUsd is required');
+    }
+    
+    const body: any = { 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<ChargeResponse>('/invoice/create', {
+      method: 'POST',
+      body: JSON.stringify(body),
+    });
+  }
+
+  /**
+   * Checks the status of an existing charge
+   */
+  async getCharge(paymentHash: string, txHash?: string): Promise<ChargeStatus> {
+    if (!paymentHash) {
+      throw new Error('AIPP: paymentHash is required');
+    }
+    const query = txHash ? `?tx_hash=${txHash}` : '';
+    return this.request<ChargeStatus>(`/invoice/status/${paymentHash}${query}`, {
+      method: 'GET',
+    });
+  }
+
+  /**
+   * Triggers a manual withdrawal of your merchant balance
+   */
+  async payout(): Promise<import('./types').PayoutResponse> {
+    return this.request<import('./types').PayoutResponse>('/merchant/payout', {
+      method: 'POST',
+    });
+  }
+
+  /**
+   * Retrieves an EU AI Act Article 26 compliant receipt for a settled invoice.
+   * Only available for invoices with status = 'settled'.
+   */
+  async getReceipt(paymentHash: string): Promise<ReceiptResponse> {
+    if (!paymentHash) {
+      throw new Error('AIPP: paymentHash is required');
+    }
+    return this.request<ReceiptResponse>(`/invoice/receipt/${paymentHash}`, {
+      method: 'GET',
+    });
+  }
+
+  /**
+   * Returns the PaidMCP.dev compatible marketplace manifest for this merchant.
+   * Use this JSON to list your AIPP-protected endpoints on AI agent directories.
+   */
+  async getMarketplaceManifest(): Promise<MarketplaceManifest> {
+    return this.request<MarketplaceManifest>('/paidmcp.json', {
+      method: 'GET',
+    });
+  }
+}

package/src/index.ts

@@ -1,3 +1,3 @@
-export * from './client';
-export * from './types';
-export * from './middleware';
+export * from './client';
+export * from './types';
+export * from './middleware';

package/src/jwt.ts

@@ -1,48 +1,48 @@
-import crypto from 'crypto';
-
-function base64urlEncode(str: string | Buffer): string {
-  const buf = Buffer.isBuffer(str) ? str : Buffer.from(str);
-  return buf.toString('base64url');
-}
-
-function base64urlDecode(str: string): string {
-  return Buffer.from(str, 'base64url').toString('utf8');
-}
-
-export function signJwt(payload: any, secret: string): string {
-  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}`;
-}
-
-export function verifyJwt(token: string, secret: string): any {
-  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');
-  
-  // Constant time comparison to prevent timing attacks
-  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 * 1000) {
-    throw new Error('JWT expired');
-  }
-  
-  return payload;
-}
+import crypto from 'crypto';
+
+function base64urlEncode(str: string | Buffer): string {
+  const buf = Buffer.isBuffer(str) ? str : Buffer.from(str);
+  return buf.toString('base64url');
+}
+
+function base64urlDecode(str: string): string {
+  return Buffer.from(str, 'base64url').toString('utf8');
+}
+
+export function signJwt(payload: any, secret: string): string {
+  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}`;
+}
+
+export function verifyJwt(token: string, secret: string): any {
+  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');
+  
+  // Constant time comparison to prevent timing attacks
+  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 * 1000) {
+    throw new Error('JWT expired');
+  }
+  
+  return payload;
+}

package/src/middleware.ts

@@ -1,86 +1,159 @@
-import crypto from 'crypto';
-import { Aipp } from './client';
-import { signJwt, verifyJwt } from './jwt';
-
-export interface L402Options {
-  client: Aipp;
-  jwtSecret: string;
-  resourceId: string;
-  amountSats?: number;
-  amountUsd?: number;
-  expiresInSeconds?: number;
-}
-
-export function l402Paywall(options: L402Options) {
-  if (!options.amountSats && !options.amountUsd) {
-    throw new Error('Either amountSats or amountUsd must be provided for l402Paywall');
-  }
-
-  return async (req: any, res: any, next: any) => {
-    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 {
-          // Verify JWT signature and expiration
-          const payload = verifyJwt(macaroonStr, options.jwtSecret);
-          
-          if (payload.resource_id !== options.resourceId) {
-            throw new Error('Invalid resource');
-          }
-
-          // Verify preimage hash matches payment_hash securely
-          const preimageHash = crypto.createHash('sha256').update(Buffer.from(preimage, 'hex')).digest('hex');
-          const expectedHash = payload.payment_hash;
-          
-          if (
-            typeof expectedHash === 'string' &&
-            expectedHash.length === preimageHash.length &&
-            crypto.timingSafeEqual(Buffer.from(preimageHash, 'hex'), Buffer.from(expectedHash, 'hex'))
-          ) {
-            valid = true;
-          }
-        } catch (e) {
-          // Invalid or expired JWT -> Fall through to 402 and issue new invoice
-        }
-      }
-    }
-
-    if (valid) {
-      return next();
-    }
-
-    try {
-      // Create invoice via AIPP
-      const charge = await options.client.createCharge({
-        amountSats: options.amountSats,
-        amountUsd: options.amountUsd,
-        memo: `L402 Payment for ${options.resourceId}`
-      });
-
-      // Issue JWT
-      const expiresIn = options.expiresInSeconds || 3600; // default 1 hour
-      const payload = {
-        payment_hash: charge.payment_hash,
-        resource_id: options.resourceId,
-        exp: Math.floor(Date.now() / 1000) + 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: any) {
-      res.status(500).json({ error: "Failed to generate L402 challenge", details: err.message || err });
-    }
-  };
-}
+import crypto from 'crypto';
+import { Aipp } from './client';
+import { signJwt, verifyJwt } from './jwt';
+
+export interface L402Options {
+  client: Aipp;
+  jwtSecret: string;
+  resourceId: string;
+  amountSats?: number;
+  amountUsd?: number;
+  expiresInSeconds?: number;
+}
+
+export function l402Paywall(options: L402Options) {
+  if (!options.amountSats && !options.amountUsd) {
+    throw new Error('Either amountSats or amountUsd must be provided for l402Paywall');
+  }
+
+  return async (req: any, res: any, next: any) => {
+    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 {
+          // Verify JWT signature and expiration
+          const payload = verifyJwt(macaroonStr, options.jwtSecret);
+          
+          if (payload.resource_id !== options.resourceId) {
+            throw new Error('Invalid resource');
+          }
+
+          // Verify preimage hash matches payment_hash securely
+          const preimageHash = crypto.createHash('sha256').update(Buffer.from(preimage, 'hex')).digest('hex');
+          const expectedHash = payload.payment_hash;
+          
+          if (
+            typeof expectedHash === 'string' &&
+            expectedHash.length === preimageHash.length &&
+            crypto.timingSafeEqual(Buffer.from(preimageHash, 'hex'), Buffer.from(expectedHash, 'hex'))
+          ) {
+            valid = true;
+          }
+        } catch (e) {
+          // Invalid or expired JWT -> Fall through to 402 and issue new invoice
+        }
+      }
+    }
+
+    if (valid) {
+      return next();
+    }
+
+    try {
+      // Create invoice via AIPP
+      const charge = await options.client.createCharge({
+        amountSats: options.amountSats,
+        amountUsd: options.amountUsd,
+        memo: `L402 Payment for ${options.resourceId}`
+      });
+
+      // Issue JWT
+      const expiresIn = options.expiresInSeconds || 3600; // default 1 hour
+      const payload = {
+        payment_hash: charge.payment_hash,
+        resource_id: options.resourceId,
+        exp: Math.floor(Date.now() / 1000) + 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: any) {
+      res.status(500).json({ error: "Failed to generate L402 challenge", details: err.message || err });
+    }
+  };
+}
+
+export interface X402Options {
+  client: Aipp;
+  resourceId: string;
+  amountUsd: number;
+}
+
+export function x402Paywall(options: X402Options) {
+  return async (req: any, res: any, next: any) => {
+    const authHeader = req.headers.authorization || req.headers.Authorization;
+    let txHash = (req.query.tx_hash || req.headers['payment-signature'] || req.headers['x-payment-signature']) as string;
+    let paymentHash = (req.query.payment_hash || req.headers['x-payment-hash']) as string;
+
+    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 ')) {
+        // Fallback or double format check
+        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) {
+        // Validation failed, proceed to challenge
+      }
+    }
+
+    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: any) {
+      res.status(500).json({ error: "Failed to generate x402 challenge", details: err.message || err });
+    }
+  };
+}