SDK Documentation

pnpm add @profullstack/coinpay

npm install @profullstack/coinpay

# Install globally for CLI access
pnpm add -g @profullstack/coinpay

# Or with npm
npm install -g @profullstack/coinpay

import { CoinPayClient, Blockchain } from '@profullstack/coinpay';

// Initialize with your API key (get it from your dashboard)
const coinpay = new CoinPayClient({
  apiKey: 'cp_live_your_api_key_here',
});

// Create a payment when customer checks out
const result = await coinpay.createPayment({
  businessId: 'your-business-id',  // From your dashboard
  amount: 100,                      // Amount in fiat currency
  currency: 'USD',                  // Fiat currency (default: USD)
  blockchain: Blockchain.BTC,       // Cryptocurrency to accept
  description: 'Order #12345',      // Shown to customer
  metadata: {                       // Your custom data
    orderId: '12345',
    customerEmail: 'customer@example.com'
  }
});

// Display to customer
console.log('Send payment to:', result.payment.payment_address);
console.log('Amount:', result.payment.crypto_amount, result.payment.blockchain);
console.log('QR Code:', result.payment.qr_code);

curl -X POST https://coinpayportal.com/api/payments/create \
  -H "Authorization: Bearer cp_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "business_id": "your-business-id",
    "amount": 100,
    "blockchain": "BTC",
    "description": "Order #12345",
    "metadata": {"orderId": "12345"}
  }'

# Configure your API key (one-time setup)
coinpay config set-key cp_live_your_api_key

# Create a Bitcoin payment
coinpay payment create --business-id biz_123 --amount 100 --blockchain BTC

# Create an Ethereum payment with description
coinpay payment create --business-id biz_123 --amount 50 --blockchain ETH --description "Order #12345"

# Create a USDC payment on Polygon
coinpay payment create --business-id biz_123 --amount 25 --blockchain USDC_POL

# Send with fiat amount (wallet commands)
coinpay wallet send --chain SOL --to abc... --amount-fiat 10 --fiat USD
coinpay wallet send --chain ETH --to 0x123... --amount-fiat 25 --fiat EUR

# Get payment details
coinpay payment get pay_abc123

# List payments
coinpay payment list --business-id biz_123

# Get exchange rates with fiat support
coinpay rates get BTC --fiat USD
coinpay rates get SOL --fiat EUR

import { CoinPayClient } from '@profullstack/coinpay';

const client = new CoinPayClient({
  // Required: Your API key (starts with cp_live_)
  apiKey: 'cp_live_your_api_key_here',
  
  // Optional: Custom API URL (defaults to https://coinpayportal.com/api)
  baseUrl: 'https://coinpayportal.com/api',
  
  // Optional: Request timeout in milliseconds (default: 30000)
  timeout: 30000,
});

const result = await client.createPayment({
  businessId: 'your-business-id',  // Required: From your dashboard
  amount: 100,                      // Required: Amount in fiat
  currency: 'USD',                  // Optional: Fiat currency (default: USD)
  blockchain: 'BTC',                // Required: BTC, ETH, SOL, POL, BCH, USDC_ETH, USDC_POL, USDC_SOL
  description: 'Order #12345',      // Optional: Shown to customer
  metadata: {                       // Optional: Your custom data
    orderId: '12345',
    customerEmail: 'customer@example.com'
  }
});

// Response structure
console.log(result);
// {
//   success: true,
//   payment: {
//     id: 'pay_abc123',
//     payment_address: 'bc1q...',
//     crypto_amount: '0.00234567',
//     blockchain: 'BTC',
//     status: 'pending',
//     expires_at: '2024-01-01T13:00:00Z',
//     qr_code: 'data:image/png;base64,...'
//   },
//   usage: { current: 45, limit: 100, remaining: 55 }
// }

// Check status once
const result = await client.getPayment('pay_abc123');
console.log(result.payment.status); // 'pending', 'confirmed', 'forwarded', etc.

