mkdir whatsapp-payments
cd whatsapp-payments
npm init -y
npm install axios express dotenv stripe @paypal/checkout-server-sdk razorpay

RAPIDAPI_KEY=your_rapidapi_key_here
RAPIDAPI_HOST=whatsapp-messaging-bot.p.rapidapi.com
WHATSAPP_SESSION=payments

# Stripe
STRIPE_SECRET_KEY=sk_live_your_stripe_key_here
STRIPE_PUBLISHABLE_KEY=pk_live_your_publishable_key_here
STRIPE_WEBHOOK_SECRET=whsec_your_webhook_secret_here

# PayPal
PAYPAL_CLIENT_ID=your_paypal_client_id
PAYPAL_CLIENT_SECRET=your_paypal_secret

# Razorpay (for India)
RAZORPAY_KEY_ID=rzp_live_your_key_id
RAZORPAY_KEY_SECRET=your_razorpay_secret

DATABASE_URL=postgresql://user:password@localhost:5432/payments_db

// stripe-client.js
const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);

class StripePaymentClient {
  async createPaymentLink(product) {
    try {
      // Create a payment link
      const paymentLink = await stripe.paymentLinks.create({
        line_items: [
          {
            price_data: {
              currency: product.currency || 'usd',
              product_data: {
                name: product.name,
                description: product.description,
                images: product.images || []
              },
              unit_amount: product.amount * 100 // Convert to cents
            },
            quantity: product.quantity || 1
          }
        ],
        after_completion: {
          type: 'redirect',
          redirect: {
            url: `${process.env.APP_URL}/payment-success?session_id={CHECKOUT_SESSION_ID}`
          }
        },
        metadata: {
          customerPhone: product.customerPhone,
          orderId: product.orderId
        }
      });

      console.log(`✅ Payment link created: ${paymentLink.url}`);
      return paymentLink;
    } catch (error) {
      console.error('Stripe error:', error.message);
      throw error;
    }
  }

  async createCheckoutSession(product, customerPhone) {
    try {
      const session = await stripe.checkout.sessions.create({
        payment_method_types: ['card'],
        line_items: [
          {
            price_data: {
              currency: product.currency || 'usd',
              product_data: {
                name: product.name,
                description: product.description
              },
              unit_amount: product.amount * 100
            },
            quantity: product.quantity || 1
          }
        ],
        mode: 'payment',
        success_url: `${process.env.APP_URL}/payment-success?session_id={CHECKOUT_SESSION_ID}`,
        cancel_url: `${process.env.APP_URL}/payment-cancel`,
        metadata: {
          customerPhone: customerPhone,
          orderId: product.orderId
        }
      });

      return session;
    } catch (error) {
      console.error('Stripe session error:', error.message);
      throw error;
    }
  }

  async verifyPayment(sessionId) {
    try {
      const session = await stripe.checkout.sessions.retrieve(sessionId);
      
      return {
        paymentStatus: session.payment_status,
        customerEmail: session.customer_details?.email,
        amountTotal: session.amount_total / 100,
        currency: session.currency,
        metadata: session.metadata
      };
    } catch (error) {
      console.error('Payment verification error:', error.message);
      throw error;
    }
  }

  async createRefund(paymentIntentId, amount) {
    try {
      const refund = await stripe.refunds.create({
        payment_intent: paymentIntentId,
        amount: amount * 100 // Convert to cents
      });

      console.log(`✅ Refund created: ${refund.id}`);
      return refund;
    } catch (error) {
      console.error('Refund error:', error.message);
      throw error;
    }
  }
}

module.exports = StripePaymentClient;

// whatsapp-payment-bot.js
const WhatsAppClient = require('./whatsapp-client');
const StripePaymentClient = require('./stripe-client');

class WhatsAppPaymentBot {
  constructor() {
    this.whatsapp = new WhatsAppClient();
    this.stripe = new StripePaymentClient();
  }

