const express = require('express');
const crypto = require('crypto');
const app = express();
app.use(express.json());

const REVIONPAY_URL = 'https://www.revionpay.com/api/v1';
const API_KEY = process.env.REVIONPAY_API_KEY;
const WEBHOOK_SECRET = process.env.REVIONPAY_WEBHOOK_SECRET;

// Create payment
app.post('/checkout', async (req, res) => {
  // network comes from frontend: 'BTC', 'ETH', 'USDT', 'ETH_USDT', etc.
  const { orderId, amount, network, description } = req.body;

  const response = await fetch(REVIONPAY_URL + '/payments', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-api-key': API_KEY,
    },
    body: JSON.stringify({
      amount: amount,
      network: network,  // Required! e.g. 'BTC', 'USDT', 'ETH_USDC'
      fiatCurrency: 'USD',
      orderId: orderId,
      description: description,
    }),
  });

  const payment = await response.json();

  if (!response.ok) {
    return res.status(400).json({ error: payment.message });
  }

  // Return payment URL to frontend — redirect customer there
  res.json({
    paymentId: payment.id,
    paymentUrl: payment.paymentUrl,
  });
});

// Webhook handler
app.post('/webhook/revionpay', (req, res) => {
  // 1. Signature verification
  const signature = req.headers['x-webhook-signature'];
  const body = JSON.stringify(req.body);
  const expected = 'sha256=' + crypto
    .createHmac('sha256', WEBHOOK_SECRET)
    .update(body)
    .digest('hex');

  if (!crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected))) {
    return res.status(401).send('Invalid signature');
  }

  // 2. Handle payment status
  const { paymentId, status, orderId } = req.body;

  switch (status) {
    case 'SETTLED':
      console.log('Payment completed!', orderId);
      await db.orders.update({ where: { id: orderId }, data: { status: 'paid' } });
      await sendConfirmationEmail(orderId);
      break;
    case 'EXPIRED':
      console.log('Payment expired', orderId);
      await db.orders.update({ where: { id: orderId }, data: { status: 'cancelled' } });
      break;
    case 'PROCESSING':
      console.log('Partial payment received', orderId);
      break;
  }

  res.status(200).send('OK');
});

app.listen(4000, () => console.log('Server running on :4000'));

import requests
import hmac
import hashlib
from flask import Flask, request, jsonify

app = Flask(__name__)

REVIONPAY_URL = 'https://www.revionpay.com/api/v1'
API_KEY = 'pk_YOUR_API_KEY_HERE'
WEBHOOK_SECRET = 'whsec_YOUR_WEBHOOK_SECRET'

@app.route('/checkout', methods=['POST'])
def create_checkout():
    data = request.json

    response = requests.post(
        f'{REVIONPAY_URL}/payments',
        json={
            'amount': data['amount'],
            'network': data['network'],  # Required! e.g. 'BTC', 'USDT', 'ETH_USDC'
            'fiatCurrency': 'USD',
            'orderId': data['orderId'],
            'description': data.get('description', ''),
        },
        headers={
            'Content-Type': 'application/json',
            'x-api-key': API_KEY,
        }
    )

    payment = response.json()
    if response.status_code != 201:
        return jsonify({'error': payment.get('message')}), 400

    return jsonify({
        'paymentId': payment['id'],
        'paymentUrl': payment['paymentUrl'],
    })

@app.route('/webhook/revionpay', methods=['POST'])
def handle_webhook():
    # Signature verification
    signature = request.headers.get('x-webhook-signature', '')
    body = request.get_data(as_text=True)
    expected = 'sha256=' + hmac.new(
        WEBHOOK_SECRET.encode(),
        body.encode(),
        hashlib.sha256
    ).hexdigest()

    if not hmac.compare_digest(signature, expected):
        return 'Invalid signature', 401

    data = request.json
    status = data['status']
    order_id = data.get('orderId')

    if status == 'SETTLED':
        print(f'Payment completed: {order_id}')
        db.execute('UPDATE orders SET status = %s WHERE id = %s', ('paid', order_id))

    return 'OK', 200

if __name__ == '__main__':
    app.run(port=4000)

<?php
// Create payment
function createPayment($orderId, $amount, $network, $description) {
    $apiKey = getenv('REVIONPAY_API_KEY');
    $url = 'https://www.revionpay.com/api/v1/payments';

    $data = json_encode([
        'amount'       => $amount,
        'network'      => $network,  // Required! e.g. 'BTC', 'USDT', 'ETH_USDC'
        'fiatCurrency' => 'USD',
        'orderId'      => $orderId,
        'description'  => $description,
    ]);

    $ch = curl_init($url);
    curl_setopt_array($ch, [
        CURLOPT_POST           => true,
        CURLOPT_POSTFIELDS     => $data,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER     => [
            'Content-Type: application/json',
            'x-api-key: ' . $apiKey,
        ],
    ]);

    $response = curl_exec($ch);
    curl_close($ch);

    return json_decode($response, true);
}

// Webhook handler (webhook.php)
$signature = $_SERVER['HTTP_X_WEBHOOK_SIGNATURE'] ?? '';
$body = file_get_contents('php://input');
$secret = getenv('REVIONPAY_WEBHOOK_SECRET');

$expected = 'sha256=' . hash_hmac('sha256', $body, $secret);

if (!hash_equals($expected, $signature)) {
    http_response_code(401);
    exit('Invalid signature');
}

$data = json_decode($body, true);

if ($data['status'] === 'SETTLED') {
    $orderId = $data['orderId'];
    $pdo->prepare('UPDATE orders SET status = ? WHERE id = ?')
        ->execute(['paid', $orderId]);
}

http_response_code(200);
echo 'OK';

<!-- Checkout button example -->
<select id="coin-select">
  <option value="BTC">Bitcoin</option>
  <option value="ETH">Ethereum</option>
  <option value="USDT">USDT (TRC-20)</option>
  <option value="ETH_USDT">USDT (ERC-20)</option>
  <option value="BNB_USDT">USDT (BEP-20)</option>
  <option value="USDC">USDC (TRC-20)</option>
</select>
<button id="pay-btn" onclick="startPayment()">
  Pay Now
</button>

<script>
async function startPayment() {
  const btn = document.getElementById('pay-btn');
  const network = document.getElementById('coin-select').value;
  btn.disabled = true;
  btn.textContent = 'Loading...';

  try {
    // Send request to YOUR backend (which calls RevionPay API)
    const res = await fetch('/checkout', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        orderId: 'order-789',
        amount: '49.99',
        network: network,  // Pass selected coin to your backend
        description: 'Order #789',
      }),
    });

    const data = await res.json();

    if (data.paymentUrl) {
      // Customer is redirected to the crypto payment page
      window.location.href = data.paymentUrl;
    } else {
      alert('Error: ' + (data.error || 'Unknown error'));
    }
  } catch (err) {
    alert('Connection error');
  } finally {
    btn.disabled = false;
    btn.textContent = 'Pay with Bitcoin';
  }
}
</script>