// Or wait for payment to complete (polls automatically)
const payment = await client.waitForPayment('pay_abc123', {
  interval: 5000,      // Check every 5 seconds
  timeout: 600000,     // Give up after 10 minutes
  onStatusChange: (status, payment) => {
    console.log(`Status changed to: ${status}`);
  }
});

if (payment.payment.status === 'confirmed' || payment.payment.status === 'forwarded') {
  console.log('Payment successful!');
} else {
  console.log('Payment failed or expired');
}

const payments = await client.listPayments({
  businessId: 'biz_123',
  status: 'completed', // optional filter
  limit: 20,           // optional, default 50
  offset: 0,           // optional, for pagination
});

console.log(`Found ${payments.length} payments`);

// Get QR code URL for use in HTML <img> tags
const qrUrl = client.getPaymentQRUrl('pay_abc123');
// Returns: "https://coinpayportal.com/api/payments/pay_abc123/qr"

// Use directly in HTML:
// <img src={qrUrl} alt="Payment QR Code" />

// Or fetch as binary data (for server-side processing)
const imageData = await client.getPaymentQR('pay_abc123');

// Save to file (Node.js)
import fs from 'fs';
fs.writeFileSync('payment-qr.png', Buffer.from(imageData));

<!-- Use QR endpoint directly as image source -->
<img src="https://coinpayportal.com/api/payments/pay_abc123/qr" alt="Payment QR Code" />

import { CoinPayClient } from '@profullstack/coinpay';

const client = new CoinPayClient({ apiKey: 'your-api-key' });

// Check what payment methods are available
const support = await client.getPaymentMethodSupport('business-id');

if (support.cards) {
  // Customer can choose crypto OR card
  console.log('✅ Crypto payments available');
  console.log('✅ Card payments available');
  
  // Create card payment
  const cardPayment = await client.createCardPayment({
    businessId: 'biz_123',
    amount: 5000, // $50.00 in cents
    currency: 'usd',
    description: 'Order #12345',
    successUrl: 'https://yourstore.com/success',
    cancelUrl: 'https://yourstore.com/cancel'
  });
  
  // Redirect customer to: cardPayment.checkout_url
  
} else {
  console.log('✅ Crypto payments available');
  console.log('❌ Card payments require Stripe onboarding');
  
  // Only crypto payments available
  const cryptoPayment = await client.createPayment({
    businessId: 'biz_123',
    amount: 50.00,
    currency: 'USD',
    blockchain: 'BTC',
    description: 'Order #12345'
  });
}

// Generate onboarding link for merchant
const onboarding = await client.createStripeOnboardingLink('business-id', {
  email: 'merchant@example.com',
  country: 'US'
});

console.log('Onboarding URL:', onboarding.onboarding_url);
// Redirect merchant to complete Stripe onboarding

// Check onboarding status
const status = await client.getStripeAccountStatus('business-id');
console.log('Can accept cards:', status.onboarding_complete);

// Gateway Mode - Direct payment to merchant
const payment = await client.createCardPayment({
  businessId: 'biz_123',
  amount: 5000, // $50.00 in cents
  currency: 'usd',
  description: 'Order #12345',
  metadata: { orderId: '12345', customerId: 'cust_456' },
  successUrl: 'https://yourstore.com/success',
  cancelUrl: 'https://yourstore.com/cancel',
  escrowMode: false // Direct payment (default)
});

// Redirect customer to payment.checkout_url for card entry

// Escrow Mode - Hold funds until release
const escrowPayment = await client.createCardPayment({
  businessId: 'biz_123',
  amount: 10000, // $100.00 in cents
  currency: 'usd',
  description: 'Freelance Work - Logo Design',
  escrowMode: true, // Hold funds in escrow
  metadata: { projectId: 'proj_789' }
});

// Customer pays via payment.checkout_url
// Funds are held until release

