Testing in Sandbox

Overview

The Modulus Labs Sandbox environment allows you to test your QR Ph integration without processing real payments. The sandbox mirrors production behavior, making it perfect for development and testing.

Sandbox vs. Production: The sandbox environment uses separate credentials and URLs. No real money changes hands in sandbox mode.

Prerequisites

Before testing, ensure you have:

Sandbox Credentials

Secret Key (for authentication)
Encryption Key (for JWE tokens)
Activation Code (for your sub-merchant account)

Webhook Integration

Development Environment

Set up your local development environment with the required libraries (jose, axios, etc.)

Testing Workflow

Testing Dynamic QR Ph requires simulating the entire payment flow:

Create a webhook endpoint to receive transaction status updates

Create QR Code

Generate a Dynamic QR Ph using the Create API

Convert QR Body

Convert the Base64-encoded QR body to an image

Decode QR Image

Extract the raw QR value from the generated image

Simulate Payment

Use the Simulate Webhook API to trigger a payment event

Receive Webhook

Your webhook endpoint receives the transaction status

Step 1: Register a Webhook

First, register your webhook URL to receive payment notifications:

curl -X POST https://qrph.sbx.moduluslabs.io/v1/webhooks \
  -u sk_YOUR_SECRET_KEY: \
  -H "Content-Type: application/json" \
  -d '{
    "callbackUrl": "https://your-app.com/webhooks/qr-payment",
    "events": ["payment.succeeded", "payment.failed"]
  }'

Use services like webhook.site or ngrok to create temporary webhook endpoints for testing.

Step 2: Create a Dynamic QR Code

Generate a QR code for testing:

const axios = require('axios');
const jose = require('jose');

const SECRET_KEY = 'sk_YOUR_SECRET_KEY';
const ENCRYPTION_KEY = 'YOUR_ENCRYPTION_KEY';

async function createQR() {
  // Encrypt payload
  const payload = {
    activationCode: 'A9X4-B7P2-Q6Z8-M3L5',
    currency: 'PHP',
    amount: '500.00',
    merchantReferenceNumber: crypto.randomUUID()
  };

  const key = Buffer.from(ENCRYPTION_KEY, 'base64');
  const jweToken = await new jose.CompactEncrypt(
    new TextEncoder().encode(JSON.stringify(payload))
  )
    .setProtectedHeader({ alg: 'A256KW', enc: 'A256CBC-HS512' })
    .encrypt(key);

  // Make API request
  const response = await axios.post(
    'https://qrph.sbx.moduluslabs.io/v1/pay/qr',
    { Token: jweToken },
    {
      auth: { username: SECRET_KEY, password: '' },
      headers: { 'Content-Type': 'application/json' }
    }
  );

  // Decrypt response
  const { plaintext } = await jose.compactDecrypt(response.data.Token, key);
  const result = JSON.parse(new TextDecoder().decode(plaintext));

  console.log('Transaction ID:', result.id);
  console.log('QR Body (Base64):', result.qrBody);

  return result;
}

createQR();

# First, encrypt your payload (use a script or library)
# Then make the request:

curl -X POST https://qrph.sbx.moduluslabs.io/v1/pay/qr \
  -u sk_YOUR_SECRET_KEY: \
  -H "Content-Type: application/json" \
  -d '{
    "Token": "eyJhbGciOiJBMjU2S1ciL..."
  }'

import os
import json
import requests
from jose import jwe

SECRET_KEY = os.getenv('MODULUS_SECRET_KEY')
ENCRYPTION_KEY = os.getenv('MODULUS_ENCRYPTION_KEY')

def create_qr():
    payload = {
        'activationCode': 'A9X4-B7P2-Q6Z8-M3L5',
        'currency': 'PHP',
        'amount': '500.00',
        'merchantReferenceNumber': f'TEST-{int(__import__("time").time())}'
    }

    jwe_token = jwe.encrypt(
        json.dumps(payload),
        ENCRYPTION_KEY,
        algorithm='A256KW',
        encryption='A256CBC-HS512'
    )

    response = requests.post(
        'https://qrph.sbx.moduluslabs.io/v1/pay/qr',
        json={'Token': jwe_token},
        auth=(SECRET_KEY, ''),
        headers={'Content-Type': 'application/json'}
    )

    decrypted = jwe.decrypt(response.json()['Token'], ENCRYPTION_KEY)
    result = json.loads(decrypted)

    print(f'Transaction ID: {result["id"]}')
    return result

