@profullstack/coinpay 0.1.0

package/README.md

@@ -0,0 +1,280 @@
+# @profullstack/coinpay
+
+CoinPay SDK & CLI - Cryptocurrency payment integration for Node.js
+
+## Installation
+
+```bash
+# Using pnpm (recommended)
+pnpm add @profullstack/coinpay
+
+# Using npm
+npm install @profullstack/coinpay
+
+# Global CLI installation
+pnpm add -g @profullstack/coinpay
+```
+
+## Quick Start
+
+### SDK Usage
+
+```javascript
+import { CoinPayClient } from '@profullstack/coinpay';
+
+// Initialize the client
+const coinpay = new CoinPayClient({
+  apiKey: 'your-api-key',
+});
+
+// Create a payment
+const payment = await coinpay.createPayment({
+  businessId: 'biz_123',
+  amount: 100,
+  currency: 'USD',
+  cryptocurrency: 'BTC',
+  description: 'Order #12345',
+});
+
+console.log(`Payment address: ${payment.address}`);
+console.log(`Amount: ${payment.cryptoAmount} ${payment.cryptocurrency}`);
+```
+
+### CLI Usage
+
+```bash
+# Configure your API key
+coinpay config set-key sk_live_xxxxx
+
+# Create a payment
+coinpay payment create --business-id biz_123 --amount 100 --currency USD --crypto BTC
+
+# Get payment details
+coinpay payment get pay_abc123
+
+# List payments
+coinpay payment list --business-id biz_123
+
+# Get exchange rates
+coinpay rates get BTC
+```
+
+## SDK API Reference
+
+### CoinPayClient
+
+```javascript
+import { CoinPayClient } from '@profullstack/coinpay';
+
+const client = new CoinPayClient({
+  apiKey: 'your-api-key',
+  baseUrl: 'https://coinpay.dev/api', // optional
+  timeout: 30000, // optional, in milliseconds
+});
+```
+
+### Payments
+
+```javascript
+// Create a payment
+const payment = await client.createPayment({
+  businessId: 'biz_123',
+  amount: 100,
+  currency: 'USD',
+  cryptocurrency: 'BTC',
+  description: 'Order #12345',
+  metadata: JSON.stringify({ orderId: '12345' }),
+  callbackUrl: 'https://your-site.com/webhook',
+});
+
+// Get payment by ID
+const payment = await client.getPayment('pay_abc123');
+
+// List payments
+const payments = await client.listPayments({
+  businessId: 'biz_123',
+  status: 'completed', // optional
+  limit: 20, // optional
+  offset: 0, // optional
+});
+
+// Get payment QR code
+const qr = await client.getPaymentQR('pay_abc123', 'png');
+```
+
+### Exchange Rates
+
+```javascript
+// Get single rate
+const rate = await client.getExchangeRate('BTC', 'USD');
+
+// Get multiple rates
+const rates = await client.getExchangeRates(['BTC', 'ETH', 'SOL'], 'USD');
+```
+
+### Businesses
+
+```javascript
+// Create a business
+const business = await client.createBusiness({
+  name: 'My Store',
+  webhookUrl: 'https://your-site.com/webhook',
+  walletAddresses: {
+    BTC: 'bc1q...',
+    ETH: '0x...',
+  },
+});
+
+// Get business
+const business = await client.getBusiness('biz_123');
+
+// List businesses
+const businesses = await client.listBusinesses();
+
+// Update business
+const updated = await client.updateBusiness('biz_123', {
+  name: 'Updated Name',
+});
+```
+
+### Webhooks
+
+```javascript
+// Get webhook logs
+const logs = await client.getWebhookLogs('biz_123', 50);
+
+// Test webhook
+const result = await client.testWebhook('biz_123', 'payment.completed');
+```
+
+## Webhook Verification
+
+```javascript
+import { verifyWebhookSignature, createWebhookHandler } from '@profullstack/coinpay';
+
+// Manual verification
+const isValid = verifyWebhookSignature({
+  payload: rawBody,
+  signature: req.headers['x-coinpay-signature'],
+  secret: 'your-webhook-secret',
+});
+
+// Express middleware
+app.post('/webhook', createWebhookHandler({
+  secret: 'your-webhook-secret',
+  onEvent: async (event) => {
+    console.log('Received event:', event.type);
+    
+    switch (event.type) {
+      case 'payment.completed':
+        // Handle completed payment
+        break;
+      case 'payment.expired':
+        // Handle expired payment
+        break;
+    }
+  },
+  onError: (error) => {
+    console.error('Webhook error:', error);
+  },
+}));
+```
+
+## Webhook Events
+
+| Event | Description |
+|-------|-------------|
+| `payment.created` | Payment was created |
+| `payment.pending` | Payment is pending confirmation |
+| `payment.confirming` | Payment is being confirmed |
+| `payment.completed` | Payment completed successfully |
+| `payment.expired` | Payment expired |
+| `payment.failed` | Payment failed |
+| `payment.refunded` | Payment was refunded |
+
+## CLI Commands
+
+### Configuration
+
+```bash
+coinpay config set-key <api-key>    # Set API key
+coinpay config set-url <base-url>   # Set custom API URL
+coinpay config show                  # Show current config
+```
+
+### Payments
+
+```bash
+coinpay payment create [options]
+  --business-id <id>    Business ID (required)
+  --amount <amount>     Amount in fiat (required)
+  --currency <code>     Fiat currency (required)
+  --crypto <code>       Cryptocurrency (required)
+  --description <text>  Description (optional)
+
+coinpay payment get <payment-id>
+coinpay payment list --business-id <id> [--status <status>] [--limit <n>]
+coinpay payment qr <payment-id> [--format png|svg]
+```
+
+### Businesses
+
+```bash
+coinpay business create --name <name> [--webhook-url <url>]
+coinpay business get <business-id>
+coinpay business list
+coinpay business update <business-id> [--name <name>] [--webhook-url <url>]
+```
+
+### Exchange Rates
+
+```bash
+coinpay rates get <crypto> [--fiat <currency>]
+coinpay rates list [--fiat <currency>]
+```
+
+### Webhooks
+
+```bash
+coinpay webhook logs <business-id> [--limit <n>]
+coinpay webhook test <business-id> [--event <type>]
+```
+
+## Supported Cryptocurrencies
+
+- **BTC** - Bitcoin
+- **BCH** - Bitcoin Cash
+- **ETH** - Ethereum
+- **MATIC** - Polygon
+- **SOL** - Solana
+
+## Supported Fiat Currencies
+
+- USD, EUR, GBP, CAD, AUD, and more
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `COINPAY_API_KEY` | API key (overrides config file) |
+| `COINPAY_BASE_URL` | Custom API URL |
+
+## Error Handling
+
+```javascript
+try {
+  const payment = await client.createPayment({ ... });
+} catch (error) {
+  if (error.status === 401) {
+    console.error('Invalid API key');
+  } else if (error.status === 400) {
+    console.error('Invalid request:', error.response);
+  } else {
+    console.error('Error:', error.message);
+  }
+}
+```
+
+## License
+
+MIT