// Later, release funds to merchant
const release = await client.releaseCardEscrow(escrowPayment.escrow_id, 'Work completed successfully');
console.log(`Released $${release.amount_transferred / 100} to merchant`);

import { 
  createQuickCardPayment, 
  formatCardAmount,
  calculateCardPaymentFees
} from '@profullstack/coinpay/card-payments';

// Quick payment with USD amount (auto-converts to cents)
const payment = await createQuickCardPayment(client, 'biz_123', 50.0, 'Order #123', {
  metadata: { orderId: '123' },
  escrowMode: true
});

// Format amounts for display
console.log(formatCardAmount(5000)); // "$50.00"
console.log(formatCardAmount(5050, 'EUR')); // "€50.50"

// Calculate platform fees
const fees = calculateCardPaymentFees(5000, 'free'); // free tier = 1%
console.log(`Platform fee: $${fees.platformFee / 100}`); // "$0.50"
console.log(`Merchant receives: $${fees.merchantReceives / 100}`); // "$49.50"

// Webhook events you'll receive for card payments:
// - card_payment_success: Customer paid successfully
// - card_dispute_created: Customer disputed the charge
// - card_refund: Payment was refunded
// - card_escrow_release: Escrow funds were released to merchant

app.post('/webhook', (req, res) => {
  const { event_type, data } = req.body;
  
  switch (event_type) {
    case 'card_payment_success':
      console.log('Card payment received:', data.amount / 100);
      // Update order status, send confirmation email, etc.
      break;
      
    case 'card_dispute_created':
      console.log('Dispute created for payment:', data.stripe_payment_intent_id);
      // Alert merchant, gather evidence
      break;
      
    case 'card_escrow_release':
      console.log('Escrow released:', data.amount / 100);
      // Mark project as completed, notify freelancer
      break;
  }
  
  res.status(200).send('OK');
});

// Full refund
const refund = await client.refundCardPayment('payment-intent-id');

// Partial refund ($25 out of $50 payment)
const partialRefund = await client.refundCardPayment('payment-intent-id', {
  amount: 2500, // $25.00 in cents
  reason: 'Customer complaint - partial refund'
});

console.log('Refund status:', refund.status);

// Release card escrow funds to merchant
const release = await client.releaseCardEscrow('escrow-id', 'Work completed successfully');
console.log(`Transfer ID: ${release.transfer_id}`);
console.log(`Amount released: $${(release.amount_transferred / 100).toFixed(2)}`);

// Refund card escrow — full refund
const refund = await client.refundCardPayment('escrow-id');
console.log(`Refund ID: ${refund.refund_id}`);

// Refund card escrow — partial refund
const partialRefund = await client.refundCardPayment('escrow-id', {
  amount: 2500, // $25.00 in cents
  reason: 'Partial refund — item returned'
});
console.log(`Refunded: $${(partialRefund.amount_refunded / 100).toFixed(2)}`);
console.log(`Escrow status: ${partialRefund.escrow_status}`); // 'partially_refunded'

# Create a card payment ($50.00 = 5000 cents)
coinpay card create --business-id biz_123 --amount 5000 --description "Order #123"

# Create card payment with escrow mode
coinpay card create --business-id biz_123 --amount 10000 --escrow --description "Freelance work"

# Get card payment details
coinpay card get pay_abc123

# List card payments for a business
coinpay card list --business-id biz_123

# Stripe Connect — onboard a merchant
coinpay card connect onboard merch_123 --email merchant@example.com --country US

# Stripe Connect — check onboarding status
coinpay card connect status merch_123

# Release card escrow funds
coinpay card escrow release esc_123 --reason "Work completed"

# Refund card escrow (full)
coinpay card escrow refund esc_123

# Refund card escrow (partial, $25)
coinpay card escrow refund esc_123 --amount 2500 --reason "Partial refund"

