aipp-node 1.2.0 → 1.2.1

package/dist/types.d.ts

@@ -0,0 +1,75 @@
+export interface AippConfig {
+    apiKey: string;
+    baseUrl?: string;
+}
+export interface ChargeParams {
+    amountSats?: number;
+    amountUsd?: number;
+    memo?: string;
+    protocol?: 'L402' | 'x402';
+}
+export interface ChargeResponse {
+    payment_hash: string;
+    protocol: 'L402' | 'x402';
+    amount_usd?: number;
+    pay_to?: string;
+    network?: string;
+    token?: string;
+    payment_request?: string;
+    amount_sats?: number;
+}
+export interface ChargeStatus {
+    paid: boolean;
+    status: 'pending' | 'settled';
+    preimage: string | null;
+}
+export interface AippErrorResponse {
+    error: string;
+    code?: string;
+}
+export interface PayoutResponse {
+    message: string;
+    amount_sats?: number;
+    amount_usd?: number;
+}
+export interface ReceiptCompliance {
+    regulation: string;
+    note: string;
+}
+export interface ReceiptFinancials {
+    currency: string;
+    total_amount: number;
+    merchant_amount: number;
+    platform_fee: number;
+}
+export interface ReceiptPaymentDetails {
+    protocol: string;
+    proof: string | null;
+    merchant_destination: string | null;
+}
+/** EU AI Act Article 26 compliant receipt for a settled invoice */
+export interface ReceiptResponse {
+    receipt_id: string;
+    transaction_id: string;
+    date: string;
+    status: string;
+    compliance: ReceiptCompliance;
+    payment_details: ReceiptPaymentDetails;
+    financials: ReceiptFinancials;
+}
+export interface MarketplaceTool {
+    name: string;
+    description: string;
+    priceUsdt: number;
+}
+/** PaidMCP.dev compatible manifest for listing on AI agent marketplaces */
+export interface MarketplaceManifest {
+    id: string;
+    name: string;
+    tagline: string;
+    description: string;
+    endpoint: string;
+    chains: string[];
+    tools: MarketplaceTool[];
+    tags: string[];
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,32 +1,32 @@
-{
-  "name": "aipp-node",
-  "version": "1.2.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,78 +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 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',
-    });
-  }
-}
+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;
+}