package/bin/coinpay.js

@@ -0,0 +1,485 @@
+#!/usr/bin/env node
+
+/**
+ * CoinPay CLI
+ * Command-line interface for CoinPay cryptocurrency payments
+ */
+
+import { CoinPayClient } from '../src/client.js';
+import { PaymentStatus, Cryptocurrency, FiatCurrency } from '../src/payments.js';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const VERSION = '0.1.0';
+const CONFIG_FILE = join(homedir(), '.coinpay.json');
+
+// ANSI colors
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+};
+
+/**
+ * Print colored output
+ */
+const print = {
+  error: (msg) => console.error(`${colors.red}Error:${colors.reset} ${msg}`),
+  success: (msg) => console.log(`${colors.green}✓${colors.reset} ${msg}`),
+  info: (msg) => console.log(`${colors.cyan}ℹ${colors.reset} ${msg}`),
+  warn: (msg) => console.log(`${colors.yellow}⚠${colors.reset} ${msg}`),
+  json: (data) => console.log(JSON.stringify(data, null, 2)),
+};
+
+/**
+ * Load configuration
+ */
+function loadConfig() {
+  try {
+    if (existsSync(CONFIG_FILE)) {
+      return JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'));
+    }
+  } catch {
+    // Ignore errors
+  }
+  return {};
+}
+
+/**
+ * Save configuration
+ */
+function saveConfig(config) {
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+/**
+ * Get API key from config or environment
+ */
+function getApiKey() {
+  const config = loadConfig();
+  return process.env.COINPAY_API_KEY || config.apiKey;
+}
+
+/**
+ * Get base URL from config or environment
+ */
+function getBaseUrl() {
+  const config = loadConfig();
+  return process.env.COINPAY_BASE_URL || config.baseUrl || 'https://coinpay.dev/api';
+}
+
+/**
+ * Create client instance
+ */
+function createClient() {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    print.error('API key not configured. Run: coinpay config set-key <api-key>');
+    process.exit(1);
+  }
+  return new CoinPayClient({ apiKey, baseUrl: getBaseUrl() });
+}
+
+/**
+ * Parse command line arguments
+ */
+function parseArgs(args) {
+  const result = { command: null, subcommand: null, args: [], flags: {} };
+  
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    
+    if (arg.startsWith('--')) {
+      const [key, value] = arg.slice(2).split('=');
+      result.flags[key] = value ?? true;
+    } else if (arg.startsWith('-')) {
+      result.flags[arg.slice(1)] = args[++i] ?? true;
+    } else if (!result.command) {
+      result.command = arg;
+    } else if (!result.subcommand) {
+      result.subcommand = arg;
+    } else {
+      result.args.push(arg);
+    }
+  }
+  
+  return result;
+}
+
+/**
+ * Show help
+ */
+function showHelp() {
+  console.log(`
+${colors.bright}CoinPay CLI${colors.reset} v${VERSION}
+
+${colors.cyan}Usage:${colors.reset}
+  coinpay <command> [options]
+
+${colors.cyan}Commands:${colors.reset}
+  ${colors.bright}config${colors.reset}
+    set-key <api-key>     Set your API key
+    set-url <base-url>    Set custom API URL
+    show                  Show current configuration
+
+  ${colors.bright}payment${colors.reset}
+    create                Create a new payment
+    get <id>              Get payment details
+    list                  List payments
+    qr <id>               Get payment QR code
+
+  ${colors.bright}business${colors.reset}
+    create                Create a new business
+    get <id>              Get business details
+    list                  List businesses
+    update <id>           Update business
+
+  ${colors.bright}rates${colors.reset}
+    get <crypto>          Get exchange rate
+    list                  Get all exchange rates
+
+  ${colors.bright}webhook${colors.reset}
+    logs <business-id>    Get webhook logs
+    test <business-id>    Send test webhook
+
+${colors.cyan}Options:${colors.reset}
+  --help, -h              Show help
+  --version, -v           Show version
+  --json                  Output as JSON
+  --business-id <id>      Business ID for operations
+  --amount <amount>       Payment amount
+  --currency <code>       Fiat currency (USD, EUR, etc.)
+  --crypto <code>         Cryptocurrency (BTC, ETH, etc.)
+
+${colors.cyan}Examples:${colors.reset}
+  coinpay config set-key sk_live_xxxxx
+  coinpay payment create --business-id biz_123 --amount 100 --currency USD --crypto BTC
+  coinpay payment get pay_abc123
+  coinpay rates get BTC
+  coinpay business list
+
+${colors.cyan}Environment Variables:${colors.reset}
+  COINPAY_API_KEY         API key (overrides config)
+  COINPAY_BASE_URL        Custom API URL
+`);
+}
+
+/**
+ * Config commands
+ */
+async function handleConfig(subcommand, args) {
+  const config = loadConfig();
+  
+  switch (subcommand) {
+    case 'set-key':
+      if (!args[0]) {
+        print.error('API key required');
+        return;
+      }
+      config.apiKey = args[0];
+      saveConfig(config);
+      print.success('API key saved');
+      break;
+      
+    case 'set-url':
+      if (!args[0]) {
+        print.error('Base URL required');
+        return;
+      }
+      config.baseUrl = args[0];
+      saveConfig(config);
+      print.success('Base URL saved');
+      break;
+      
+    case 'show':
+      print.info(`Config file: ${CONFIG_FILE}`);
+      print.json({
+        apiKey: config.apiKey ? `${config.apiKey.slice(0, 10)}...` : '(not set)',
+        baseUrl: config.baseUrl || '(default)',
+      });
+      break;
+      
+    default:
+      print.error(`Unknown config command: ${subcommand}`);
+      showHelp();
+  }
+}
+
+/**
+ * Payment commands
+ */
+async function handlePayment(subcommand, args, flags) {
+  const client = createClient();
+  
+  switch (subcommand) {
+    case 'create': {
+      const { 'business-id': businessId, amount, currency, crypto, description } = flags;
+      
+      if (!businessId || !amount || !currency || !crypto) {
+        print.error('Required: --business-id, --amount, --currency, --crypto');
+        return;
+      }
+      
+      const payment = await client.createPayment({
+        businessId,
+        amount: parseFloat(amount),
+        currency,
+        cryptocurrency: crypto,
+        description,
+      });
+      
+      print.success('Payment created');
+      print.json(payment);
+      break;
+    }
+    
+    case 'get': {
+      const paymentId = args[0];
+      if (!paymentId) {
+        print.error('Payment ID required');
+        return;
+      }
+      
+      const payment = await client.getPayment(paymentId);
+      print.json(payment);
+      break;
+    }
+    
+    case 'list': {
+      const { 'business-id': businessId, status, limit } = flags;
+      
+      if (!businessId) {
+        print.error('Required: --business-id');
+        return;
+      }
+      
+      const payments = await client.listPayments({
+        businessId,
+        status,
+        limit: limit ? parseInt(limit, 10) : undefined,
+      });
+      
+      print.json(payments);
+      break;
+    }
+    
+    case 'qr': {
+      const paymentId = args[0];
+      const { format } = flags;
+      
+      if (!paymentId) {
+        print.error('Payment ID required');
+        return;
+      }
+      
+      const qr = await client.getPaymentQR(paymentId, format);
+      print.json(qr);
+      break;
+    }
+    
+    default:
+      print.error(`Unknown payment command: ${subcommand}`);
+      showHelp();
+  }
+}
+
+/**
+ * Business commands
+ */
+async function handleBusiness(subcommand, args, flags) {
+  const client = createClient();
+  
+  switch (subcommand) {
+    case 'create': {
+      const { name, 'webhook-url': webhookUrl } = flags;
+      
+      if (!name) {
+        print.error('Required: --name');
+        return;
+      }
+      
+      const business = await client.createBusiness({ name, webhookUrl });
+      print.success('Business created');
+      print.json(business);
+      break;
+    }
+    
+    case 'get': {
+      const businessId = args[0];
+      if (!businessId) {
+        print.error('Business ID required');
+        return;
+      }
+      
+      const business = await client.getBusiness(businessId);
+      print.json(business);
+      break;
+    }
+    
+    case 'list': {
+      const businesses = await client.listBusinesses();
+      print.json(businesses);
+      break;
+    }
+    
+    case 'update': {
+      const businessId = args[0];
+      const { name, 'webhook-url': webhookUrl } = flags;
+      
+      if (!businessId) {
+        print.error('Business ID required');
+        return;
+      }
+      
+      const updates = {};
+      if (name) updates.name = name;
+      if (webhookUrl) updates.webhookUrl = webhookUrl;
+      
+      const business = await client.updateBusiness(businessId, updates);
+      print.success('Business updated');
+      print.json(business);
+      break;
+    }
+    
+    default:
+      print.error(`Unknown business command: ${subcommand}`);
+      showHelp();
+  }
+}
+
+/**
+ * Rates commands
+ */
+async function handleRates(subcommand, args, flags) {
+  const client = createClient();
+  
+  switch (subcommand) {
+    case 'get': {
+      const crypto = args[0];
+      const { fiat } = flags;
+      
+      if (!crypto) {
+        print.error('Cryptocurrency code required (BTC, ETH, etc.)');
+        return;
+      }
+      
+      const rate = await client.getExchangeRate(crypto, fiat);
+      print.json(rate);
+      break;
+    }
+    
+    case 'list': {
+      const { fiat } = flags;
+      const cryptos = Object.values(Cryptocurrency);
+      const rates = await client.getExchangeRates(cryptos, fiat);
+      print.json(rates);
+      break;
+    }
+    
+    default:
+      print.error(`Unknown rates command: ${subcommand}`);
+      showHelp();
+  }
+}
+
+/**
+ * Webhook commands
+ */
+async function handleWebhook(subcommand, args, flags) {
+  const client = createClient();
+  
+  switch (subcommand) {
+    case 'logs': {
+      const businessId = args[0];
+      const { limit } = flags;
+      
+      if (!businessId) {
+        print.error('Business ID required');
+        return;
+      }
+      
+      const logs = await client.getWebhookLogs(businessId, limit ? parseInt(limit, 10) : undefined);
+      print.json(logs);
+      break;
+    }
+    
+    case 'test': {
+      const businessId = args[0];
+      const { event } = flags;
+      
+      if (!businessId) {
+        print.error('Business ID required');
+        return;
+      }
+      
+      const result = await client.testWebhook(businessId, event);
+      print.success('Test webhook sent');
+      print.json(result);
+      break;
+    }
+    
+    default:
+      print.error(`Unknown webhook command: ${subcommand}`);
+      showHelp();
+  }
+}
+
+/**
+ * Main entry point
+ */
+async function main() {
+  const { command, subcommand, args, flags } = parseArgs(process.argv.slice(2));
+  
+  // Handle global flags
+  if (flags.version || flags.v) {
+    console.log(VERSION);
+    return;
+  }
+  
+  if (flags.help || flags.h || !command) {
+    showHelp();
+    return;
+  }
+  
+  try {
+    switch (command) {
+      case 'config':
+        await handleConfig(subcommand, args);
+        break;
+        
+      case 'payment':
+        await handlePayment(subcommand, args, flags);
+        break;
+        
+      case 'business':
+        await handleBusiness(subcommand, args, flags);
+        break;
+        
+      case 'rates':
+        await handleRates(subcommand, args, flags);
+        break;
+        
+      case 'webhook':
+        await handleWebhook(subcommand, args, flags);
+        break;
+        
+      default:
+        print.error(`Unknown command: ${command}`);
+        showHelp();
+        process.exit(1);
+    }
+  } catch (error) {
+    print.error(error.message);
+    if (flags.debug) {
+      console.error(error);
+    }
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@profullstack/coinpay",
+  "version": "0.1.0",
+  "description": "CoinPay SDK & CLI - Cryptocurrency payment integration for Node.js",
+  "type": "module",
+  "main": "./src/index.js",
+  "bin": {
+    "coinpay": "./bin/coinpay.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./src/index.js",
+      "types": "./src/index.d.ts"
+    },
+    "./payments": {
+      "import": "./src/payments.js",
+      "types": "./src/payments.d.ts"
+    },
+    "./webhooks": {
+      "import": "./src/webhooks.js",
+      "types": "./src/webhooks.d.ts"
+    }
+  },
+  "files": [
+    "src",
+    "bin",
+    "README.md"
+  ],
+  "keywords": [
+    "coinpay",
+    "profullstack",
+    "cryptocurrency",
+    "payments",
+    "bitcoin",
+    "ethereum",
+    "solana",
+    "polygon",
+    "sdk",
+    "cli"
+  ],
+  "author": "Profullstack, Inc.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/profullstack/coinpayportal.git",
+    "directory": "packages/sdk"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "devDependencies": {
+    "vitest": "^2.1.8",
+    "eslint": "^8.57.0",
+    "prettier": "^3.4.1"
+  },
+  "peerDependencies": {},
+  "dependencies": {},
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src bin test",
+    "format": "prettier --write src bin test"
+  }
+}