const business = await client.createBusiness({
  name: 'My Store',
  webhookUrl: 'https://your-site.com/webhook',
  walletAddresses: {
    BTC: 'bc1q...',
    ETH: '0x...',
    SOL: '...',
  },
});

console.log(`Business ID: ${business.id}`);
console.log(`API Key: ${business.apiKey}`);

const business = await client.getBusiness('biz_123');

console.log(business.name);
console.log(business.walletAddresses);

const businesses = await client.listBusinesses();

businesses.forEach(biz => {
  console.log(`${biz.name}: ${biz.id}`);
});

const updated = await client.updateBusiness('biz_123', {
  name: 'Updated Store Name',
  webhookUrl: 'https://new-webhook-url.com/webhook',
});

const escrow = await client.createEscrow({
  chain: 'ETH',
  amount: 0.5,
  depositorAddress: '0xAlice...',
  beneficiaryAddress: '0xBob...',
  expiresInHours: 48,  // optional (default: 24, max: 720)
  metadata: { order_id: '12345' },  // optional
});

console.log('Deposit to:', escrow.escrowAddress);
console.log('Release token:', escrow.releaseToken);      // Save this! Given to depositor
console.log('Beneficiary token:', escrow.beneficiaryToken); // Save this! Given to beneficiary

// Convert fiat to crypto
const conversion = await client.convertFiatToCrypto(50, 'USD', 'SOL');
console.log(`$50 USD = ${conversion.cryptoAmount} SOL`);
console.log(`Rate: 1 SOL = $${conversion.rate}`);

// Create escrow with fiat amount (auto-converts internally)
const escrow = await client.createEscrow({
  chain: 'SOL',
  amountFiat: 50,
  fiatCurrency: 'USD',
  depositorAddress: '...',
  beneficiaryAddress: '...',
});

console.log(`Escrow created for $50 USD (${escrow.amount} SOL)`);

const escrow = await client.getEscrow('a1b2c3d4-...');
console.log(escrow.status);  // 'created' | 'funded' | 'released' | 'settled' | ...

const { escrows, total } = await client.listEscrows({
  status: 'funded',
  depositor: '0xAlice...',   // optional
  beneficiary: '0xBob...',   // optional
  limit: 20,
  offset: 0,
});

await client.releaseEscrow('a1b2c3d4-...', 'esc_release_token...');
// Triggers on-chain settlement: funds → beneficiary minus fee

await client.refundEscrow('a1b2c3d4-...', 'esc_release_token...');
// Full amount returned — no platform fee on refunds

await client.disputeEscrow('a1b2c3d4-...', 'esc_any_token...', 
  'Work was not delivered as agreed'
);

const { events } = await client.getEscrowEvents('a1b2c3d4-...');
events.forEach(e => console.log(e.event_type, e.actor, e.created_at));

// Poll until escrow reaches target status (or timeout)
const settled = await client.waitForEscrow('a1b2c3d4-...', 'settled', {
  intervalMs: 5000,   // check every 5s
  timeoutMs: 300000,  // timeout after 5min
});

// Authenticate with escrow token
const { escrow, role } = await client.authenticateEscrow('escrow-id', 'token');
console.log(`Your role: ${role}`); // 'depositor' or 'beneficiary'

// Check available actions based on role and status
if (escrow.status === 'funded') {
  if (role === 'depositor') {
    console.log('Available actions: release, refund, dispute');
  } else if (role === 'beneficiary') {
    console.log('Available actions: dispute');
  }
}

// Depositor can release or refund
const auth = await client.authenticateEscrow(escrowId, releaseToken);
if (auth.role === 'depositor') {
  // Release to beneficiary
  await client.releaseEscrow(escrowId, releaseToken);
  
  // Or refund to self (if needed)
  // await client.refundEscrow(escrowId, releaseToken);
}