create_qr()

<?php
require 'vendor/autoload.php';

use Jose\Component\Core\AlgorithmManager;
use Jose\Component\Core\JWK;
use Jose\Component\Encryption\Algorithm\KeyEncryption\A256KW;
use Jose\Component\Encryption\Algorithm\ContentEncryption\A256CBCHS512;
use Jose\Component\Encryption\Compression\CompressionMethodManager;
use Jose\Component\Encryption\JWEBuilder;
use Jose\Component\Encryption\Serializer\CompactSerializer;

$secretKey = getenv('MODULUS_SECRET_KEY');
$encryptionKey = getenv('MODULUS_ENCRYPTION_KEY');

$jwk = new JWK(['kty' => 'oct', 'k' => $encryptionKey]);

$payload = json_encode([
    'activationCode' => 'A9X4-B7P2-Q6Z8-M3L5',
    'currency' => 'PHP',
    'amount' => '500.00',
    'merchantReferenceNumber' => uniqid('TEST-', true)
]);

$jweBuilder = new JWEBuilder(
    new AlgorithmManager([new A256KW()]),
    new AlgorithmManager([new A256CBCHS512()]),
    new CompressionMethodManager()
);

$jwe = $jweBuilder->create()
    ->withPayload($payload)
    ->withSharedProtectedHeader(['alg' => 'A256KW', 'enc' => 'A256CBC-HS512'])
    ->addRecipient($jwk)
    ->build();

$token = (new CompactSerializer())->serialize($jwe, 0);

$ch = curl_init('https://qrph.sbx.moduluslabs.io/v1/pay/qr');
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(['Token' => $token]));
curl_setopt($ch, CURLOPT_USERPWD, $secretKey . ':');
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = json_decode(curl_exec($ch), true);
curl_close($ch);

echo "Response received\n";

package main

import (
	"bytes"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"

	"github.com/lestrrat-go/jwx/v2/jwa"
	"github.com/lestrrat-go/jwx/v2/jwe"
)

func main() {
	secretKey := os.Getenv("MODULUS_SECRET_KEY")
	encryptionKey := os.Getenv("MODULUS_ENCRYPTION_KEY")

	payload, _ := json.Marshal(map[string]string{
		"activationCode":          "A9X4-B7P2-Q6Z8-M3L5",
		"currency":                "PHP",
		"amount":                  "500.00",
		"merchantReferenceNumber": "TEST-001",
	})

	keyBytes, _ := base64.RawURLEncoding.DecodeString(encryptionKey)
	encrypted, _ := jwe.Encrypt(payload,
		jwe.WithKey(jwa.A256KW, keyBytes),
		jwe.WithContentEncryption(jwa.A256CBC_HS512),
	)

	reqBody, _ := json.Marshal(map[string]string{"Token": string(encrypted)})
	req, _ := http.NewRequest("POST", "https://qrph.sbx.moduluslabs.io/v1/pay/qr", bytes.NewBuffer(reqBody))
	req.SetBasicAuth(secretKey, "")
	req.Header.Set("Content-Type", "application/json")

	resp, _ := (&http.Client{}).Do(req)
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)

	var tokenResp map[string]string
	json.Unmarshal(body, &tokenResp)

	decrypted, _ := jwe.Decrypt([]byte(tokenResp["Token"]), jwe.WithKey(jwa.A256KW, keyBytes))

	var result map[string]string
	json.Unmarshal(decrypted, &result)
	fmt.Printf("Transaction ID: %s\n", result["id"])
}

import com.nimbusds.jose.*;
import com.nimbusds.jose.crypto.*;
import com.nimbusds.jose.jwk.OctetSequenceKey;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.net.URI;
import java.net.http.*;
import java.util.*;

