Webhooks

    POST https://api.yoursite.com/webhooks/88pay

    from flask import Flask, request, jsonify
    import base64
    import json
    import time
    from cryptography.hazmat.primitives.ciphers.aead import AESGCM
    
    app = Flask(__name__)
    
    # Your 64-char merchant secret key (HEX)
    MERCHANT_SECRET = os.getenv("EIGHTY_EIGHT_PAY_SECRET")
    
    def decrypt_token(secret_hex: str, token_b64: str) -> dict:
        """Decrypt webhook token using AES-256-GCM"""
        key = bytes.fromhex(secret_hex)
        raw = base64.b64decode(token_b64)
        
        iv = raw[:12]
        tag = raw[-16:]
        ciphertext = raw[12:-16]
        
        aesgcm = AESGCM(key)
        plaintext = aesgcm.decrypt(iv, ciphertext + tag, None)
        
        return json.loads(plaintext.decode('utf-8'))
    
    @app.route('/webhooks/88pay', methods=['POST'])
    def webhook_handler():
        try:
            # 1. Extract token
            auth_header = request.headers.get('Authorization', '')
            if not auth_header.startswith('Bearer '):
                return jsonify({'error': 'Missing authorization'}), 401
            
            token = auth_header[7:]  # Remove "Bearer "
            
            # 2. Decrypt and verify
            decrypted = decrypt_token(MERCHANT_SECRET, token)
            
            webhook_data = request.json
            
            # 3. Verify payload
            if decrypted['transaction_id'] != webhook_data['transaction_id']:
                return jsonify({'error': 'Transaction ID mismatch'}), 400
            
            if str(decrypted['transaction_amount']) != webhook_data['transaction_amount']:
                return jsonify({'error': 'Amount mismatch'}), 400
            
            # 4. Verify timestamp (within 5 minutes)
            now = int(time.time() * 1000)
            token_age = now - decrypted['ts']
            if token_age > 300000:  # 5 minutes
                return jsonify({'error': 'Token expired'}), 400
            
            # 5. Process async
            process_webhook_async(webhook_data)
            
            # 6. Always respond 200 OK
            return jsonify({'received': True}), 200
            
        except Exception as e:
            print(f'Webhook error: {e}')
            # Still return 200 to prevent retries
            return jsonify({'received': True, 'error': str(e)}), 200
    
    def process_webhook_async(webhook):
        """Process webhook asynchronously"""
        status = webhook['transaction_status']
        reference = webhook['transaction_reference']
        
        # Check idempotency
        existing = db.webhooks.find_one({'reference': reference})
        if existing and existing.get('processed'):
            print(f'Webhook already processed: {reference}')
            return
        
        # Save webhook
        db.webhooks.insert_one({
            'reference': reference,
            'status': status,
            'amount': webhook['transaction_amount'],
            'received_at': datetime.now(),
            'processed': False
        })
        
        # Handle status
        if status == 'COMPLETED':
            handle_payment_success(reference)
        elif status == 'REJECTED':
            handle_payment_failure(reference)
        elif status == 'PENDING':
            handle_payment_pending(reference)
        
        # Mark processed
        db.webhooks.update_one(
            {'reference': reference},
            {'$set': {'processed': True, 'processed_at': datetime.now()}}
        )
    
    if __name__ == '__main__':
        app.run(port=3000)

    <?php
    // webhook.php
    
    // Your 64-char merchant secret key (HEX)
    $merchantSecret = getenv('EIGHTY_EIGHT_PAY_SECRET');
    
    /**
     * Decrypt webhook token
     */
    function decryptToken($secretHex, $tokenB64) {
        $key = hex2bin($secretHex);
        $raw = base64_decode($tokenB64, true);
        
        $iv = substr($raw, 0, 12);
        $tag = substr($raw, -16);
        $ciphertext = substr($raw, 12, -16);
        
        $plaintext = openssl_decrypt(
            $ciphertext,
            'aes-256-gcm',
            $key,
            OPENSSL_RAW_DATA,
            $iv,
            $tag
        );
        
        if ($plaintext === false) {
            throw new Exception('Decryption failed');
        }
        
        return json_decode($plaintext, true);
    }
    
    // Get Authorization header
    $headers = getallheaders();
    $authHeader = $headers['Authorization'] ?? '';
    
    if (!str_starts_with($authHeader, 'Bearer ')) {
        http_response_code(401);
        echo json_encode(['error' => 'Missing authorization']);
        exit;
    }
    
    $token = substr($authHeader, 7); // Remove "Bearer "
    
    // Get webhook payload
    $payload = json_decode(file_get_contents('php://input'), true);
    
    try {
        // Decrypt and verify token
        $decrypted = decryptToken($merchantSecret, $token);
        
        // Verify payload matches token
        if ($decrypted['transaction_id'] !== $payload['transaction_id']) {
            throw new Exception('Transaction ID mismatch');
        }
        
        if ($decrypted['transaction_amount'] != $payload['transaction_amount']) {
            throw new Exception('Amount mismatch');
        }
        
        // Verify timestamp (within 5 minutes)
        $now = round(microtime(true) * 1000);
        $tokenAge = $now - $decrypted['ts'];
        if ($tokenAge > 300000) {
            throw new Exception('Token expired');
        }
        
        // Process webhook (async recommended)
        processWebhook($payload);
        
        // Always respond 200 OK
        http_response_code(200);
        echo json_encode(['received' => true]);
        
    } catch (Exception $e) {
        error_log('Webhook error: ' . $e->getMessage());
        
        // Still return 200 to prevent retries
        http_response_code(200);
        echo json_encode([
            'received' => true,
            'error' => $e->getMessage()
        ]);
    }
    
    function processWebhook($webhook) {
        global $db;
        
        $status = $webhook['transaction_status'];
        $reference = $webhook['transaction_reference'];
        
        // Check idempotency
        $existing = $db->webhooks->findOne(['reference' => $reference]);
        if ($existing && $existing['processed']) {
            error_log("Webhook already processed: $reference");
            return;
        }
        
        // Save webhook
        $db->webhooks->insertOne([
            'reference' => $reference,
            'status' => $status,
            'amount' => $webhook['transaction_amount'],
            'received_at' => new DateTime(),
            'processed' => false
        ]);
        
        // Handle status
        switch ($status) {
            case 'COMPLETED':
                handlePaymentSuccess($reference);
                break;
            case 'REJECTED':
                handlePaymentFailure($reference);
                break;
            case 'PENDING':
                handlePaymentPending($reference);
                break;
        }
        
        // Mark processed
        $db->webhooks->updateOne(
            ['reference' => $reference],
            ['$set' => [
                'processed' => true,
                'processed_at' => new DateTime()
            ]]
        );
    }
    ?>

    # Install
    npm install -g localtunnel
    
    # Expose port 3000
    lt --port 3000 --subdomain myapp
    
    # Use: https://myapp.loca.lt/webhooks/88pay