// Beneficiary can check status and dispute if needed
const auth = await client.authenticateEscrow(escrowId, beneficiaryToken);
if (auth.role === 'beneficiary') {
  console.log(`Escrow status: ${auth.escrow.status}`);
  
  // Open dispute if work not delivered
  if (auth.escrow.status === 'funded' && workNotDelivered) {
    await client.disputeEscrow(escrowId, beneficiaryToken, 
      'Work was not delivered as agreed upon'
    );
  }
}

const series = await client.createEscrowSeries({
  business_id: 'biz_123',
  payment_method: 'crypto',             // 'crypto' or 'card'
  customer_email: 'client@example.com',
  description: 'Weekly retainer — frontend dev',
  amount: 500,
  currency: 'USD',
  coin: 'USDC_SOL',                     // Required for crypto
  interval: 'weekly',                   // 'weekly' | 'biweekly' | 'monthly'
  max_periods: 12,                      // Optional: stop after N periods
  beneficiary_address: 'Bob...',        // Required for crypto
  // stripe_account_id: 'acct_...',     // Required for card method
});

console.log('Series ID:', series.id);
console.log('Next charge:', series.next_charge_at);

// List all active series
const { series, total } = await client.listEscrowSeries('biz_123', 'active');

// List all series (no status filter)
const all = await client.listEscrowSeries('biz_123');

const { series, escrows } = await client.getEscrowSeries('series_abc123');

console.log('Status:', series.status);
console.log('Periods completed:', series.periods_completed);
escrows.forEach(e => {
  console.log(`  Period ${e.period}: ${e.status} — ${e.amount} ${series.currency}`);
});

// Pause a series
await client.updateEscrowSeries('series_abc123', { status: 'paused' });

// Resume a series
await client.updateEscrowSeries('series_abc123', { status: 'active' });

// Change amount for future periods
await client.updateEscrowSeries('series_abc123', { amount: 750 });

await client.cancelEscrowSeries('series_abc123');
// In-flight escrows are not affected — release or refund them individually

# Create a recurring escrow series
coinpay escrow series create \
  --business-id biz_123 \
  --payment-method crypto \
  --email client@example.com \
  --amount 500 --currency USD --coin USDC_SOL \
  --interval weekly --max-periods 12 \
  --beneficiary Bob...

# List series for a business
coinpay escrow series list --business-id biz_123
coinpay escrow series list --business-id biz_123 --status active

# Get series details (includes child escrows)
coinpay escrow series get series_abc123

# Pause a series
coinpay escrow series pause series_abc123

# Resume a series
coinpay escrow series resume series_abc123

# Cancel a series permanently
coinpay escrow series cancel series_abc123

// Get rate in USD (default)
const rate = await client.getExchangeRate('BTC');
console.log(`1 BTC = $${rate.price} USD`);

// Get rate in specific fiat currency
const eurRate = await client.getExchangeRate('SOL', 'EUR');
console.log(`1 SOL = €${eurRate.price} EUR`);

// Get multiple rates in USD (default)
const rates = await client.getExchangeRates(['BTC', 'ETH', 'SOL']);

// Get multiple rates in specific fiat currency
const gbpRates = await client.getExchangeRates(['BTC', 'ETH', 'SOL'], 'GBP');
console.log(`BTC: £${gbpRates.rates.BTC}`);

// Convert $100 USD to BTC
const conversion = await client.convertFiatToCrypto(100, 'USD', 'BTC');
console.log(`$100 USD = ${conversion.cryptoAmount.toFixed(8)} BTC`);

// Convert €50 EUR to SOL
const eurConversion = await client.convertFiatToCrypto(50, 'EUR', 'SOL');
console.log(`€50 EUR = ${eurConversion.cryptoAmount.toFixed(6)} SOL`);

import { verifyWebhookSignature } from '@profullstack/coinpay';

// In your webhook handler
const isValid = verifyWebhookSignature({
  payload: rawBody,  // Raw request body as string
  signature: req.headers['x-coinpay-signature'],
  secret: 'your-webhook-secret',
});