public class CreateQRTest {
    public static void main(String[] args) throws Exception {
        String secretKey = System.getenv("MODULUS_SECRET_KEY");
        String encryptionKey = System.getenv("MODULUS_ENCRYPTION_KEY");
        ObjectMapper mapper = new ObjectMapper();

        Map<String, String> payload = Map.of(
            "activationCode", "A9X4-B7P2-Q6Z8-M3L5",
            "currency", "PHP",
            "amount", "500.00",
            "merchantReferenceNumber", "TEST-" + System.currentTimeMillis()
        );

        byte[] keyBytes = Base64.getUrlDecoder().decode(encryptionKey);
        OctetSequenceKey jwk = new OctetSequenceKey.Builder(keyBytes).build();

        JWEObject jwe = new JWEObject(
            new JWEHeader(JWEAlgorithm.A256KW, EncryptionMethod.A256CBC_HS512),
            new Payload(mapper.writeValueAsString(payload))
        );
        jwe.encrypt(new AESEncrypter(jwk));

        String auth = Base64.getEncoder().encodeToString((secretKey + ":").getBytes());
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://qrph.sbx.moduluslabs.io/v1/pay/qr"))
            .header("Authorization", "Basic " + auth)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(
                mapper.writeValueAsString(Map.of("Token", jwe.serialize()))
            ))
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());

        Map<String, String> respData = mapper.readValue(response.body(), Map.class);
        JWEObject respJwe = JWEObject.parse(respData.get("Token"));
        respJwe.decrypt(new AESDecrypter(jwk));

        Map<String, String> result = mapper.readValue(respJwe.getPayload().toString(), Map.class);
        System.out.println("Transaction ID: " + result.get("id"));
    }
}

using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using Jose;

var secretKey = Environment.GetEnvironmentVariable("MODULUS_SECRET_KEY");
var encryptionKey = Environment.GetEnvironmentVariable("MODULUS_ENCRYPTION_KEY");

static byte[] Base64UrlDecode(string base64Url)
{
    var base64 = base64Url.Replace('-', '+').Replace('_', '/');
    switch (base64.Length % 4)
    {
        case 2: base64 += "=="; break;
        case 3: base64 += "="; break;
    }
    return Convert.FromBase64String(base64);
}

var key = Base64UrlDecode(encryptionKey);

var payload = new
{
    activationCode = "A9X4-B7P2-Q6Z8-M3L5",
    currency = "PHP",
    amount = "500.00",
    merchantReferenceNumber = $"TEST-{DateTimeOffset.UtcNow.ToUnixTimeSeconds()}"
};

var jweToken = JWT.Encode(
    JsonSerializer.Serialize(payload), key,
    JweAlgorithm.A256KW, JweEncryption.A256CBC_HS512
);

using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Basic", Convert.ToBase64String(Encoding.ASCII.GetBytes($"{secretKey}:"))
);

var response = await client.PostAsync(
    "https://qrph.sbx.moduluslabs.io/v1/pay/qr",
    new StringContent(
        JsonSerializer.Serialize(new { Token = jweToken }),
        Encoding.UTF8, "application/json"
    )
);

var responseBody = await response.Content.ReadAsStringAsync();
var responseData = JsonSerializer.Deserialize<JsonElement>(responseBody);
var decryptedJson = JWT.Decode(responseData.GetProperty("Token").GetString(), key);
var result = JsonSerializer.Deserialize<JsonElement>(decryptedJson);

Console.WriteLine($"Transaction ID: {result.GetProperty("id")}");

Response (encrypted JWE token):

{
  "Token": "eyJhbGciOiJBMjU2S1ciLCJlbmMiOiJBMjU2Q0JDLUhTNTEyIn0..."
}

Decrypted payload:

{
  "id": "0ce32626-08cf-405c-adab-6d384a8871da",
  "qrBody": "iVBORw0KGgoAAAANSUhEUgAAASwAAAEsCAYAAAB5fY51AAAMTElEQVR4nO..."
}

Step 3: Convert Base64 to QR Image

The qrBody field contains a Base64-encoded PNG image. Convert it to an image file:

const fs = require('fs');

function saveQRImage(base64Data, filename = 'qr-code.png') {
  const buffer = Buffer.from(base64Data, 'base64');
  fs.writeFileSync(filename, buffer);
  console.log(`QR code saved to ${filename}`);
}