package/src/client.js

@@ -0,0 +1,254 @@
+/**
+ * CoinPay API Client
+ * Main client class for interacting with the CoinPay API
+ */
+
+const DEFAULT_BASE_URL = 'https://coinpay.dev/api';
+
+/**
+ * CoinPay API Client
+ */
+export class CoinPayClient {
+  #apiKey;
+  #baseUrl;
+  #timeout;
+
+  /**
+   * Create a new CoinPay client
+   * @param {Object} options - Client options
+   * @param {string} options.apiKey - Your CoinPay API key
+   * @param {string} [options.baseUrl] - API base URL (default: https://coinpay.dev/api)
+   * @param {number} [options.timeout] - Request timeout in ms (default: 30000)
+   */
+  constructor({ apiKey, baseUrl = DEFAULT_BASE_URL, timeout = 30000 }) {
+    if (!apiKey) {
+      throw new Error('API key is required');
+    }
+
+    this.#apiKey = apiKey;
+    this.#baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash
+    this.#timeout = timeout;
+  }
+
+  /**
+   * Make an authenticated API request
+   * @param {string} endpoint - API endpoint
+   * @param {Object} [options] - Fetch options
+   * @returns {Promise<Object>} API response
+   */
+  async request(endpoint, options = {}) {
+    const url = `${this.#baseUrl}${endpoint}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.#timeout);
+
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal,
+        headers: {
+          'Content-Type': 'application/json',
+          'X-API-Key': this.#apiKey,
+          ...options.headers,
+        },
+      });
+
+      const data = await response.json();
+
+      if (!response.ok) {
+        const error = new Error(data.error || `HTTP ${response.status}`);
+        error.status = response.status;
+        error.response = data;
+        throw error;
+      }
+
+      return data;
+    } catch (error) {
+      if (error.name === 'AbortError') {
+        throw new Error(`Request timeout after ${this.#timeout}ms`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+
+  /**
+   * Create a new payment
+   * @param {Object} params - Payment parameters
+   * @param {string} params.businessId - Business ID
+   * @param {number} params.amount - Amount in fiat currency
+   * @param {string} params.currency - Fiat currency code (USD, EUR, etc.)
+   * @param {string} params.cryptocurrency - Cryptocurrency code (BTC, ETH, etc.)
+   * @param {string} [params.description] - Payment description
+   * @param {string} [params.metadata] - Custom metadata (JSON string)
+   * @param {string} [params.callbackUrl] - Webhook callback URL
+   * @returns {Promise<Object>} Created payment
+   */
+  async createPayment({
+    businessId,
+    amount,
+    currency,
+    cryptocurrency,
+    description,
+    metadata,
+    callbackUrl,
+  }) {
+    return this.request('/payments/create', {
+      method: 'POST',
+      body: JSON.stringify({
+        businessId,
+        amount,
+        currency,
+        cryptocurrency,
+        description,
+        metadata,
+        callbackUrl,
+      }),
+    });
+  }
+
+  /**
+   * Get payment by ID
+   * @param {string} paymentId - Payment ID
+   * @returns {Promise<Object>} Payment details
+   */
+  async getPayment(paymentId) {
+    return this.request(`/payments/${paymentId}`);
+  }
+
+  /**
+   * List payments for a business
+   * @param {Object} params - Query parameters
+   * @param {string} params.businessId - Business ID
+   * @param {string} [params.status] - Filter by status
+   * @param {number} [params.limit] - Number of results (default: 20)
+   * @param {number} [params.offset] - Pagination offset
+   * @returns {Promise<Object>} List of payments
+   */
+  async listPayments({ businessId, status, limit = 20, offset = 0 }) {
+    const params = new URLSearchParams({
+      businessId,
+      limit: String(limit),
+      offset: String(offset),
+    });
+
+    if (status) {
+      params.set('status', status);
+    }
+
+    return this.request(`/payments?${params.toString()}`);
+  }
+
+  /**
+   * Get payment QR code
+   * @param {string} paymentId - Payment ID
+   * @param {string} [format] - QR code format (png, svg)
+   * @returns {Promise<Object>} QR code data
+   */
+  async getPaymentQR(paymentId, format = 'png') {
+    return this.request(`/payments/${paymentId}/qr?format=${format}`);
+  }
+
+  /**
+   * Get exchange rates
+   * @param {string} cryptocurrency - Cryptocurrency code
+   * @param {string} [fiatCurrency] - Fiat currency code (default: USD)
+   * @returns {Promise<Object>} Exchange rate
+   */
+  async getExchangeRate(cryptocurrency, fiatCurrency = 'USD') {
+    return this.request(`/rates?crypto=${cryptocurrency}&fiat=${fiatCurrency}`);
+  }
+
+  /**
+   * Get multiple exchange rates
+   * @param {string[]} cryptocurrencies - Array of cryptocurrency codes
+   * @param {string} [fiatCurrency] - Fiat currency code (default: USD)
+   * @returns {Promise<Object>} Exchange rates
+   */
+  async getExchangeRates(cryptocurrencies, fiatCurrency = 'USD') {
+    return this.request('/rates/batch', {
+      method: 'POST',
+      body: JSON.stringify({
+        cryptocurrencies,
+        fiatCurrency,
+      }),
+    });
+  }
+
+  /**
+   * Get business details
+   * @param {string} businessId - Business ID
+   * @returns {Promise<Object>} Business details
+   */
+  async getBusiness(businessId) {
+    return this.request(`/businesses/${businessId}`);
+  }
+
+  /**
+   * List businesses
+   * @returns {Promise<Object>} List of businesses
+   */
+  async listBusinesses() {
+    return this.request('/businesses');
+  }
+
+  /**
+   * Create a new business
+   * @param {Object} params - Business parameters
+   * @param {string} params.name - Business name
+   * @param {string} [params.webhookUrl] - Webhook URL
+   * @param {Object} [params.walletAddresses] - Wallet addresses by chain
+   * @returns {Promise<Object>} Created business
+   */
+  async createBusiness({ name, webhookUrl, walletAddresses }) {
+    return this.request('/businesses', {
+      method: 'POST',
+      body: JSON.stringify({
+        name,
+        webhookUrl,
+        walletAddresses,
+      }),
+    });
+  }
+
+  /**
+   * Update business
+   * @param {string} businessId - Business ID
+   * @param {Object} params - Update parameters
+   * @returns {Promise<Object>} Updated business
+   */
+  async updateBusiness(businessId, params) {
+    return this.request(`/businesses/${businessId}`, {
+      method: 'PATCH',
+      body: JSON.stringify(params),
+    });
+  }
+
+  /**
+   * Get webhook logs
+   * @param {string} businessId - Business ID
+   * @param {number} [limit] - Number of results
+   * @returns {Promise<Object>} Webhook logs
+   */
+  async getWebhookLogs(businessId, limit = 50) {
+    return this.request(`/webhooks/logs?businessId=${businessId}&limit=${limit}`);
+  }
+
+  /**
+   * Test webhook endpoint
+   * @param {string} businessId - Business ID
+   * @param {string} [eventType] - Event type to simulate
+   * @returns {Promise<Object>} Test result
+   */
+  async testWebhook(businessId, eventType = 'payment.completed') {
+    return this.request('/webhooks/test', {
+      method: 'POST',
+      body: JSON.stringify({
+        businessId,
+        eventType,
+      }),
+    });
+  }
+}
+
+export default CoinPayClient;

package/src/index.js

@@ -0,0 +1,30 @@
+/**
+ * CoinPay SDK
+ * Cryptocurrency payment integration for Node.js
+ *
+ * @module @profullstack/coinpay
+ */
+
+import { CoinPayClient } from './client.js';
+import { createPayment, getPayment, listPayments } from './payments.js';
+import {
+  verifyWebhookSignature,
+  generateWebhookSignature,
+  parseWebhookPayload,
+  createWebhookHandler,
+  WebhookEvent,
+} from './webhooks.js';
+
+export {
+  CoinPayClient,
+  createPayment,
+  getPayment,
+  listPayments,
+  verifyWebhookSignature,
+  generateWebhookSignature,
+  parseWebhookPayload,
+  createWebhookHandler,
+  WebhookEvent,
+};
+
+export default CoinPayClient;

package/src/payments.js

@@ -0,0 +1,122 @@
+/**
+ * Payment utilities for CoinPay SDK
+ */
+
+import { CoinPayClient } from './client.js';
+
+/**
+ * Create a payment using a client instance or API key
+ * @param {Object} params - Payment parameters
+ * @param {string} params.apiKey - API key (if not using client)
+ * @param {CoinPayClient} [params.client] - Existing client instance
+ * @param {string} params.businessId - Business ID
+ * @param {number} params.amount - Amount in fiat currency
+ * @param {string} params.currency - Fiat currency code
+ * @param {string} params.cryptocurrency - Cryptocurrency code
+ * @param {string} [params.description] - Payment description
+ * @param {string} [params.metadata] - Custom metadata
+ * @param {string} [params.callbackUrl] - Webhook callback URL
+ * @returns {Promise<Object>} Created payment
+ */
+export async function createPayment({
+  apiKey,
+  client,
+  businessId,
+  amount,
+  currency,
+  cryptocurrency,
+  description,
+  metadata,
+  callbackUrl,
+}) {
+  const coinpay = client || new CoinPayClient({ apiKey });
+  
+  return coinpay.createPayment({
+    businessId,
+    amount,
+    currency,
+    cryptocurrency,
+    description,
+    metadata,
+    callbackUrl,
+  });
+}
+
+/**
+ * Get payment by ID
+ * @param {Object} params - Parameters
+ * @param {string} params.apiKey - API key (if not using client)
+ * @param {CoinPayClient} [params.client] - Existing client instance
+ * @param {string} params.paymentId - Payment ID
+ * @returns {Promise<Object>} Payment details
+ */
+export async function getPayment({ apiKey, client, paymentId }) {
+  const coinpay = client || new CoinPayClient({ apiKey });
+  return coinpay.getPayment(paymentId);
+}
+
+/**
+ * List payments
+ * @param {Object} params - Parameters
+ * @param {string} params.apiKey - API key (if not using client)
+ * @param {CoinPayClient} [params.client] - Existing client instance
+ * @param {string} params.businessId - Business ID
+ * @param {string} [params.status] - Filter by status
+ * @param {number} [params.limit] - Number of results
+ * @param {number} [params.offset] - Pagination offset
+ * @returns {Promise<Object>} List of payments
+ */
+export async function listPayments({
+  apiKey,
+  client,
+  businessId,
+  status,
+  limit,
+  offset,
+}) {
+  const coinpay = client || new CoinPayClient({ apiKey });
+  return coinpay.listPayments({ businessId, status, limit, offset });
+}
+
+/**
+ * Payment status constants
+ */
+export const PaymentStatus = {
+  PENDING: 'pending',
+  CONFIRMING: 'confirming',
+  COMPLETED: 'completed',
+  EXPIRED: 'expired',
+  FAILED: 'failed',
+  REFUNDED: 'refunded',
+};
+
+/**
+ * Supported cryptocurrencies
+ */
+export const Cryptocurrency = {
+  BTC: 'BTC',
+  BCH: 'BCH',
+  ETH: 'ETH',
+  MATIC: 'MATIC',
+  SOL: 'SOL',
+};
+
+/**
+ * Supported fiat currencies
+ */
+export const FiatCurrency = {
+  USD: 'USD',
+  EUR: 'EUR',
+  GBP: 'GBP',
+  CAD: 'CAD',
+  AUD: 'AUD',
+};
+
+export default {
+  createPayment,
+  getPayment,
+  listPayments,
+  PaymentStatus,
+  Cryptocurrency,
+  FiatCurrency,
+};

package/src/webhooks.js

@@ -0,0 +1,169 @@
+/**
+ * Webhook utilities for CoinPay SDK
+ */
+
+import { createHmac, timingSafeEqual } from 'crypto';
+
+/**
+ * Webhook event types
+ */
+export const WebhookEvent = {
+  PAYMENT_CREATED: 'payment.created',
+  PAYMENT_PENDING: 'payment.pending',
+  PAYMENT_CONFIRMING: 'payment.confirming',
+  PAYMENT_COMPLETED: 'payment.completed',
+  PAYMENT_EXPIRED: 'payment.expired',
+  PAYMENT_FAILED: 'payment.failed',
+  PAYMENT_REFUNDED: 'payment.refunded',
+  BUSINESS_CREATED: 'business.created',
+  BUSINESS_UPDATED: 'business.updated',
+};
+
+/**
+ * Verify webhook signature
+ * @param {Object} params - Verification parameters
+ * @param {string} params.payload - Raw request body (string)
+ * @param {string} params.signature - Signature from X-CoinPay-Signature header
+ * @param {string} params.secret - Your webhook secret
+ * @param {number} [params.tolerance] - Timestamp tolerance in seconds (default: 300)
+ * @returns {boolean} True if signature is valid
+ */
+export function verifyWebhookSignature({
+  payload,
+  signature,
+  secret,
+  tolerance = 300,
+}) {
+  if (!payload || !signature || !secret) {
+    throw new Error('Missing required parameters: payload, signature, and secret are required');
+  }
+
+  try {
+    // Parse signature header (format: t=timestamp,v1=signature)
+    const parts = signature.split(',');
+    const signatureParts = {};
+    
+    for (const part of parts) {
+      const [key, value] = part.split('=');
+      signatureParts[key] = value;
+    }
+
+    const timestamp = signatureParts.t;
+    const expectedSignature = signatureParts.v1;
+
+    if (!timestamp || !expectedSignature) {
+      return false;
+    }
+
+    // Check timestamp tolerance
+    const timestampAge = Math.floor(Date.now() / 1000) - parseInt(timestamp, 10);
+    if (Math.abs(timestampAge) > tolerance) {
+      return false;
+    }
+
+    // Compute expected signature
+    const signedPayload = `${timestamp}.${payload}`;
+    const computedSignature = createHmac('sha256', secret)
+      .update(signedPayload)
+      .digest('hex');
+
+    // Timing-safe comparison
+    const expectedBuffer = Buffer.from(expectedSignature, 'hex');
+    const computedBuffer = Buffer.from(computedSignature, 'hex');
+
+    if (expectedBuffer.length !== computedBuffer.length) {
+      return false;
+    }
+
+    return timingSafeEqual(expectedBuffer, computedBuffer);
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Parse webhook payload
+ * @param {string} payload - Raw request body
+ * @returns {Object} Parsed webhook event
+ */
+export function parseWebhookPayload(payload) {
+  try {
+    const event = JSON.parse(payload);
+    
+    return {
+      id: event.id,
+      type: event.type,
+      data: event.data,
+      createdAt: new Date(event.created_at),
+      businessId: event.business_id,
+    };
+  } catch (error) {
+    throw new Error(`Failed to parse webhook payload: ${error.message}`);
+  }
+}
+
+/**
+ * Create a webhook handler middleware for Express/Connect
+ * @param {Object} options - Handler options
+ * @param {string} options.secret - Webhook secret
+ * @param {Function} options.onEvent - Event handler function
+ * @param {Function} [options.onError] - Error handler function
+ * @returns {Function} Express middleware
+ */
+export function createWebhookHandler({ secret, onEvent, onError }) {
+  return async (req, res) => {
+    try {
+      const signature = req.headers['x-coinpay-signature'];
+      const payload = typeof req.body === 'string' ? req.body : JSON.stringify(req.body);
+
+      // Verify signature
+      const isValid = verifyWebhookSignature({
+        payload,
+        signature,
+        secret,
+      });
+
+      if (!isValid) {
+        res.status(401).json({ error: 'Invalid signature' });
+        return;
+      }
+
+      // Parse and handle event
+      const event = parseWebhookPayload(payload);
+      await onEvent(event);
+
+      res.status(200).json({ received: true });
+    } catch (error) {
+      if (onError) {
+        onError(error);
+      }
+      res.status(500).json({ error: 'Webhook handler error' });
+    }
+  };
+}
+
+/**
+ * Generate a webhook signature (for testing)
+ * @param {Object} params - Signature parameters
+ * @param {string} params.payload - Request body
+ * @param {string} params.secret - Webhook secret
+ * @param {number} [params.timestamp] - Unix timestamp (default: now)
+ * @returns {string} Signature header value
+ */
+export function generateWebhookSignature({ payload, secret, timestamp }) {
+  const ts = timestamp || Math.floor(Date.now() / 1000);
+  const signedPayload = `${ts}.${payload}`;
+  const signature = createHmac('sha256', secret)
+    .update(signedPayload)
+    .digest('hex');
+
+  return `t=${ts},v1=${signature}`;
+}
+
+export default {
+  WebhookEvent,
+  verifyWebhookSignature,
+  parseWebhookPayload,
+  createWebhookHandler,
+  generateWebhookSignature,
+};