  async initiatePayment(customerPhone, product) {
    try {
      // Create Stripe payment link
      const paymentLink = await this.stripe.createPaymentLink({
        ...product,
        customerPhone: customerPhone
      });

      // Send payment link via WhatsApp
      const message = `
🛍️ *Your Order Summary*

*Product:* ${product.name}
*Price:* ${product.amount}
*Quantity:* ${product.quantity || 1}

💳 *Ready to complete your purchase?*

Click here to pay securely:
${paymentLink.url}

🔒 Secure payment powered by Stripe
✅ Your information is protected

Questions? Just reply to this message!
      `.trim();

      await this.whatsapp.sendMessage(customerPhone, message);

      console.log(`✅ Payment link sent to ${customerPhone}`);
      return paymentLink;
    } catch (error) {
      console.error('Payment initiation error:', error);
      
      await this.whatsapp.sendMessage(
        customerPhone,
        'Sorry, there was an error processing your payment request. Please try again or contact support.'
      );
    }
  }

  async handlePaymentSuccess(sessionId, customerPhone) {
    try {
      // Verify payment
      const paymentDetails = await this.stripe.verifyPayment(sessionId);

      if (paymentDetails.paymentStatus === 'paid') {
        // Send confirmation via WhatsApp
        const confirmationMessage = `
✅ *Payment Successful!*

Thank you for your purchase!

*Amount paid:* ${paymentDetails.amountTotal}
*Transaction ID:* ${sessionId.substring(0, 12)}...

📦 Your order is being processed and will ship within 24 hours.

📧 Receipt sent to: ${paymentDetails.customerEmail}

Track your order: [link]

Need help? Reply to this message anytime! 🙌
        `.trim();

        await this.whatsapp.sendMessage(customerPhone, confirmationMessage);

        // Trigger fulfillment (ship product, send digital download, etc.)
        await this.fulfillOrder(paymentDetails);

        console.log(`✅ Payment confirmed for ${customerPhone}`);
      }
    } catch (error) {
      console.error('Payment success handler error:', error);
    }
  }

  async handlePaymentFailure(customerPhone, reason) {
    const failureMessage = `
❌ *Payment Failed*

We couldn't process your payment.

*Reason:* ${reason || 'Payment was declined'}

*What you can do:*
1. Try a different payment method
2. Contact your bank
3. Reply here for assistance

We're here to help! 💬
    `.trim();

    await this.whatsapp.sendMessage(customerPhone, failureMessage);
  }

  async fulfillOrder(paymentDetails) {
    // Your fulfillment logic here
    // - Update inventory
    // - Send to shipping provider
    // - Deliver digital products
    // - Update CRM
    
    console.log('🎁 Order fulfilled:', paymentDetails.metadata.orderId);
  }

  async processRefund(customerPhone, orderId, amount) {
    try {
      // Process refund via Stripe
      const refund = await this.stripe.createRefund(orderId, amount);

      // Notify customer
      const refundMessage = `
💰 *Refund Processed*

Your refund has been approved!

*Amount:* ${amount}
*Refund ID:* ${refund.id.substring(0, 12)}...

🏦 Funds will appear in your account within 5-10 business days.

If you have questions, just reply to this message!
      `.trim();

      await this.whatsapp.sendMessage(customerPhone, refundMessage);

      console.log(`✅ Refund processed for ${customerPhone}`);
    } catch (error) {
      console.error('Refund error:', error);
      
      await this.whatsapp.sendMessage(
        customerPhone,
        'There was an issue processing your refund. Our team will review and get back to you within 24 hours.'
      );
    }
  }
}

module.exports = WhatsAppPaymentBot;

// Handle Stripe webhook events
app.post('/webhook/stripe', express.raw({ type: 'application/json' }), async (req, res) => {
  const sig = req.headers['stripe-signature'];
  
  let event;
  
  try {
    event = stripe.webhooks.constructEvent(
      req.body,
      sig,
      process.env.STRIPE_WEBHOOK_SECRET
    );
  } catch (err) {
    console.error('Webhook signature verification failed:', err.message);
    return res.sendStatus(400);
  }

  // Handle the event
  switch (event.type) {
    case 'checkout.session.completed':
      const session = event.data.object;
      
      // Get customer phone from metadata
      const customerPhone = session.metadata.customerPhone;
      
      // Send WhatsApp confirmation
      await paymentBot.handlePaymentSuccess(session.id, customerPhone);
      break;

    case 'payment_intent.payment_failed':
      const failedPayment = event.data.object;
      const phone = failedPayment.metadata.customerPhone;
      const reason = failedPayment.last_payment_error?.message;
      
      await paymentBot.handlePaymentFailure(phone, reason);
      break;

    case 'charge.refunded':
      const refund = event.data.object;
      // Handle refund notification
      break;

    default:
      console.log(`Unhandled event type: ${event.type}`);
  }

  res.sendStatus(200);
});