// Usage
const result = await createQR();
saveQRImage(result.qrBody, 'test-qr.png');

import base64

def save_qr_image(base64_data, filename='qr-code.png'):
    image_data = base64.b64decode(base64_data)
    with open(filename, 'wb') as f:
        f.write(image_data)
    print(f'QR code saved to {filename}')

# Usage
result = create_qr()
save_qr_image(result['qrBody'], 'test-qr.png')

# Save base64 data to a file first, then:
base64 -d qr-body.txt > qr-code.png

Online Converter (For Quick Testing)

Alternatively, use this online tool:

Visit https://base64.guru/converter/decode/image/png
Paste your Base64-encoded QR body
Click “Decode” to generate the image
Download the PNG file

Example QR Code:

Step 4: Decode the QR Image

Extract the raw QR value from the image:

Using Online Tool

Visit https://zxing.org/w/decode.jspx
Upload your QR code image
Click “Submit”
Copy the raw text value

Example raw QR value:

00020101021228820011ph.ppmi.p2m0111CUOBPHM2XXX03258eff02de-e172-4b0d-bc5b-3041288500100000905033015204601653036085407 1500.005802PH5912MAIN ACCOUNT6006MANILA63041943

Using Code

const fs = require('fs');
const { PNG } = require('pngjs');
const jsQR = require('jsqr');

function decodeQR(filename) {
  const data = fs.readFileSync(filename);
  const png = PNG.sync.read(data);

  const code = jsQR(
    Uint8ClampedArray.from(png.data),
    png.width,
    png.height
  );

  if (code) {
    console.log('QR Value:', code.data);
    return code.data;
  } else {
    throw new Error('Could not decode QR code');
  }
}

// Usage
const qrValue = decodeQR('test-qr.png');

from PIL import Image
from pyzbar.pyzbar import decode

def decode_qr(filename):
    img = Image.open(filename)
    decoded = decode(img)

    if decoded:
        qr_value = decoded[0].data.decode('utf-8')
        print('QR Value:', qr_value)
        return qr_value
    else:
        raise ValueError('Could not decode QR code')

# Usage
qr_value = decode_qr('test-qr.png')

Step 5: Simulate Payment

Now simulate a payment by calling the Simulate Webhook API:

const axios = require('axios');

async function simulatePayment(qrValue, useCase = 'SUCCESS') {
  const response = await axios.post(
    'https://qrph.sbx.moduluslabs.io/v1/webhooks/simulate',
    {
      qrBody: qrValue,
      useCase: useCase  // 'SUCCESS' or error code
    },
    {
      auth: { username: SECRET_KEY, password: '' },
      headers: { 'Content-Type': 'application/json' }
    }
  );

  console.log('Simulation triggered:', response.data);
  return response.data;
}

// Usage - Successful payment
await simulatePayment(qrValue, 'SUCCESS');

// Usage - Failed payment
await simulatePayment(qrValue, 'MISSING_PARTNER_REVENUE_ACCOUNT');

# Successful payment
curl -X POST https://qrph.sbx.moduluslabs.io/v1/webhooks/simulate \
  -u sk_YOUR_SECRET_KEY: \
  -H "Content-Type: application/json" \
  -d '{
    "qrBody": "00020101021228820011ph.ppmi.p2m0111CUOBPHM2XXX...",
    "useCase": "SUCCESS"
  }'

# Failed payment
curl -X POST https://qrph.sbx.moduluslabs.io/v1/webhooks/simulate \
  -u sk_YOUR_SECRET_KEY: \
  -H "Content-Type: application/json" \
  -d '{
    "qrBody": "00020101021228820011ph.ppmi.p2m0111CUOBPHM2XXX...",
    "useCase": "MISSING_PARTNER_REVENUE_ACCOUNT"
  }'

import requests

SECRET_KEY = 'sk_YOUR_SECRET_KEY'

def simulate_payment(qr_value, use_case='SUCCESS'):
    response = requests.post(
        'https://qrph.sbx.moduluslabs.io/v1/webhooks/simulate',
        json={'qrBody': qr_value, 'useCase': use_case},
        auth=(SECRET_KEY, ''),
        headers={'Content-Type': 'application/json'}
    )

    print(f'Simulation triggered: {response.json()}')
    return response.json()