if (!isValid) {
  return res.status(401).json({ error: 'Invalid signature' });
}

// Process the webhook...

import express from 'express';
import { createWebhookHandler } from '@profullstack/coinpay';

const app = express();

// Use raw body parser for webhook route
app.post('/webhook', 
  express.raw({ type: 'application/json' }),
  createWebhookHandler({
    secret: 'your-webhook-secret',
    onEvent: async (event) => {
      console.log('Received event:', event.type);
      
      switch (event.type) {
        case 'payment.completed':
          // Handle completed payment
          await fulfillOrder(event.payment_id);
          break;
        case 'payment.expired':
          // Handle expired payment
          await cancelOrder(event.payment_id);
          break;
        case 'payment.failed':
          // Handle failed payment
          await notifyCustomer(event.payment_id);
          break;
      }
    },
    onError: (error) => {
      console.error('Webhook error:', error);
    },
  })
);

// Get recent webhook logs for a business
const logs = await client.getWebhookLogs('biz_123', 50);

logs.forEach(log => {
  console.log(`${log.event}: ${log.status} (${log.statusCode})`);
});

// Test webhook endpoint
const result = await client.testWebhook('biz_123', 'payment.completed');
console.log(`Test delivery: ${result.success ? 'OK' : 'Failed'}`);

# Set your API key
coinpay config set-key sk_live_xxxxx

# Set custom API URL (optional)
coinpay config set-url https://custom-api.example.com

# Show current configuration
coinpay config show

# Create a Bitcoin payment
coinpay payment create \
  --business-id biz_123 \
  --amount 100 \
  --blockchain BTC \
  --description "Order #12345"

# Create a USDC payment on Polygon
coinpay payment create \
  --business-id biz_123 \
  --amount 50 \
  --blockchain USDC_POL

# Get payment details
coinpay payment get pay_abc123

# List payments
coinpay payment list --business-id biz_123 --status completed --limit 20

# Generate QR code
coinpay payment qr pay_abc123 --format png > payment-qr.png

# Create a business
coinpay business create --name "My Store" --webhook-url https://example.com/webhook

# Get business details
coinpay business get biz_123

# List all businesses
coinpay business list

# Update business
coinpay business update biz_123 --name "New Name" --webhook-url https://new-url.com/webhook

# Get rate for single cryptocurrency in USD (default)
coinpay rates get BTC

# Get rate in specific fiat currency
coinpay rates get SOL --fiat EUR

# List all supported rates in USD
coinpay rates list

# List all supported rates in EUR
coinpay rates list --fiat EUR

# Create escrow with crypto amount
coinpay escrow create --chain ETH --amount 0.5 \
  --depositor 0xAlice... --beneficiary 0xBob...

# Create escrow with fiat amount
coinpay escrow create --chain SOL --amount-fiat 50 --fiat USD \
  --depositor abc... --beneficiary def...

# Create escrow with EUR amount
coinpay escrow create --chain SOL --amount-fiat 45 --fiat EUR \
  --depositor abc... --beneficiary def...

# Authenticate and manage escrow with token
coinpay escrow auth <id> --token <token>

# Get escrow details
coinpay escrow get a1b2c3d4-...

# List escrows by status
coinpay escrow list --status funded

# Release funds (depositor)
coinpay escrow release a1b2c3d4-... --token esc_abc123...

# Refund (depositor, no fee)
coinpay escrow refund a1b2c3d4-... --token esc_abc123...

# Open dispute (either party)
coinpay escrow dispute a1b2c3d4-... --token esc_def456... \
  --reason "Work not delivered as agreed"

# View audit log
coinpay escrow events a1b2c3d4-...

# View webhook logs
coinpay webhook logs biz_123 --limit 50

# Test webhook endpoint
coinpay webhook test biz_123 --event payment.completed

