Skip to content

A self-hosted UPI & COD payment gateway with zero per-transaction platform fees, universal JavaScript checkout integration, dynamic QR payments, WhatsApp OTP authentication, and automated payment verification.

JavaScript
36.1 KB
Raw Blame
import { test, describe, before, after } from 'node:test';
import assert from 'node:assert/strict';
import http from 'node:http';
import crypto from 'node:crypto';
import { Database, CustomerRepository, CustomerSessionRepository, PaymentSessionRepository, MerchantRepository } from '@youpi/db';
import { startServer as startPaymentApi } from '../index.js';
import { authHeadersFor } from '../../../../scripts/test-support.js';

describe('YOUPI PG: Device Binding & Duplicate Session Detection', () => {
  let apiInstance;
  let baseUrl;
  let testDb;
  let merchantRepo;
  let sessionRepo;
  let customerRepo;
  let customerSessionRepo;
  let dev1TokenShared;
  const merchantId = '00000000-0000-0000-0000-000000000001';
  const receivingAccountId = '00000000-0000-0000-0000-000000000002';

  before(async () => {
    testDb = new Database({ inMemory: true });
    merchantRepo = new MerchantRepository(testDb);
    sessionRepo = new PaymentSessionRepository(testDb);
    customerRepo = new CustomerRepository(testDb);
    customerSessionRepo = new CustomerSessionRepository(testDb);

    apiInstance = await startPaymentApi(6201, testDb);
    baseUrl = `http://localhost:${apiInstance.port}`;
  });

  after(async () => {
    if (apiInstance) await apiInstance.close();
    if (testDb) testDb.close();
  });

  function request(path, options = {}) {
    return new Promise((resolve, reject) => {
      const url = new URL(path, baseUrl);
      const req = http.request(url, {
        method: options.method || 'GET',
        headers: {
          'Content-Type': 'application/json',
          'x-merchant-id': merchantId,
          ...authHeadersFor(path), ...(options.headers || {})
        }
      }, res => {
        let data = '';
        res.on('data', chunk => { data += chunk; });
        res.on('end', () => {
          let body;
          try {
            body = JSON.parse(data);
          } catch {
            body = data;
          }
          resolve({ status: res.statusCode, headers: res.headers, body });
        });
      });
      req.on('error', reject);
      if (options.body) {
        req.write(typeof options.body === 'string' ? options.body : JSON.stringify(options.body));
      }
      req.end();
    });
  }

  test('1. Device registration (POST /api/v1/devices/register) generates unique deviceId and JWT deviceToken', async () => {
    const res = await request('/api/v1/devices/register', {
      method: 'POST',
      body: {
        publicKey: 'mock-public-key-device-alpha',
        signals: {
          userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0',
          platform: 'Win32',
          screenSignature: '1920x1080x24',
          canvasSignature: 'test-canvas-hash-alpha'
        }
      }
    });

    assert.equal(res.status, 201);
    assert.ok(res.body.deviceId);
    assert.ok(res.body.deviceToken);
    assert.equal(res.body.success, true);
    assert.ok(res.body.deviceId.startsWith('dev_'));
  });

  test('2. Checkout session binds to the first device that accesses it', async () => {
    // Create a payment session
    const createRes = await request('/api/v1/payments', {
      method: 'POST',
      body: {
        orderId: 'ORDER_DEV_001',
        amount: 499.00,
        customerName: 'Aarav Sharma',
        customerPhone: '+919876543210',
        customerEmail: '[email protected]'
      }
    });

    assert.equal(createRes.status, 201);
    const sessionId = createRes.body.paymentId;
    assert.ok(sessionId);

    // Device 1 registers
    const regRes1 = await request('/api/v1/devices/register', {
      method: 'POST',
      body: {
        publicKey: 'dev-1-public-key',
        signals: { userAgent: 'Device-1-Agent' }
      }
    });
    const dev1Id = regRes1.body.deviceId;
    const dev1Token = regRes1.body.deviceToken;
    dev1TokenShared = dev1Token;

    // Device 1 accesses the checkout session state
    const stateRes1 = await request(`/api/v1/checkout/${sessionId}/state`, {
      headers: {
        'x-device-id': dev1Id,
        'x-device-token': dev1Token
      }
    });

    assert.equal(stateRes1.status, 200);
    assert.equal(stateRes1.body.paymentId, sessionId);
    assert.equal(stateRes1.body.deviceId, dev1Id);

    // Verify session in database is bound to dev1Id
    const row = testDb.db.prepare('SELECT device_id FROM payment_sessions WHERE id = ?').get(sessionId);
    assert.equal(row.device_id, dev1Id);
  });

  test('3. Same bound device can perform repeated requests without conflict', async () => {
    const row = testDb.db.prepare('SELECT id, device_id FROM payment_sessions WHERE order_id = ?').get('ORDER_DEV_001');
    const sessionId = row.id;
    const dev1Id = row.device_id;

    // Access again with device 1 and valid token
    const res = await request(`/api/v1/checkout/${sessionId}/state`, {
      headers: {
        'x-device-id': dev1Id,
        'x-device-token': dev1TokenShared
      }
    });
    assert.equal(res.status, 200);

    // Select payment method with device 1 and valid token
    const methodRes = await request(`/api/v1/checkout/${sessionId}/select-method`, {
      method: 'POST',
      headers: {
        'x-device-id': dev1Id,
        'x-device-token': dev1TokenShared
      },
      body: { method: 'UPI' }
    });
    assert.equal(methodRes.status, 200);
  });

  test('4. Different device (dev-2) attempting to access session triggers DUPLICATE_SESSION_DETECTED (HTTP 409)', async () => {
    const row = testDb.db.prepare('SELECT id, device_id FROM payment_sessions WHERE order_id = ?').get('ORDER_DEV_001');
    const sessionId = row.id;

    // Device 2 registers
    const regRes2 = await request('/api/v1/devices/register', {
      method: 'POST',
      body: {
        publicKey: 'dev-2-public-key',
        signals: { userAgent: 'Device-2-Agent' }
      }
    });
    const dev2Id = regRes2.body.deviceId;
    const dev2Token = regRes2.body.deviceToken;

    // Device 2 attempts to fetch state of session bound to Device 1
    const conflictRes = await request(`/api/v1/checkout/${sessionId}/state`, {
      headers: {
        'x-device-id': dev2Id,
        'x-device-token': dev2Token
      }
    });

    assert.equal(conflictRes.status, 409);
    assert.equal(conflictRes.body.error, 'DUPLICATE_SESSION_DETECTED');
    assert.equal(conflictRes.body.action, 'END_SESSION_AND_CREATE_NEW');
    assert.ok(conflictRes.body.message.includes('another device'));
  });

  test('5. Non-bound device (dev-2) is blocked from taking payment actions', async () => {
    const row = testDb.db.prepare('SELECT id, device_id FROM payment_sessions WHERE order_id = ?').get('ORDER_DEV_001');
    const sessionId = row.id;

    // Device 2 attempts to select method
    const resMethod = await request(`/api/v1/checkout/${sessionId}/select-method`, {
      method: 'POST',
      headers: { 'x-device-id': 'dev_unauthorized_999' },
      body: { method: 'COD' }
    });
    assert.equal(resMethod.status, 409);
    assert.equal(resMethod.body.error, 'DUPLICATE_SESSION_DETECTED');

    // Device 2 attempts to confirm COD
    const resCod = await request(`/api/v1/checkout/${sessionId}/confirm-cod`, {
      method: 'POST',
      headers: { 'x-device-id': 'dev_unauthorized_999' }
    });
    assert.equal(resCod.status, 409);
    assert.equal(resCod.body.error, 'DUPLICATE_SESSION_DETECTED');
  });

  test('6. "End Session & Start New Payment" terminates the old session and creates a fresh session bound to the requesting device', async () => {
    const row = testDb.db.prepare('SELECT id, device_id FROM payment_sessions WHERE order_id = ?').get('ORDER_DEV_001');
    const oldSessionId = row.id;

    const regNew = await request('/api/v1/devices/register', {
      method: 'POST',
      body: {
        publicKey: 'dev-recovery-replacement-888-pubkey',
        signals: { userAgent: 'Recovery-Device-Agent' }
      }
    });
    assert.equal(regNew.status, 201);
    const newDevId = regNew.body.deviceId;
    const newDevToken = regNew.body.deviceToken;

    // Call POST /api/v1/checkout/:id/end-and-restart-payment with registered new device
    const restartRes = await request(`/api/v1/checkout/${oldSessionId}/end-and-restart-payment`, {
      method: 'POST',
      headers: {
        'x-device-id': newDevId,
        'x-device-token': newDevToken
      },
      body: { deviceId: newDevId, deviceToken: newDevToken }
    });

    assert.equal(restartRes.status, 201);
    assert.equal(restartRes.body.success, true);
    assert.equal(restartRes.body.oldSessionId, oldSessionId);
    assert.ok(restartRes.body.newSessionId);
    assert.notEqual(restartRes.body.newSessionId, oldSessionId);
    assert.ok(restartRes.body.checkoutUrl.includes(restartRes.body.newSessionId));

    // Verify old session in DB is terminated
    const oldSessionDb = testDb.db.prepare('SELECT status FROM payment_sessions WHERE id = ?').get(oldSessionId);
    assert.equal(oldSessionDb.status, 'CANCELLED');

    // Verify new session in DB is bound to newDevId
    const newSessionDb = testDb.db.prepare('SELECT id, status, device_id, amount_paise, order_id FROM payment_sessions WHERE id = ?').get(restartRes.body.newSessionId);
    assert.ok(newSessionDb);
    assert.equal(newSessionDb.device_id, newDevId);
    assert.equal(newSessionDb.amount_paise, 49900);

    // Verify new device can seamlessly load new session state
    const newStateRes = await request(`/api/v1/checkout/${restartRes.body.newSessionId}/state`, {
      headers: {
        'x-device-id': newDevId,
        'x-device-token': newDevToken
      }
    });
    assert.equal(newStateRes.status, 200);
    assert.equal(newStateRes.body.paymentId, restartRes.body.newSessionId);
  });

  test('7. If a customer binds to a session, another session for the same customer triggers active session conflict', async () => {
    // Create customer & session token
    const cust = customerRepo.create({
      merchantId,
      name: 'Concurrent User',
      email: '[email protected]',
      mobileNumber: '+919999888877'
    });
    const custSess = customerSessionRepo.create({ customerId: cust.id });

    // Create session 1
    const s1Res = await request('/api/v1/payments', {
      method: 'POST',
      body: {
        orderId: 'ORDER_CONC_1',
        amount: 250.00,
        customerName: 'Concurrent User',
        customerPhone: '+919999888877',
        customerEmail: '[email protected]'
      }
    });
    const s1Id = s1Res.body.paymentId;

    // Bind customer to session 1
    const bind1Res = await request(`/api/v1/checkout/${s1Id}/bind-customer`, {
      method: 'POST',
      body: { customerId: cust.id, token: custSess.token }
    });
    assert.equal(bind1Res.status, 200);

    // Create session 2 for same customer
    const s2Res = await request('/api/v1/payments', {
      method: 'POST',
      body: {
        orderId: 'ORDER_CONC_2',
        amount: 350.00,
        customerName: 'Concurrent User',
        customerPhone: '+919999888877',
        customerEmail: '[email protected]'
      }
    });
    const s2Id = s2Res.body.paymentId;

    // Bind customer to session 2 -> conflict detected!
    const bind2Res = await request(`/api/v1/checkout/${s2Id}/bind-customer`, {
      method: 'POST',
      body: { customerId: cust.id, token: custSess.token }
    });

    assert.equal(bind2Res.body.hasActiveSessionConflict, true);
    assert.ok(bind2Res.body.conflictingSession);
    assert.equal(bind2Res.body.conflictingSession.paymentId, s1Id);
  });

  test('8. Prompt 64 Regression: Device A creates ACTIVE Session A, Device B attempts access, Device B chooses "End Session & Start New Payment" -> Session A becomes terminal, slot is released, and Device B\'s new Session B becomes ACTIVE immediately (not queued behind Session A)', async () => {
    // Reset any lingering sessions and clear receiving account slot from prior tests
    testDb.execute("UPDATE payment_sessions SET status = 'CANCELLED' WHERE status IN ('ACTIVE', 'PROCESSING', 'QUEUED')");
    testDb.execute("UPDATE payment_receiving_accounts SET is_slot_busy = 0, current_active_session_id = NULL");

    // 1. Register devices
    const regLaptop = await request('/api/v1/devices/register', {
      method: 'POST',
      body: { publicKey: 'key_laptop_p64', signals: { userAgent: 'Laptop Chrome' } }
    });
    const regMobile = await request('/api/v1/devices/register', {
      method: 'POST',
      body: { publicKey: 'key_mobile_p64', signals: { userAgent: 'Mobile Safari' } }
    });
    const devLaptopId = regLaptop.body.deviceId;
    const devLaptopToken = regLaptop.body.deviceToken;
    const devMobileId = regMobile.body.deviceId;
    const devMobileToken = regMobile.body.deviceToken;

    // 2. Create customer & session token
    const custP64 = customerRepo.create({
      merchantId,
      name: 'Mohit Laptop User',
      email: '[email protected]',
      mobileNumber: '+918796266491'
    });
    const custP64Sess = customerSessionRepo.create({ customerId: custP64.id });

    // 3. Create Session A with autoActivate: true
    const createRes = await request('/api/v1/payments', {
      method: 'POST',
      headers: {
        'x-device-id': devLaptopId,
        'x-device-token': devLaptopToken
      },
      body: {
        orderId: 'ORDER_P64_ALPHA',
        amount: 499.00,
        customerName: 'Mohit Laptop User',
        customerPhone: '+918796266491',
        customerEmail: '[email protected]',
        autoActivate: true
      }
    });

    assert.equal(createRes.status, 201);
    const sessionAId = createRes.body.paymentId;
    assert.ok(sessionAId);

    // Bind Session A to Laptop device
    const bindResA = await request(`/api/v1/checkout/${sessionAId}/bind-customer`, {
      method: 'POST',
      headers: {
        'x-device-id': devLaptopId,
        'x-device-token': devLaptopToken
      },
      body: { customerId: custP64.id, token: custP64Sess.token }
    });
    assert.equal(bindResA.status, 200);

    // Verify Session A is ACTIVE in database and slot is occupied
    const sessionADbBefore = testDb.db.prepare('SELECT id, status, queue_position, device_id, receiving_account_id FROM payment_sessions WHERE id = ?').get(sessionAId);
    assert.equal(sessionADbBefore.status, 'ACTIVE');
    assert.equal(sessionADbBefore.queue_position, 0);
    assert.equal(sessionADbBefore.device_id, devLaptopId);

    const receivingAccBefore = testDb.db.prepare('SELECT is_slot_busy, current_active_session_id FROM payment_receiving_accounts WHERE id = ?').get(sessionADbBefore.receiving_account_id);
    assert.equal(receivingAccBefore.is_slot_busy, 1);
    assert.equal(receivingAccBefore.current_active_session_id, sessionAId);

    // 4. Device B attempts to access Session A -> triggers DUPLICATE_SESSION_DETECTED (HTTP 409)
    const accessResB = await request(`/api/v1/checkout/${sessionAId}/state`, {
      headers: {
        'x-device-id': devMobileId,
        'x-device-token': devMobileToken
      }
    });
    assert.equal(accessResB.status, 409);
    assert.equal(accessResB.body.error, 'DUPLICATE_SESSION_DETECTED');
    assert.equal(accessResB.body.action, 'END_SESSION_AND_CREATE_NEW');
    assert.equal(accessResB.body.boundDeviceId, devLaptopId);

    // 5. Device B chooses "End Session & Start New Payment"
    const restartRes = await request(`/api/v1/checkout/${sessionAId}/end-and-restart-payment`, {
      method: 'POST',
      headers: {
        'x-device-id': devMobileId,
        'x-device-token': devMobileToken
      },
      body: {
        deviceId: devMobileId,
        deviceToken: devMobileToken,
        conflictingSessionId: sessionAId
      }
    });

    assert.equal(restartRes.status, 201);
    assert.equal(restartRes.body.success, true);
    assert.equal(restartRes.body.oldSessionId, sessionAId);
    assert.ok(restartRes.body.newSessionId);
    assert.notEqual(restartRes.body.newSessionId, sessionAId);

    // CRITICAL: Session B must become ACTIVE immediately, NOT QUEUED behind Session A!
    assert.equal(restartRes.body.status, 'ACTIVE', 'New session on Device B must become ACTIVE immediately');
    assert.equal(restartRes.body.queuePosition, 0, 'New session must have queuePosition 0, not queued');

    // 6. Verify database invariants
    // Old Session A must be CANCELLED / terminal
    const sessionADbAfter = testDb.db.prepare('SELECT status, completed_at FROM payment_sessions WHERE id = ?').get(sessionAId);
    assert.equal(sessionADbAfter.status, 'CANCELLED');
    assert.ok(sessionADbAfter.completed_at);

    // Receiving account active slot must be occupied by new Session B
    const receivingAccAfter = testDb.db.prepare('SELECT is_slot_busy, current_active_session_id FROM payment_receiving_accounts WHERE id = ?').get(sessionADbBefore.receiving_account_id);
    assert.equal(receivingAccAfter.is_slot_busy, 1);
    assert.equal(receivingAccAfter.current_active_session_id, restartRes.body.newSessionId);

    // New Session B in DB must be ACTIVE and bound to devMobileId
    const sessionBDb = testDb.db.prepare('SELECT id, status, queue_position, device_id FROM payment_sessions WHERE id = ?').get(restartRes.body.newSessionId);
    assert.equal(sessionBDb.status, 'ACTIVE');
    assert.equal(sessionBDb.queue_position, 0);
    assert.equal(sessionBDb.device_id, devMobileId);

    // 7. Device B loads state for new session seamlessly
    const stateB = await request(`/api/v1/checkout/${restartRes.body.newSessionId}/state`, {
      headers: {
        'x-device-id': devMobileId,
        'x-device-token': devMobileToken
      }
    });
    assert.equal(stateB.status, 200);
    assert.equal(stateB.body.status, 'ACTIVE');
    assert.equal(stateB.body.queuePosition, 0);
    assert.equal(stateB.body.canClickPaymentDone, true);
  });

  test('9. Prompt 64 Queue Invariant: When Session A is terminated, existing queued Customer C is promoted to ACTIVE, and new Session B is queued at position 1', async () => {
    // Reset any lingering sessions and clear receiving account slot from prior tests
    testDb.execute("UPDATE payment_sessions SET status = 'CANCELLED' WHERE status IN ('ACTIVE', 'PROCESSING', 'QUEUED')");
    testDb.execute("UPDATE payment_receiving_accounts SET is_slot_busy = 0, current_active_session_id = NULL");

    const regL = await request('/api/v1/devices/register', {
      method: 'POST',
      body: { publicKey: 'key_laptop_p64_q9', signals: { userAgent: 'Laptop Q9' } }
    });
    const regM = await request('/api/v1/devices/register', {
      method: 'POST',
      body: { publicKey: 'key_mobile_p64_q9', signals: { userAgent: 'Mobile Q9' } }
    });
    const regC = await request('/api/v1/devices/register', {
      method: 'POST',
      body: { publicKey: 'key_other_customer_q9', signals: { userAgent: 'Customer C Q9' } }
    });

    const devLId = regL.body.deviceId;
    const devLToken = regL.body.deviceToken;
    const devMId = regM.body.deviceId;
    const devMToken = regM.body.deviceToken;
    const devCId = regC.body.deviceId;
    const devCToken = regC.body.deviceToken;

    // 1. Create active Session A on devLId
    const sARes = await request('/api/v1/payments', {
      method: 'POST',
      headers: {
        'x-device-id': devLId,
        'x-device-token': devLToken
      },
      body: {
        orderId: 'ORDER_P64_Q9_A',
        amount: 500.00,
        customerName: 'User A',
        customerPhone: '+918888777701',
        customerEmail: '[email protected]',
        autoActivate: true
      }
    });
    const sAId = sARes.body.paymentId;

    // Verify Session A is active
    const sADb = testDb.db.prepare('SELECT status, receiving_account_id FROM payment_sessions WHERE id = ?').get(sAId);
    assert.equal(sADb.status, 'ACTIVE');

    // 2. Customer C arrives concurrently and gets queued
    const sCRes = await request('/api/v1/payments', {
      method: 'POST',
      headers: {
        'x-device-id': devCId,
        'x-device-token': devCToken
      },
      body: {
        orderId: 'ORDER_P64_Q9_C',
        amount: 300.00,
        customerName: 'Queued Customer C',
        customerPhone: '+918888777702',
        customerEmail: '[email protected]',
        autoActivate: true
      }
    });
    const sCId = sCRes.body.paymentId;
    const sCDb = testDb.db.prepare('SELECT status, queue_position FROM payment_sessions WHERE id = ?').get(sCId);
    assert.equal(sCDb.status, 'QUEUED');
    assert.equal(sCDb.queue_position, 1);

    // 3. User A moves from Laptop (devLId) to Mobile (devMId) and ends Session A
    const restartRes = await request(`/api/v1/checkout/${sAId}/end-and-restart-payment`, {
      method: 'POST',
      headers: {
        'x-device-id': devMId,
        'x-device-token': devMToken
      },
      body: {
        deviceId: devMId,
        deviceToken: devMToken,
        conflictingSessionId: sAId
      }
    });

    assert.equal(restartRes.status, 201);
    assert.equal(restartRes.body.success, true);

    // Old Session A must be CANCELLED
    const sADbAfter = testDb.db.prepare('SELECT status FROM payment_sessions WHERE id = ?').get(sAId);
    assert.equal(sADbAfter.status, 'CANCELLED');

    // Customer C must be promoted to ACTIVE with slot
    const sCDbAfter = testDb.db.prepare('SELECT status, queue_position FROM payment_sessions WHERE id = ?').get(sCId);
    assert.equal(sCDbAfter.status, 'ACTIVE');
    assert.equal(sCDbAfter.queue_position, 0);

    const receivingAcc = testDb.db.prepare('SELECT is_slot_busy, current_active_session_id FROM payment_receiving_accounts WHERE id = ?').get(sADb.receiving_account_id);
    assert.equal(receivingAcc.is_slot_busy, 1);
    assert.equal(receivingAcc.current_active_session_id, sCId);

    // New Session B on devMId must be legitimately queued behind Customer C
    assert.equal(restartRes.body.status, 'QUEUED');
    assert.equal(restartRes.body.queuePosition, 1);

    const sBDb = testDb.db.prepare('SELECT status, queue_position, device_id FROM payment_sessions WHERE id = ?').get(restartRes.body.newSessionId);
    assert.equal(sBDb.status, 'QUEUED');
    assert.equal(sBDb.queue_position, 1);
    assert.equal(sBDb.device_id, devMId);
  });

  test('10. When duplicate payment session is detected and user starts new payment, admin queue receives info about ongoing session', async () => {
    // Reset sessions and clear slot
    testDb.execute("UPDATE payment_sessions SET status = 'CANCELLED' WHERE status IN ('ACTIVE', 'PROCESSING', 'QUEUED')");
    testDb.execute("UPDATE payment_receiving_accounts SET is_slot_busy = 0, current_active_session_id = NULL");

    const regA = await request('/api/v1/devices/register', {
      method: 'POST',
      body: { publicKey: 'key_admin_sync_A', signals: { userAgent: 'Admin Sync A' } }
    });
    const regB = await request('/api/v1/devices/register', {
      method: 'POST',
      body: { publicKey: 'key_admin_sync_B', signals: { userAgent: 'Admin Sync B' } }
    });
    const devA = regA.body.deviceId;
    const devAToken = regA.body.deviceToken;
    const devB = regB.body.deviceId;
    const devBToken = regB.body.deviceToken;

    // 1. Create session from scratch
    const createRes = await request('/api/v1/payments', {
      method: 'POST',
      headers: {
        'x-device-id': devA,
        'x-device-token': devAToken
      },
      body: {
        orderId: 'ORDER_ADMIN_SYNC_001',
        amount: 750.00,
        autoActivate: true
      }
    });
    assert.equal(createRes.status, 201);
    const session1Id = createRes.body.paymentId;

    // Verify admin queue sees session 1
    const qRes1 = await request('/api/v1/admin/queue');
    assert.equal(qRes1.status, 200);
    assert.ok(qRes1.body.currentSlot);
    assert.equal(qRes1.body.currentSlot.id, session1Id);
    assert.equal(qRes1.body.currentSlot.orderId, 'ORDER_ADMIN_SYNC_001');

    // 2. Duplicate session detected on Device B
    const conflictRes = await request(`/api/v1/checkout/${session1Id}/state`, {
      headers: {
        'x-device-id': devB,
        'x-device-token': devBToken
      }
    });
    assert.equal(conflictRes.status, 409);
    assert.equal(conflictRes.body.error, 'DUPLICATE_SESSION_DETECTED');

    // 3. Device B clicks "End Session & Start New Payment"
    const restartRes = await request(`/api/v1/checkout/${session1Id}/end-and-restart-payment`, {
      method: 'POST',
      headers: {
        'x-device-id': devB,
        'x-device-token': devBToken
      },
      body: {
        deviceId: devB,
        deviceToken: devBToken,
        conflictingSessionId: session1Id
      }
    });
    assert.equal(restartRes.status, 201);
    assert.equal(restartRes.body.success, true);
    assert.equal(restartRes.body.status, 'ACTIVE');
    const newSessionId = restartRes.body.newSessionId;

    // 4. CRITICAL: Verify admin queue immediately reflects the new ongoing active session!
    const qRes2 = await request('/api/v1/admin/queue');
    assert.equal(qRes2.status, 200);
    assert.ok(qRes2.body.currentSlot, 'Admin queue currentSlot must not be null');
    assert.equal(qRes2.body.currentSlot.id, newSessionId, 'Admin queue must show the new session ID');
    assert.equal(qRes2.body.currentSlot.status, 'ACTIVE', 'Admin queue currentSlot must be ACTIVE');
    assert.equal(qRes2.body.currentSlot.orderId, restartRes.body.orderId, 'Admin queue must show new session order ID');
    assert.ok(qRes2.body.currentSlot.expiresAt, 'Admin queue must have active timer expiresAt');
  });

  test('11. Issue #8 Security: Device binding cannot be bypassed by omitting X-Device-Id, X-Device-Token, or sending unregistered device IDs', async () => {
    const reg = await request('/api/v1/devices/register', {
      method: 'POST',
      body: { publicKey: 'key_issue8_bound_dev', signals: { userAgent: 'Issue8 Bound Agent' } }
    });
    const boundId = reg.body.deviceId;
    const boundToken = reg.body.deviceToken;

    // 1. Unregistered deviceId in POST /api/v1/payments is rejected (no adhoc_ auto-creation)
    const spoofPay = await request('/api/v1/payments', {
      method: 'POST',
      headers: { 'x-device-id': 'dev_unregistered_spoof_123' },
      body: { orderId: 'ORDER_ISSUE8_SPOOF', amount: 100.00 }
    });
    assert.equal(spoofPay.status, 401);
    const adhocRow = testDb.db.prepare('SELECT id FROM devices WHERE id = ?').get('dev_unregistered_spoof_123');
    assert.equal(adhocRow, undefined, 'Must not auto-create adhoc_ device row');

    // 2. Registered deviceId without deviceToken in POST /api/v1/payments is rejected
    const missingTokenPay = await request('/api/v1/payments', {
      method: 'POST',
      headers: { 'x-device-id': boundId },
      body: { orderId: 'ORDER_ISSUE8_NOTOK', amount: 100.00 }
    });
    assert.equal(missingTokenPay.status, 401);

    // 3. Create valid device-bound session
    const validPay = await request('/api/v1/payments', {
      method: 'POST',
      headers: { 'x-device-id': boundId, 'x-device-token': boundToken },
      body: { orderId: 'ORDER_ISSUE8_BOUND_1', amount: 299.00, autoActivate: true }
    });
    assert.equal(validPay.status, 201);
    const sid = validPay.body.paymentId;

    // 4. Omitting X-Device-Id on a device-bound session is rejected with 409 DUPLICATE_SESSION_DETECTED
    const omitIdState = await request(`/api/v1/checkout/${sid}/state`);
    assert.equal(omitIdState.status, 409);
    assert.equal(omitIdState.body.error, 'DUPLICATE_SESSION_DETECTED');

    // 5. Sending X-Device-Id without X-Device-Token on a device-bound session is rejected with 409
    const omitTokenState = await request(`/api/v1/checkout/${sid}/state`, {
      headers: { 'x-device-id': boundId }
    });
    assert.equal(omitTokenState.status, 409);
    assert.equal(omitTokenState.body.error, 'DUPLICATE_SESSION_DETECTED');

    // 6. Spoofing X-Internal-Render: true without internal token is rejected with 409
    const spoofInternal = await request(`/api/v1/checkout/${sid}/state`, {
      headers: { 'x-internal-render': 'true' }
    });
    assert.equal(spoofInternal.status, 409);
    assert.equal(spoofInternal.body.error, 'DUPLICATE_SESSION_DETECTED');

    // 7. Re-calling POST /api/v1/payments for the same order while omitting deviceId is rejected with 409
    const omitIdReCreate = await request('/api/v1/payments', {
      method: 'POST',
      body: { orderId: 'ORDER_ISSUE8_BOUND_1', amount: 299.00 }
    });
    assert.equal(omitIdReCreate.status, 409);
    assert.equal(omitIdReCreate.body.error, 'DUPLICATE_SESSION_DETECTED');
  });

  test('12. Issue #8 Security: /devices/register does not leak deviceToken for existing publicKey without signed challenge, and /devices/verify requires valid credentials and nonce+timestamp signatures', async () => {
    // Generate real ECDSA P-256 keypair
    const { publicKey, privateKey } = crypto.generateKeyPairSync('ec', {
      namedCurve: 'prime256v1'
    });
    const publicKeySpkiBase64 = publicKey.export({ type: 'spki', format: 'der' }).toString('base64');

    // 1. Initial registration succeeds and returns deviceToken
    const reg1 = await request('/api/v1/devices/register', {
      method: 'POST',
      body: { publicKey: publicKeySpkiBase64, signals: { userAgent: 'ECDSA-Agent' } }
    });
    assert.equal(reg1.status, 201);
    const deviceId = reg1.body.deviceId;
    const token1 = reg1.body.deviceToken;
    assert.ok(token1);

    // 2. Re-registering the same publicKey without a signed challenge returns 409 and NO deviceToken
    const regDup = await request('/api/v1/devices/register', {
      method: 'POST',
      body: { publicKey: publicKeySpkiBase64, signals: { userAgent: 'Attacker-Replay' } }
    });
    assert.equal(regDup.status, 409);
    assert.equal(regDup.body.error, 'DEVICE_ALREADY_REGISTERED');
    assert.equal(regDup.body.deviceToken, undefined);
    assert.ok(regDup.body.challenge);

    // 3. Signing the challenge with the ECDSA private key rotates and returns a new deviceToken
    const challengePayload = JSON.stringify({
      deviceId,
      challenge: regDup.body.challenge,
      nonce: crypto.randomBytes(12).toString('hex'),
      timestamp: Date.now()
    });
    const challengeSig = crypto.sign('SHA256', Buffer.from(challengePayload, 'utf8'), {
      key: privateKey,
      dsaEncoding: 'ieee-p1363'
    }).toString('base64');

    const regRotated = await request('/api/v1/devices/register', {
      method: 'POST',
      body: {
        publicKey: publicKeySpkiBase64,
        challenge: regDup.body.challenge,
        payload: challengePayload,
        signature: challengeSig
      }
    });
    assert.equal(regRotated.status, 200);
    assert.ok(regRotated.body.deviceToken);
    assert.notEqual(regRotated.body.deviceToken, token1);
    const activeToken = regRotated.body.deviceToken;

    // 4. /devices/verify with no credential returns 401 { valid: false }
    const verifyEmpty = await request('/api/v1/devices/verify', {
      method: 'POST',
      body: { deviceId }
    });
    assert.equal(verifyEmpty.status, 401);
    assert.equal(verifyEmpty.body.valid, false);

    // 5. /devices/verify with old rotated token fails (401) and with new active token succeeds (200)
    const verifyOld = await request('/api/v1/devices/verify', {
      method: 'POST',
      body: { deviceId, deviceToken: token1 }
    });
    assert.equal(verifyOld.status, 401);
    assert.equal(verifyOld.body.valid, false);

    const verifyNew = await request('/api/v1/devices/verify', {
      method: 'POST',
      body: { deviceId, deviceToken: activeToken }
    });
    assert.equal(verifyNew.status, 200);
    assert.equal(verifyNew.body.valid, true);

    // 6. /devices/verify with signature lacking nonce/timestamp is rejected (401)
    const staticPayload = 'static-message-without-nonce-or-timestamp';
    const staticSig = crypto.sign('SHA256', Buffer.from(staticPayload, 'utf8'), {
      key: privateKey,
      dsaEncoding: 'ieee-p1363'
    }).toString('base64');
    const verifyStatic = await request('/api/v1/devices/verify', {
      method: 'POST',
      body: { deviceId, payload: staticPayload, signature: staticSig }
    });
    assert.equal(verifyStatic.status, 401);
    assert.equal(verifyStatic.body.valid, false);

    // 7. /devices/verify with fresh nonce + timestamp succeeds once, and replay of same nonce is rejected
    const freshPayload = JSON.stringify({
      deviceId,
      nonce: crypto.randomBytes(12).toString('hex'),
      timestamp: Date.now()
    });
    const freshSig = crypto.sign('SHA256', Buffer.from(freshPayload, 'utf8'), {
      key: privateKey,
      dsaEncoding: 'ieee-p1363'
    }).toString('base64');

    const verifySig1 = await request('/api/v1/devices/verify', {
      method: 'POST',
      body: { deviceId, payload: freshPayload, signature: freshSig }
    });
    assert.equal(verifySig1.status, 200);
    assert.equal(verifySig1.body.valid, true);

    const verifySigReplay = await request('/api/v1/devices/verify', {
      method: 'POST',
      body: { deviceId, payload: freshPayload, signature: freshSig }
    });
    assert.equal(verifySigReplay.status, 401);
    assert.equal(verifySigReplay.body.valid, false);
  });

  test('13. Issue #8 Security: bind-customer rejects bare customerId, and cancel / retry / end-and-restart reject PROCESSING sessions and unauthenticated body.customerId', async () => {
    testDb.execute("UPDATE payment_sessions SET status = 'CANCELLED' WHERE status IN ('ACTIVE', 'PROCESSING', 'QUEUED')");
    testDb.execute("UPDATE payment_receiving_accounts SET is_slot_busy = 0, current_active_session_id = NULL");

    const regDev = await request('/api/v1/devices/register', {
      method: 'POST',
      body: { publicKey: 'key_issue8_proc_guard', signals: { userAgent: 'ProcGuard Agent' } }
    });
    const devId = regDev.body.deviceId;
    const devToken = regDev.body.deviceToken;

    const cust = customerRepo.create({
      merchantId,
      name: 'Protected Customer',
      email: '[email protected]',
      mobileNumber: '+919777666555'
    });

    const payRes = await request('/api/v1/payments', {
      method: 'POST',
      headers: { 'x-device-id': devId, 'x-device-token': devToken },
      body: { orderId: 'ORDER_ISSUE8_PROC_1', amount: 199.00, autoActivate: true }
    });
    assert.equal(payRes.status, 201);
    const sid = payRes.body.paymentId;

    // 1. bind-customer with bare customerId (no session token) is rejected with 401
    const bareBind = await request(`/api/v1/checkout/${sid}/bind-customer`, {
      method: 'POST',
      headers: { 'x-device-id': devId, 'x-device-token': devToken },
      body: { customerId: cust.id }
    });
    assert.equal(bareBind.status, 401);

    // 2. Transition session to PROCESSING via payment-done
    const doneRes = await request(`/api/v1/checkout/${sid}/payment-done`, {
      method: 'POST',
      headers: { 'x-device-id': devId, 'x-device-token': devToken }
    });
    assert.equal(doneRes.status, 200);
    assert.equal(doneRes.body.status, 'PROCESSING');

    // 3. cancel on PROCESSING session is rejected with 409 SESSION_PROCESSING
    const cancelRes = await request(`/api/v1/checkout/${sid}/cancel`, {
      method: 'POST',
      headers: { 'x-device-id': devId, 'x-device-token': devToken }
    });
    assert.equal(cancelRes.status, 409);
    assert.equal(cancelRes.body.error, 'SESSION_PROCESSING');

    // 4. retry-new-payment on PROCESSING session is rejected with 409 SESSION_PROCESSING
    const retryRes = await request(`/api/v1/checkout/${sid}/retry-new-payment`, {
      method: 'POST',
      headers: { 'x-device-id': devId, 'x-device-token': devToken }
    });
    assert.equal(retryRes.status, 409);
    assert.equal(retryRes.body.error, 'SESSION_PROCESSING');

    // 5. end-and-restart-payment on PROCESSING session is rejected with 409 SESSION_PROCESSING
    const restartProc = await request(`/api/v1/checkout/${sid}/end-and-restart-payment`, {
      method: 'POST',
      headers: { 'x-device-id': devId, 'x-device-token': devToken },
      body: { deviceId: devId, deviceToken: devToken }
    });
    assert.equal(restartProc.status, 409);
    assert.equal(restartProc.body.error, 'SESSION_PROCESSING');

    // Verify session is still in PROCESSING in DB
    const dbRow = testDb.db.prepare('SELECT status FROM payment_sessions WHERE id = ?').get(sid);
    assert.equal(dbRow.status, 'PROCESSING');

    // 6. end-and-restart-payment with bare customerId in body (no customer token) is rejected with 401
    testDb.execute("UPDATE payment_sessions SET status = 'ACTIVE' WHERE id = ?", [sid]);
    const restartBareCust = await request(`/api/v1/checkout/${sid}/end-and-restart-payment`, {
      method: 'POST',
      headers: { 'x-device-id': devId, 'x-device-token': devToken },
      body: { deviceId: devId, deviceToken: devToken, customerId: cust.id }
    });
    assert.equal(restartBareCust.status, 401);
    assert.equal(restartBareCust.body.error, 'CUSTOMER_AUTH_REQUIRED');
  });
});