// paypal-client.js
const paypal = require('@paypal/checkout-server-sdk');

class PayPalClient {
  constructor() {
    const environment = new paypal.core.LiveEnvironment(
      process.env.PAYPAL_CLIENT_ID,
      process.env.PAYPAL_CLIENT_SECRET
    );
    this.client = new paypal.core.PayPalHttpClient(environment);
  }

  async createOrder(product, customerPhone) {
    const request = new paypal.orders.OrdersCreateRequest();
    
    request.prefer('return=representation');
    request.requestBody({
      intent: 'CAPTURE',
      purchase_units: [
        {
          amount: {
            currency_code: product.currency || 'USD',
            value: product.amount.toString()
          },
          description: product.description,
          custom_id: customerPhone // Track customer
        }
      ],
      application_context: {
        return_url: `${process.env.APP_URL}/paypal-success`,
        cancel_url: `${process.env.APP_URL}/paypal-cancel`,
        brand_name: 'Your Store',
        user_action: 'PAY_NOW'
      }
    });

    try {
      const order = await this.client.execute(request);
      
      // Get approval link
      const approvalUrl = order.result.links.find(
        link => link.rel === 'approve'
      ).href;

      return {
        orderId: order.result.id,
        approvalUrl: approvalUrl
      };
    } catch (error) {
      console.error('PayPal order creation error:', error);
      throw error;
    }
  }

  async capturePayment(orderId) {
    const request = new paypal.orders.OrdersCaptureRequest(orderId);
    
    try {
      const capture = await this.client.execute(request);
      return capture.result;
    } catch (error) {
      console.error('PayPal capture error:', error);
      throw error;
    }
  }
}

module.exports = PayPalClient;

async function sendPayPalPaymentLink(customerPhone, product) {
  const paypalClient = new PayPalClient();
  const whatsapp = new WhatsAppClient();

  // Create PayPal order
  const order = await paypalClient.createOrder(product, customerPhone);

  // Send payment link
  const message = `
💳 *Complete Your Purchase*

*Product:* ${product.name}
*Amount:* ${product.amount}

Click here to pay with PayPal:
${order.approvalUrl}

✅ Secure payment
✅ Buyer protection included

Questions? Just reply! 💬
  `.trim();

  await whatsapp.sendMessage(customerPhone, message);

  return order.orderId;
}

// razorpay-client.js
const Razorpay = require('razorpay');

class RazorpayClient {
  constructor() {
    this.razorpay = new Razorpay({
      key_id: process.env.RAZORPAY_KEY_ID,
      key_secret: process.env.RAZORPAY_KEY_SECRET
    });
  }

  async createPaymentLink(product, customerPhone) {
    try {
      const paymentLink = await this.razorpay.paymentLink.create({
        amount: product.amount * 100, // Convert to paise
        currency: 'INR',
        description: product.description,
        customer: {
          contact: customerPhone
        },
        notify: {
          sms: false, // We'll notify via WhatsApp
          email: false
        },
        callback_url: `${process.env.APP_URL}/razorpay-callback`,
        callback_method: 'get'
      });

      return paymentLink;
    } catch (error) {
      console.error('Razorpay error:', error);
      throw error;
    }
  }

  async verifyPayment(paymentId, orderId, signature) {
    const crypto = require('crypto');
    
    const generatedSignature = crypto
      .createHmac('sha256', process.env.RAZORPAY_KEY_SECRET)
      .update(`${orderId}|${paymentId}`)
      .digest('hex');

    return generatedSignature === signature;
  }
}

module.exports = RazorpayClient;

async function sendRazorpayPaymentLink(customerPhone, product) {
  const razorpay = new RazorpayClient();
  const whatsapp = new WhatsAppClient();

  // Create payment link
  const paymentLink = await razorpay.createPaymentLink(product, customerPhone);

  // Send WhatsApp message with payment options
  const message = `
💳 *Complete Your Order*

*Product:* ${product.name}
*Amount:* ₹${product.amount}

Click to pay:
${paymentLink.short_url}

*Payment options:*
✅ UPI (Google Pay, PhonePe, Paytm)
✅ Credit/Debit Card
✅ Net Banking
✅ Wallets

100% secure payment 🔒

Questions? Reply here! 💬
  `.trim();

  await whatsapp.sendMessage(customerPhone, message);

  return paymentLink.id;
}