simulate_payment(qr_value, 'SUCCESS')

<?php
$secretKey = 'sk_YOUR_SECRET_KEY';

$ch = curl_init('https://qrph.sbx.moduluslabs.io/v1/webhooks/simulate');
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'qrBody' => $qrValue,
    'useCase' => 'SUCCESS'
]));
curl_setopt($ch, CURLOPT_USERPWD, $secretKey . ':');
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

echo "Simulation triggered: $response\n";

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

func simulatePayment(secretKey, qrValue, useCase string) {
	body, _ := json.Marshal(map[string]string{
		"qrBody":  qrValue,
		"useCase": useCase,
	})

	req, _ := http.NewRequest("POST",
		"https://qrph.sbx.moduluslabs.io/v1/webhooks/simulate",
		bytes.NewBuffer(body))
	req.SetBasicAuth(secretKey, "")
	req.Header.Set("Content-Type", "application/json")

	resp, _ := (&http.Client{}).Do(req)
	defer resp.Body.Close()
	result, _ := io.ReadAll(resp.Body)

	fmt.Printf("Simulation triggered: %s\n", string(result))
}

import java.net.URI;
import java.net.http.*;
import java.util.Base64;

public class SimulatePayment {
    public static void main(String[] args) throws Exception {
        String secretKey = "sk_YOUR_SECRET_KEY";
        String auth = Base64.getEncoder().encodeToString((secretKey + ":").getBytes());

        String body = String.format(
            "{\"qrBody\":\"%s\",\"useCase\":\"SUCCESS\"}", qrValue
        );

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://qrph.sbx.moduluslabs.io/v1/webhooks/simulate"))
            .header("Authorization", "Basic " + auth)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println("Simulation triggered: " + response.body());
    }
}

using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;

var secretKey = "sk_YOUR_SECRET_KEY";

using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Basic", Convert.ToBase64String(Encoding.ASCII.GetBytes($"{secretKey}:"))
);

var response = await client.PostAsync(
    "https://qrph.sbx.moduluslabs.io/v1/webhooks/simulate",
    new StringContent(
        JsonSerializer.Serialize(new { qrBody = qrValue, useCase = "SUCCESS" }),
        Encoding.UTF8, "application/json"
    )
);

var result = await response.Content.ReadAsStringAsync();
Console.WriteLine($"Simulation triggered: {result}");

Step 6: Receive Webhook Notification

After simulating the payment, your webhook endpoint will receive a notification:

Successful Payment Webhook

{
  "event": "payment.succeeded",
  "transactionId": "0ce32626-08cf-405c-adab-6d384a8871da",
  "merchantReferenceNumber": "5e91bc6c-f7e2-4a39-ae0e-5e93985c94a4",
  "amount": "500.00",
  "currency": "PHP",
  "status": "succeeded",
  "completedAt": "2025-01-29T10:30:00Z"
}

Failed Payment Webhook

{
  "event": "payment.failed",
  "transactionId": "0ce32626-08cf-405c-adab-6d384a8871da",
  "merchantReferenceNumber": "5e91bc6c-f7e2-4a39-ae0e-5e93985c94a4",
  "amount": "500.00",
  "currency": "PHP",
  "status": "failed",
  "errorCode": "MISSING_PARTNER_REVENUE_ACCOUNT",
  "errorMessage": "Partner revenue account not found",
  "failedAt": "2025-01-29T10:30:00Z"
}

Test Scenarios

Test different scenarios to ensure your integration handles all cases:

Successful Payment

Use Case: SUCCESSExpected Result: Webhook receives payment.succeeded eventTest: Verify your app processes successful payments correctly

Missing Revenue Account

Use Case: MISSING_PARTNER_REVENUE_ACCOUNTExpected Result: Webhook receives payment.failed eventTest: Verify your app handles this specific error gracefully

Insufficient Funds

Use Case: INSUFFICIENT_FUNDSExpected Result: Webhook receives payment.failed eventTest: Ensure user is informed of insufficient funds

Invalid QR Code