// Enable Lightning for a wallet (provisions LNbits custodial wallet)
const result = await client.lightning.enableWallet({
  wallet_id: 'your-wallet-uuid',
  mnemonic: 'your bip39 mnemonic words...',
});

console.log('Lightning enabled!', result);

// Register a Lightning Address (username@coinpayportal.com)
const addr = await client.lightning.registerAddress({
  wallet_id: 'your-wallet-uuid',
  username: 'alice',  // 3-32 chars, lowercase alphanumeric
});
console.log('Address:', addr.lightning_address);
// → alice@coinpayportal.com

// Get current Lightning Address
const current = await client.lightning.getAddress('your-wallet-uuid');
console.log(current.lightning_address);

// Check if a username is available
const check = await client.lightning.checkAddressAvailable('alice');
console.log(check.available ? 'Available!' : 'Taken');

const invoice = await client.lightning.createInvoice({
  wallet_id: 'your-wallet-uuid',
  amount_sats: 1000,
  description: 'Coffee payment',
});

console.log('Payment request:', invoice.payment_request);
console.log('Payment hash:', invoice.payment_hash);
// Share the payment_request (BOLT11 string) with the sender

// Send to a Lightning Address
const payment = await client.lightning.sendPayment({
  wallet_id: 'your-wallet-uuid',
  destination: 'bob@coinpayportal.com',
  amount_sats: 100,
});
console.log('Sent!', payment.payment_hash);

// Send to a BOLT11 invoice (amount encoded in invoice)
const payment2 = await client.lightning.sendPayment({
  wallet_id: 'your-wallet-uuid',
  destination: 'lnbc1000n1p...',
});

// List all payments
const result = await client.lightning.listPayments({
  wallet_id: 'your-wallet-uuid',
});

// Filter by direction
const incoming = await client.lightning.listPayments({
  wallet_id: 'your-wallet-uuid',
  direction: 'incoming',
});

// Get specific payment by hash
const payment = await client.lightning.getPayment('abc123...');

# Enable Lightning for a wallet
coinpay ln enable --wallet-id <uuid>

# Register a Lightning Address
coinpay ln address --wallet-id <uuid> --username alice

# Check current Lightning Address
coinpay ln address --wallet-id <uuid>

# Check username availability
coinpay ln address-check --username alice

# Create an invoice
coinpay ln invoice --wallet-id <uuid> --amount 1000 --description "Coffee"

# Send a payment
coinpay ln send --wallet-id <uuid> --to bob@coinpayportal.com --amount 100

# Send to a BOLT11 invoice
coinpay ln send --wallet-id <uuid> --to lnbc1000n1p...

# List payment history
coinpay ln payments --wallet-id <uuid>
coinpay ln payments --wallet-id <uuid> --direction incoming

# Check Lightning balance
coinpay ln balance --wallet-id <uuid>

import { CoinPayClient } from '@profullstack/coinpay';

const client = new CoinPayClient({ apiKey: 'cp_live_your_api_key' });

try {
  const result = await client.createPayment({
    businessId: 'your-business-id',
    amount: 100,
    blockchain: 'BTC',
  });
  
  console.log('Payment created:', result.payment.id);
  console.log('Address:', result.payment.payment_address);
} catch (error) {
  if (error.status === 401) {
    console.error('Invalid API key');
  } else if (error.status === 400) {
    console.error('Invalid request:', error.response?.error);
  } else if (error.status === 429) {
    // Transaction limit exceeded or rate limit
    console.error('Limit exceeded:', error.response?.error);
    console.error('Usage:', error.response?.usage);
  } else {
    console.error('Unexpected error:', error.message);
  }
}

# Register a new merchant account
coinpay auth register --email you@example.com --password yourpassword --name "Your Name"

# Login to get a JWT token (saved to config)
coinpay auth login --email you@example.com --password yourpassword

# Check who you're logged in as
coinpay auth me