// Full shopping experience in WhatsApp
class ConversationalCheckout {
  async handleProductInquiry(customerPhone, productId) {
    const product = await getProductById(productId);
    
    // Send product details with image
    await whatsapp.sendImage(
      customerPhone,
      product.imageUrl,
      `
🛍️ *${product.name}*

${product.description}

💰 *Price:* ${product.price}
📦 *In stock:* ${product.stock} available
⭐ *Rating:* ${product.rating}/5 (${product.reviews} reviews)

*Want to buy?* Reply "BUY" to checkout!
      `.trim()
    );
  }

  async handleBuyIntent(customerPhone, productId) {
    const product = await getProductById(productId);
    
    // Create payment
    const paymentLink = await paymentBot.initiatePayment(customerPhone, {
      name: product.name,
      amount: product.price,
      quantity: 1,
      orderId: generateOrderId(),
      description: product.description,
      images: [product.imageUrl]
    });
    
    console.log(`💳 Checkout initiated for ${customerPhone}`);
  }
}

// Sell eBooks, courses, templates
async function sellDigitalProduct(customerPhone, product) {
  // Send payment link
  const paymentLink = await paymentBot.initiatePayment(customerPhone, product);
  
  // Listen for payment webhook (Stripe)
  // On success:
  
  await whatsapp.sendDocument(
    customerPhone,
    product.downloadUrl,
    product.filename,
    `
✅ *Purchase Complete!*

Thank you for buying ${product.name}!

Your digital product is attached below. Feel free to download and enjoy! 🎉

*Need help?* Just reply to this message.

*Like it?* Share with friends! 🙌
    `.trim()
  );
}

// Remind customers about recurring payments
async function sendSubscriptionReminder(customer) {
  const renewalDate = customer.subscriptionRenewsAt;
  const daysUntil = Math.ceil((renewalDate - Date.now()) / (1000 * 60 * 60 * 24));
  
  if (daysUntil === 3) {
    await whatsapp.sendMessage(
      customer.phone,
      `
⏰ *Subscription Renewal Reminder*

Your ${customer.planName} plan renews in *3 days* on ${formatDate(renewalDate)}.

💳 *Amount:* ${customer.planPrice}

Your saved payment method will be charged automatically.

*Want to update your payment method?*
Reply "UPDATE CARD"

*Questions?*
Just reply to this message! 💬
      `.trim()
    );
  }
}

// ❌ NEVER DO THIS
// Don't store card numbers, CVV, or full card details

// ✅ DO THIS INSTEAD
// Store only:
// - Stripe customer ID
// - Payment method ID (tokenized)
// - Last 4 digits for display

// Always verify webhook signatures
const isValid = stripe.webhooks.constructEvent(
  req.body,
  req.headers['stripe-signature'],
  process.env.STRIPE_WEBHOOK_SECRET
);

if (!isValid) {
  return res.sendStatus(400);
}

// Enforce HTTPS for all payment endpoints
if (req.protocol !== 'https' && process.env.NODE_ENV === 'production') {
  return res.redirect('https://' + req.get('host') + req.url);
}

const rateLimit = require('express-rate-limit');

const paymentLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 5, // Limit each phone to 5 payment requests per window
  message: 'Too many payment requests. Please try again later.'
});

app.post('/initiate-payment', paymentLimiter, async (req, res) => {
  // Handle payment initiation
});

// Payment analytics dashboard
async function getPaymentAnalytics() {
  const totalRevenue = await getTotalRevenue();
  const conversionRate = await getWhatsAppConversionRate();
  const avgOrderValue = await getAverageOrderValue();
  const abandonmentRate = await getAbandonmentRate();
  
  return {
    totalRevenue: `${totalRevenue}`,
    conversionRate: `${conversionRate}%`,
    avgOrderValue: `${avgOrderValue}`,
    abandonmentRate: `${abandonmentRate}%`,
    whatsappVsWebConversion: `+${calculateLift()}%`
  };
}