Use Case: Use a malformed or expired QR valueExpected Result: API returns error before webhook is sentTest: Verify error handling for invalid QR codes

Duplicate Payment

Use Case: Reuse the same merchantReferenceNumberExpected Result: API rejects duplicate transactionTest: Ensure idempotency is working correctly

Timeout Scenario

Use Case: Delay webhook simulation by 30+ secondsExpected Result: Test timeout handling in your applicationTest: Verify your app doesn’t hang waiting for webhook

Complete Test Script

Here’s a complete end-to-end test script:

const axios = require('axios');
const jose = require('jose');
const fs = require('fs');

const SECRET_KEY = process.env.MODULUS_SECRET_KEY;
const ENCRYPTION_KEY = process.env.MODULUS_ENCRYPTION_KEY;

async function runFullTest() {
  console.log('🧪 Starting QR Ph Integration Test\n');

  try {
    // Step 1: Create QR Code
    console.log('📝 Step 1: Creating Dynamic QR Code...');
    const payload = {
      activationCode: 'A9X4-B7P2-Q6Z8-M3L5',
      currency: 'PHP',
      amount: '500.00',
      merchantReferenceNumber: `TEST-${Date.now()}`
    };

    const key = Buffer.from(ENCRYPTION_KEY, 'base64');
    const jweToken = await new jose.CompactEncrypt(
      new TextEncoder().encode(JSON.stringify(payload))
    )
      .setProtectedHeader({ alg: 'A256KW', enc: 'A256CBC-HS512' })
      .encrypt(key);

    const createResponse = await axios.post(
      'https://qrph.sbx.moduluslabs.io/v1/pay/qr',
      { Token: jweToken },
      {
        auth: { username: SECRET_KEY, password: '' },
        headers: { 'Content-Type': 'application/json' }
      }
    );

    const { plaintext } = await jose.compactDecrypt(createResponse.data.Token, key);
    const qrData = JSON.parse(new TextDecoder().decode(plaintext));
    console.log(` QR Created - ID: ${qrData.id}\n`);

    // Step 2: Save QR Image
    console.log(' Step 2: Saving QR Image...');
    const buffer = Buffer.from(qrData.qrBody, 'base64');
    fs.writeFileSync('test-qr.png', buffer);
    console.log(' QR saved to test-qr.png\n');

    // Step 3: Decode QR (manual step - using placeholder)
    console.log(' Step 3: Decode QR manually using:');
    console.log('   https://zxing.org/w/decode.jspx');
    console.log('   Upload: test-qr.png\n');

    // Step 4: Simulate Payment (after you get qrValue from decoding)
    console.log(' Step 4: Ready to simulate payment');
    console.log('   Run: simulatePayment(qrValue, "SUCCESS")');
    console.log('\n Test setup complete!');

    return qrData;

  } catch (error) {
    console.error(' Test failed:', error.message);
    if (error.response) {
      console.error('Response:', error.response.data);
    }
    throw error;
  }
}

// Run the test
runFullTest();

import os
import base64
import json
import time
import requests
from jose import jwe

SECRET_KEY = os.getenv('MODULUS_SECRET_KEY')
ENCRYPTION_KEY = os.getenv('MODULUS_ENCRYPTION_KEY')

def run_full_test():
    print('🧪 Starting QR Ph Integration Test\n')

    try:
        # Step 1: Create QR Code
        print('📝 Step 1: Creating Dynamic QR Code...')
        payload = {
            'activationCode': 'A9X4-B7P2-Q6Z8-M3L5',
            'currency': 'PHP',
            'amount': '500.00',
            'merchantReferenceNumber': f'TEST-{int(time.time())}'
        }

        jwe_token = jwe.encrypt(
            json.dumps(payload),
            ENCRYPTION_KEY,
            algorithm='A256KW',
            encryption='A256CBC-HS512'
        )

        response = requests.post(
            'https://qrph.sbx.moduluslabs.io/v1/pay/qr',
            json={'Token': jwe_token},
            auth=(SECRET_KEY, ''),
            headers={'Content-Type': 'application/json'}
        )

        decrypted = jwe.decrypt(response.json()['Token'], ENCRYPTION_KEY)
        qr_data = json.loads(decrypted)
        print(f" QR Created - ID: {qr_data['id']}\n")

        # Step 2: Save QR Image
        print(' Step 2: Saving QR Image...')
        image_data = base64.b64decode(qr_data['qrBody'])
        with open('test-qr.png', 'wb') as f:
            f.write(image_data)
        print(' QR saved to test-qr.png\n')

        # Step 3: Instructions
        print(' Step 3: Decode QR manually using:')
        print('   https://zxing.org/w/decode.jspx')
        print('   Upload: test-qr.png\n')

        print('⏳ Step 4: Ready to simulate payment')
        print('   Run: simulate_payment(qr_value, "SUCCESS")')
        print('\n Test setup complete!')

        return qr_data

    except Exception as e:
        print(f' Test failed: {str(e)}')
        raise