import { CoinPayClient, registerMerchant, loginMerchant, getMe } from '@profullstack/coinpay';

// Create a client (no API key needed for registration)
const client = new CoinPayClient({ apiKey: 'unused', baseUrl: 'https://coinpayportal.com' });

// Register a new merchant
const { token, merchant } = await registerMerchant(client, {
  email: 'agent@example.com',
  password: 'securepassword',
  name: 'My Agent'
});
console.log('JWT:', token);
console.log('Merchant ID:', merchant.id);

// Login
const login = await loginMerchant(client, {
  email: 'agent@example.com',
  password: 'securepassword'
});
console.log('JWT:', login.token);

// Get current merchant info (requires JWT auth)
const me = await getMe(client);
console.log('Logged in as:', me.email);

# 1. Register your account
coinpay auth register --email agent@example.com --password mypass123

# 2. Create a business (generates API key)
coinpay business create --name "My Agency" --chain ETH,SOL,BTC

# 3. Set your API key
coinpay config set-key cp_live_your_key_here

# 4. Claim your DID
coinpay reputation did claim

# 5. Check your reputation
coinpay reputation did

import { CoinPayClient } from '@profullstack/coinpay';

const client = new CoinPayClient({ apiKey: 'cp_live_your_api_key' });

// Claim a DID
const did = await client.claimDid({ displayName: 'Agent Smith' });
console.log('DID:', did.did);

// Get your DID
const myDid = await client.getMyDid();
console.log('My DID:', myDid.did);

// Link an external DID
await client.linkDid({ externalDid: 'did:web:example.com' });

// Submit a task receipt (after escrow settlement)
const receipt = await client.submitReceipt({
  escrowId: 'esc_abc123',
  taskDescription: 'Frontend bug fix',
  rating: 5,
  counterpartyDid: 'did:coinpay:xyz789...',
});
console.log('Receipt:', receipt.receiptId);

// Query reputation for a DID
const rep = await client.queryReputation('did:coinpay:abc123...');
console.log('Score:', rep.score, 'Tasks:', rep.totalTasks);

// Get a credential
const cred = await client.getCredential('cred_ghi789');
console.log('Credential:', cred.credential);

// Verify a credential
const result = await client.verifyCredential('cred_ghi789');
console.log('Valid:', result.valid, 'Revoked:', result.revoked);

// Get revocation list
const revocations = await client.getRevocations();
console.log('Revoked credentials:', revocations.revocations.length);

// List all credentials for a DID
const creds = await client.getCredentials('did:key:z6Mk...');
console.log('Credentials:', creds.credentials.length);

// List all task receipts for a DID
const receipts = await client.getReceipts('did:key:z6Mk...');
console.log('Receipts:', receipts.receipts.length);

// Get embeddable reputation badge URL
import { getBadgeUrl } from '@profullstack/coinpay';
const badgeUrl = getBadgeUrl('https://coinpayportal.com', 'did:key:z6Mk...');
// Use in markdown: ![Reputation](badgeUrl)

# Claim a DID
coinpay reputation did claim --name "Agent Smith"

# Get your DID
coinpay reputation did

# Link an external DID
coinpay reputation did link --did "did:web:example.com"

# Submit a receipt
coinpay reputation submit --escrow esc_abc123 --rating 5 --description "Bug fix"

# Query reputation
coinpay reputation query did:key:z6Mk...

# Get a credential
coinpay reputation credential cred_ghi789

# List all your credentials
coinpay reputation credentials

# List credentials for another DID
coinpay reputation credentials did:key:z6Mk...

# List your task receipts
coinpay reputation receipts

# List receipts for another DID
coinpay reputation receipts did:key:z6Mk...

# Get your embeddable reputation badge URL
coinpay reputation badge

# Get badge for another DID
coinpay reputation badge did:key:z6Mk...

# Verify a credential
coinpay reputation verify cred_ghi789

# List revocations
coinpay reputation revocations