{
  "checksum":      "f3a91c0be2d5477a815c6e0d9b23f4a6c8d17e5290bb34cd6f01a8e7d4529c1b",
  "encryptedBody": "Kx92LmT7Qw3vNpB1cYdE8fGhJa5sRzUoW0iVtM6nXqPeC4bDlZ2wHj8kAg7yEmSf…"
}

{
  "responseTimestamp": "2026-08-19T10:12:44.318Z",
  "code": 200,
  "result": "SUCCESS",
  "description": "Transaction Initiated successfully!",
  "encryptedResponse": "Vb84KpXw2mRtYqLu0ZnHs6EjcOgD5aTfM1iNvB7yPzQxWkC3eJdSrhUoA9lG…"
}

import hashlib

def system_checksum(data: str) -> str:
    return hashlib.sha256(data.encode("utf-8")).hexdigest()

import java.security.MessageDigest;

public static String systemChecksum(String data) throws Exception {
    MessageDigest md = MessageDigest.getInstance("SHA-256");
    byte[] hash = md.digest(data.getBytes("UTF-8"));
    StringBuilder hex = new StringBuilder();
    for (byte b : hash) hex.append(String.format("%02x", b));
    return hex.toString();
}

const crypto = require("crypto");

function systemChecksum(data) {
  return crypto.createHash("sha256").update(data, "utf8").digest("hex");
}

function systemChecksum(string $data): string {
    return hash("sha256", $data);
}

import hashlib, base64
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad

IV = b"1234567890123456"

def derive_key(key: str) -> bytes:
    return hashlib.sha256(key.encode()).hexdigest()[:32].encode()

def system_encryption(plain_text: str, key: str) -> str:
    cipher = AES.new(derive_key(key), AES.MODE_CBC, IV)
    encrypted = cipher.encrypt(pad(plain_text.encode("utf-8"), AES.block_size))
    return base64.b64encode(encrypted).decode()

def system_decryption(cipher_text: str, key: str) -> str:
    cipher = AES.new(derive_key(key), AES.MODE_CBC, IV)
    decrypted = unpad(cipher.decrypt(base64.b64decode(cipher_text)), AES.block_size)
    return decrypted.decode("utf-8")

import java.security.MessageDigest;
import java.util.Base64;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

public class SystemEncryption {
    private static final String IV = "1234567890123456";

    private static byte[] deriveKey(String key) throws Exception {
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        byte[] hash = md.digest(key.getBytes("UTF-8"));
        StringBuilder hex = new StringBuilder();
        for (byte b : hash) hex.append(String.format("%02x", b));
        return hex.substring(0, 32).getBytes("UTF-8");
    }

    public static String encrypt(String plainText, String key) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(deriveKey(key), "AES"),
                    new IvParameterSpec(IV.getBytes("UTF-8")));
        return Base64.getEncoder().encodeToString(cipher.doFinal(plainText.getBytes("UTF-8")));
    }

    public static String decrypt(String cipherText, String key) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(deriveKey(key), "AES"),
                    new IvParameterSpec(IV.getBytes("UTF-8")));
        return new String(cipher.doFinal(Base64.getDecoder().decode(cipherText)), "UTF-8");
    }
}

const crypto = require("crypto");
const IV = Buffer.from("1234567890123456", "utf8");

function deriveKey(key) {
  return Buffer.from(crypto.createHash("sha256").update(key).digest("hex").slice(0, 32), "utf8");
}
function systemEncryption(plainText, key) {
  const c = crypto.createCipheriv("aes-256-cbc", deriveKey(key), IV);
  return Buffer.concat([c.update(plainText, "utf8"), c.final()]).toString("base64");
}
function systemDecryption(cipherText, key) {
  const d = crypto.createDecipheriv("aes-256-cbc", deriveKey(key), IV);
  return Buffer.concat([d.update(Buffer.from(cipherText, "base64")), d.final()]).toString("utf8");
}

const IV = "1234567890123456";

function deriveKey(string $key): string {
    return substr(hash("sha256", $key), 0, 32);
}
function systemEncryption(string $plain, string $key): string {
    return base64_encode(openssl_encrypt($plain, "aes-256-cbc", deriveKey($key), OPENSSL_RAW_DATA, IV));
}
function systemDecryption(string $cipher, string $key): string {
    return openssl_decrypt(base64_decode($cipher), "aes-256-cbc", deriveKey($key), OPENSSL_RAW_DATA, IV);
}

{
  "timestamp": "2026-08-19T10:12:45.062Z",
  "statusCode": 200, "status": "OK", "success": true,
  "message": "Decrypted Successfully!",
  "data": {
    "merchantorderId": "ORD2026INV45210",
    "gatewayTxnId": "TXNCF2026081900457",
    "txnAmount": 350.50,
    "intentUrl": "upi://pay?pa=collect@cfpay&pn=CASHFLOW%20TECH%20PRIVATE%20LIMITED&am=350.50&cu=INR&tr=TXNCF2026081900457",
    "txnStatus": "INITIATED"
  }
}

{
  "merchantOrderId": "ORD2026INV45210",
  "gatewayTxnId": "TXNCF2026081900457",
  "txnAmount": 350.50,
  "currency": "INR",
  "txnStatus": "SUCCESS",
  "paymentMethod": "UPI",
  "updatedAt": "2026-08-19T10:14:03.521Z",
  "rrn": "615508923471",
  "customerVpa": "rahulm@okaxis"
}

{ "accepted": true, "message": "Transaction Decrypted Successfully" }

{
  "merchantOrderId": "PYT2026TRF88431",
  "gatewayTxnId": "TXNCF2026081900982",
  "txnAmount": 5000.00,
  "currency": "INR",
  "txnStatus": "INITIATED",
  "paymentMethod": "IMPS",
  "updatedAt": "2026-08-19T11:02:36.144Z",
  "message": "Request accepted successfully"
}

{
  "merchantOrderId": "PYT2026TRF88431",
  "gatewayTxnId": "TXNCF2026081900982",
  "txnAmount": 5000.00,
  "currency": "INR",
  "txnStatus": "SUCCESS",
  "paymentMethod": "IMPS",
  "updatedAt": "2026-08-19T11:04:52.208Z",
  "rrn": "618224905137",
  "message": ""
}

{
  "merchantOrderId": "PYT2026TRF88431",
  "gatewayTxnId": "TXNCF2026081900982",
  "txnAmount": 5000.00,
  "currency": "INR",
  "txnStatus": "SUCCESS",
  "paymentMethod": "IMPS",
  "updatedAt": "2026-08-19T11:04:52.208Z",
  "rrn": "618224905137",
  "message": ""
}