if __name__ == '__main__':
    run_full_test()

Debugging Tips

Enable Verbose Logging

Log all requests, responses, and encryption/decryption steps

Use Webhook.site

Test webhook delivery without setting up a server

Check Base64 Encoding

Ensure Base64 strings aren’t corrupted during copy/paste

Verify Credentials

Double-check you’re using sandbox credentials, not production

Test Incrementally

Test each step independently before running end-to-end

Monitor Webhook Logs

Check webhook server logs for incoming requests

Common Issues

QR Code Won't Decode

Ensure the image was saved correctly from Base64
Try a different QR decoder tool
Check if the image file is corrupted
Verify the Base64 string wasn’t truncated

Webhook Not Received

Verify webhook URL is publicly accessible
Check webhook registration was successful
Ensure firewall isn’t blocking incoming requests
Use webhook.site for initial testing

Simulation Returns Error

Verify the QR value was decoded correctly
Check that the transaction hasn’t been used already
Ensure proper authentication
Verify the useCase parameter is valid

Next Steps

Quickstart Guide

Complete integration guide with code examples

Create QR API

Full API reference for QR generation

Webhooks Documentation

Learn about webhook events and security

Go to Production

Steps to deploy your integration to production

QR API

Onboarding API

Terminal Gateway

Transaction Reporting API

Ecom API

Shared Resources

Overview

Prerequisites

Testing Workflow

Step 1: Register a Webhook

Step 2: Create a Dynamic QR Code

Step 3: Convert Base64 to QR Image

Online Converter (For Quick Testing)

Step 4: Decode the QR Image

Using Online Tool

Using Code

Step 5: Simulate Payment

Step 6: Receive Webhook Notification

Successful Payment Webhook

Failed Payment Webhook

Test Scenarios

Complete Test Script

Debugging Tips

Enable Verbose Logging

Use Webhook.site

Check Base64 Encoding

Verify Credentials

Test Incrementally

Monitor Webhook Logs

Common Issues

Next Steps

Quickstart Guide

Create QR API

Webhooks Documentation

Go to Production

​Overview

​Prerequisites

​Testing Workflow

​Step 1: Register a Webhook

​Step 2: Create a Dynamic QR Code

​Step 3: Convert Base64 to QR Image

​Online Converter (For Quick Testing)

​Step 4: Decode the QR Image

​Using Online Tool

​Using Code

​Step 5: Simulate Payment

​Step 6: Receive Webhook Notification

​Successful Payment Webhook

​Failed Payment Webhook

​Test Scenarios

​Complete Test Script

​Debugging Tips

Enable Verbose Logging

Use Webhook.site

Check Base64 Encoding

Verify Credentials

Test Incrementally

Monitor Webhook Logs

​Common Issues

​Next Steps

Quickstart Guide

Create QR API

Webhooks Documentation

Go to Production

Overview

Prerequisites

Testing Workflow

Step 1: Register a Webhook

Step 2: Create a Dynamic QR Code

Step 3: Convert Base64 to QR Image

Online Converter (For Quick Testing)

Step 4: Decode the QR Image

Using Online Tool

Using Code

Step 5: Simulate Payment

Step 6: Receive Webhook Notification

Successful Payment Webhook

Failed Payment Webhook

Test Scenarios

Complete Test Script

Debugging Tips

Common Issues

Next Steps