Webhooks

    import json
    import hmac
    import hashlib
    import base64
    import logging

    logging.basicConfig(level=logging.INFO, format="%(message)s")

    def hooks_cron2():
        try:
            payload = """
            {
            "event_type": "payment_success",
            "requestId": "45f2dc2d-d559-4773-bba3-2XXXXXXXXXX",
            "data": {
                "merchant": {
                "walletId": "6756ff80aafe04a795f18b3XXXXXXXXXX",
                "walletBalance": 6052,
                "userId": "b7b10e81-e57d-41d0-8XXXXXXXXXX"
                },
                "terminal": {},
                "transaction": {
                "aliasAccountNumber": "5343270516",
                "fee": 5,
                "sessionId": "IFAP-TRANSFER-46501-e0339485-1a2f-4b43-9bXXXXXXXXXX",
                "type": "vact_transfer",
                "transactionId": "API-VACT_TRA-B7B10-0435b274-807a-4bc7-8abe-9dbXXXXXXXXXX",
                "aliasAccountName": "SAMPLE/JOHN DOE",
                "responseCode": "",
                "originatingFrom": "api",
                "transactionAmount": 10,
                "narration": "John Doe Transfer 10.00 To ZAXBOX/EZENNA NWACHUKWU - Nomba",
                "time": "2025-09-29T10:51:44Z",
                "aliasAccountReference": "654f7c80bd4**10c90fb7f92",
                "aliasAccountType": "VIRTUAL"
                },
                "customer": {
                "bankCode": "090645",
                "senderName": "John Doe",
                "bankName": "Nombank",
                "accountNumber": "0000000000"
                }
            }
            }
            """

            signature_value = "Kt9095hQxfgmVbx6iz7G2tPhHdbdXgLlyY/mf35sptw="
            nomba_timestamp = "2025-09-29T10:51:44Z"
            secret = "sampleScret"

            my_sig = generate_signature(payload, secret, nomba_timestamp)

            logging.info(f"Generated signature [{my_sig}]")
            logging.info(f"Expected signature [{signature_value}]")

            if signature_value.lower() == my_sig.lower():
                logging.info(">>>>>>> Signatures match <<<<<<<<<")
            else:
                logging.info("<<<<<<<<< Signatures did not match >>>>>>>>>")

        except Exception as ex:
            logging.error(f"Error occurred while generating signature: {ex}")

    def generate_signature(payload: str, secret: str, timestamp: str) -> str:
        request_payload = json.loads(payload)

        data = request_payload.get("data", {})
        merchant = data.get("merchant", {})
        transaction = data.get("transaction", {})

        event_type = request_payload.get("event_type", "")
        request_id = request_payload.get("requestId", "")
        user_id = merchant.get("userId", "")
        wallet_id = merchant.get("walletId", "")
        transaction_id = transaction.get("transactionId", "")
        transaction_type = transaction.get("type", "")
        transaction_time = transaction.get("time", "")
        transaction_response_code = transaction.get("responseCode", "")

        if transaction_response_code == "null":
            transaction_response_code = ""

        # Construct the same hashing payload as in Java/Go
        hashing_payload = f"{event_type}:{request_id}:{user_id}:{wallet_id}:{transaction_id}:{transaction_type}:{transaction_time}:{transaction_response_code}:{timestamp}"

        logging.info(f"::: payload to hash --> [{hashing_payload}] :::")

        # Compute HMAC-SHA256 and Base64 encode it
        digest = hmac.new(secret.encode(), hashing_payload.encode(), hashlib.sha256).digest()
        signature = base64.b64encode(digest).decode()

        return signature

    if __name__ == "__main__":
        hooks_cron2()

    import crypto from "crypto";

    async function hooksCron2() {
    try {
        const payload = `
        {
        "event_type": "payment_success",
        "requestId": "45f2dc2d-d559-4773-bba3-2XXXXXXXXXX",
        "data": {
            "merchant": {
            "walletId": "6756ff80aafe04XXXXXXXXXX",
            "walletBalance": 6052,
            "userId": "b7b10e81-**-**-**-f4e23a132bbf"
            },
            "terminal": {},
            "transaction": {
            "aliasAccountNumber": "5343270516",
            "fee": 5,
            "sessionId": "IFAP-TRANSFER-46501-e0339485-1a2f-4b43-9bd5-XXXXXXXXXX",
            "type": "vact_transfer",
            "transactionId": "API-VACT_TRA-B7B10-0435b274-807a-4bc7-8abe-9XXXXXXXXXX",
            "aliasAccountName": "SAMPLE/JOHN DOE",
            "responseCode": "",
            "originatingFrom": "api",
            "transactionAmount": 10,
            "narration": "John Does Transfer 10.00 To SAMPLE/JOHN DOE - Nomba",
            "time": "2025-09-29T10:51:44Z",
            "aliasAccountReference": "sampleAccountReference",
            "aliasAccountType": "VIRTUAL"
            },
            "customer": {
            "bankCode": "090645",
            "senderName": "John Does",
            "bankName": "Nombank",
            "accountNumber": "0000000000"
            }
        }
        }`;

        const signatureValue = "Kt9095hQxfgmVbx6iz7G2tPhHdbdXgLlyY/mf35sptw=";
        const nombaTimeStamp = "2025-09-29T10:51:44Z";
        const secret = "sampleSecret";

        const mySig = generateSignature(payload, secret, nombaTimeStamp);

        console.log(`Generated signature [${mySig}]`);
        console.log(`Expected signature [${signatureValue}]`);

        if (signatureValue.toLowerCase() === mySig.toLowerCase()) {
        console.log(">>>>>>> Signatures match <<<<<<<<<<<");
        } else {
        console.log("<<<<<<<<< Signatures did not match >>>>>>>>>");
        }
    } catch (ex) {
        console.error("Error occurred while generating signature:", ex.message);
    }
    }

    function generateSignature(payload, secret, timeStamp) {
    const requestPayload = JSON.parse(payload);
    const data = requestPayload.data || {};
    const merchant = data.merchant || {};
    const transaction = data.transaction || {};

    const eventType = requestPayload.event_type || "";
    const requestId = requestPayload.requestId || "";
    const userId = merchant.userId || "";
    const walletId = merchant.walletId || "";
    const transactionId = transaction.transactionId || "";
    const transactionType = transaction.type || "";
    const transactionTime = transaction.time || "";
    let transactionResponseCode = transaction.responseCode || "";

    if (transactionResponseCode === "null") {
        transactionResponseCode = "";
    }


    const hashingPayload = `${eventType}:${requestId}:${userId}:${walletId}:${transactionId}:${transactionType}:${transactionTime}:${transactionResponseCode}:${timeStamp}`;

    console.log(`::: payload to hash --> [${hashingPayload}] :::`);

    const hmac = crypto.createHmac("sha256", secret);
    hmac.update(hashingPayload);
    const hash = hmac.digest("base64");

    return hash;
    }

    // Run
    hooksCron2();

import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

@Slf4j
public class NombaHooksRefactored {

    private static final ObjectMapper objectMapper = new ObjectMapper();

    public static void main(String[] args) throws Exception {
        new NombaHooksRefactored().hooksCron2();
    }

    public void hooksCron2() {
        try {
            String payload = """
                {
                "event_type": "payment_success",
                "requestId": "45f2dc2d-d559-4773-bba3-2XXXXXXXXXX",
                "data": {
                    "merchant": {
                    "walletId": "6756ff80aafe04aXXXXXXXXXX",
                    "walletBalance": 6052,
                    "userId": "b7b10e81-**-**-**-f4e23a132bbf"
                    },
                    "terminal": {},
                    "transaction": {
                    "aliasAccountNumber": "5343270516",
                    "fee": 5,
                    "sessionId": "IFAP-TRANSFER-46501-***-1a2f-4b43-9bd5-fec964XXXXXXXXXX28",
                    "type": "vact_transfer",
                    "transactionId": "API-VACT_TRA-B7B10-0435b274-807a-4bc7-8XXXXXXXXXX",
                    "aliasAccountName": "SAMPLE/JOHN DOE",
                    "responseCode": "",
                    "originatingFrom": "api",
                    "transactionAmount": 10,
                    "narration": "John Doe Transfer 10.00 To ZAXBOX/EZENNA NWACHUKWU - Nomba",
                    "time": "2025-09-29T10:51:44Z",
                    "aliasAccountReference": "654f7c80bd4***0c90fb7f92",
                    "aliasAccountType": "VIRTUAL"
                    },
                    "customer": {
                    "bankCode": "090645",
                    "senderName": "John Doe",
                    "bankName": "Nombank",
                    "accountNumber": "0000000000"
                    }
                }
                }
                """;

            String signatureValue = "Kt9095hQxfgmVbx6iz7G2tPhHdbdXgLlyY/mf35sptw=";
            String nombaTimeStamp = "2025-09-29T10:51:44Z";
            String secret = "HkatexKDZg7CLWy96q5sfrVHSvtXXXXXXXXXXB";

            HookPayload hookPayload = objectMapper.readValue(payload, HookPayload.class);

            String mySig = generateSignature(hookPayload, secret, nombaTimeStamp);

            log.info("Generated signature [{}]", mySig);
            log.info("Expected signature [{}]", signatureValue);

            if (signatureValue.equalsIgnoreCase(mySig)) {
                log.info(">>>>>>> Signatures match <<<<<<<<<");
            } else {
                log.info("<<<<<<<<< Signatures did not match >>>>>>>>>");
            }

        } catch (Exception ex) {
            log.error("Error occurred while generating signature. Error message [{}]", ex.getMessage(), ex);
        }
    }

    public String generateSignature(HookPayload payload, String secret, String timeStamp) throws Exception {
        var data = payload.getData();
        var merchant = data.getMerchant();
        var transaction = data.getTransaction();

        String eventType = safe(payload.getEventType());
        String requestId = safe(payload.getRequestId());
        String userId = safe(merchant.getUserId());
        String walletId = safe(merchant.getWalletId());
        String transactionId = safe(transaction.getTransactionId());
        String transactionType = safe(transaction.getType());
        String transactionTime = safe(transaction.getTime());
        String transactionResponseCode = safe(transaction.getResponseCode());

        if ("null".equalsIgnoreCase(transactionResponseCode)) {
            transactionResponseCode = "";
        }

        String hashingPayload = String.format(
                "%s:%s:%s:%s:%s:%s:%s:%s:%s",
                eventType, requestId, userId, walletId,
                transactionId, transactionType, transactionTime,
                transactionResponseCode, timeStamp
        );

        log.info("::: payload to hash --> [{}] :::", hashingPayload);

        Mac sha256HMAC = Mac.getInstance("HmacSHA256");
        SecretKeySpec secretKey = new SecretKeySpec(secret.getBytes(), "HmacSHA256");
        sha256HMAC.init(secretKey);

        byte[] hash = sha256HMAC.doFinal(hashingPayload.getBytes());
        return Base64.getEncoder().encodeToString(hash);
    }

    private String safe(String value) {
        return value == null ? "" : value;
    }
}

// POJO Models (Strongly Typed Payload Classes)

import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;

@Data
public class HookPayload {
    @JsonProperty("event_type")
    private String eventType;

    @JsonProperty("requestId")
    private String requestId;

    @JsonProperty("data")
    private HookData data;
}

@Data
class HookData {
    private Merchant merchant;
    private Transaction transaction;
    private Customer customer;
    private Object terminal;
}

@Data
class Merchant {
    private String walletId;
    private Double walletBalance;
    private String userId;
}

@Data
class Transaction {
    private String transactionId;
    private String type;
    private String time;
    private String responseCode;
}

@Data
class Customer {
    private String bankCode;
    private String senderName;
    private String bankName;
    private String accountNumber;
}

    using System;
    using System.Text;
    using System.Text.Json;
    using System.Text.Json.Serialization;
    using System.Security.Cryptography;

    public class HooksCron
    {
        public static void Main()
        {
            try
            {
                var payload = @"
                {
                ""event_type"": ""payment_success"",
                ""requestId"": ""45f2dc2d-d559-4773-bba3-2XXXXXXXXXX"",
                ""data"": {
                    ""merchant"": {
                    ""walletId"": ""6756ff80aafe04a7XXXXXXXXXX"",
                    ""walletBalance"": 6052,
                    ""userId"": ""b7b10e81-e57d-41d0-8fdc-f4XXXXXXXXXX""
                    },
                    ""terminal"": {},
                    ""transaction"": {
                    ""aliasAccountNumber"": ""5343270516"",
                    ""fee"": 5,
                    ""sessionId"": ""IFAP-TRANSFER-46501-e0339485-1a2f-4b43-9bd5-feXXXXXXXXXX28"",
                    ""type"": ""vact_transfer"",
                    ""transactionId"": ""API-VACT_TRA-B7B10-0435b274-807a-4bc7-8abe-XXXXXXXXXXd7a"",
                    ""aliasAccountName"": ""ZAXBOX/EZENNA NWACHUKWU"",
                    ""responseCode"": """",
                    ""originatingFrom"": ""api"",
                    ""transactionAmount"": 10,
                    ""narration"": ""Habiblahi Hamzat Transfer 10.00 To ZAXBOX/EZENNA NWACHUKWU - Nomba"",
                    ""time"": ""2025-09-29T10:51:44Z"",
                    ""aliasAccountReference"": ""654XXXXXXXXXX92"",
                    ""aliasAccountType"": ""VIRTUAL""
                    },
                    ""customer"": {
                    ""bankCode"": ""090645"",
                    ""senderName"": ""Habiblahi Hamzat"",
                    ""bankName"": ""Nombank"",
                    ""accountNumber"": ""9617811496""
                    }
                }
                }";

                var signatureValue = "Kt9095hQxfgmVbx6iz7G2tPhHdbdXgLlyY/mf35sptw=";
                var nombaTimestamp = "2025-09-29T10:51:44Z";
                var secret = "HkatexKDZg7CLWy96q5sfrVH92B";

                // Deserialize payload into object model
                var requestPayload = JsonSerializer.Deserialize<HookPayload>(payload);

                var mySig = GenerateSignature(requestPayload, secret, nombaTimestamp);

                Console.WriteLine($"Generated signature [{mySig}]");
                Console.WriteLine($"Expected signature [{signatureValue}]");

                if (string.Equals(signatureValue, mySig, StringComparison.OrdinalIgnoreCase))
                {
                    Console.WriteLine(">>>>>>> Signatures match <<<<<<<<<");
                }
                else
                {
                    Console.WriteLine("<<<<<<<<< Signatures did not match >>>>>>>>>");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error occurred while generating signature. Error: {ex.Message}");
            }
        }

        public static string GenerateSignature(HookPayload payload, string secret, string timestamp)
        {
            var data = payload.Data;
            var merchant = data.Merchant;
            var transaction = data.Transaction;

            string eventType = payload.EventType ?? "";
            string requestId = payload.RequestId ?? "";
            string userId = merchant?.UserId ?? "";
            string walletId = merchant?.WalletId ?? "";
            string transactionId = transaction?.TransactionId ?? "";
            string transactionType = transaction?.Type ?? "";
            string transactionTime = transaction?.Time ?? "";
            string transactionResponseCode = transaction?.ResponseCode ?? "";

            if (transactionResponseCode == "null")
            {
                transactionResponseCode = "";
            }

            var hashingPayload = $"{eventType}:{requestId}:{userId}:{walletId}:{transactionId}:{transactionType}:{transactionTime}:{transactionResponseCode}:{timestamp}";
            Console.WriteLine($"::: payload to hash --> [{hashingPayload}] :::");

            using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(secret));
            var hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(hashingPayload));
            var signature = Convert.ToBase64String(hash);

            return signature;
        }
    }

    #region Models

    public class HookPayload
    {
        [JsonPropertyName("event_type")]
        public string? EventType { get; set; }

        [JsonPropertyName("requestId")]
        public string? RequestId { get; set; }

        [JsonPropertyName("data")]
        public HookData Data { get; set; } = new();
    }

    public class HookData
    {
        [JsonPropertyName("merchant")]
        public Merchant? Merchant { get; set; }

        [JsonPropertyName("transaction")]
        public Transaction? Transaction { get; set; }

        [JsonPropertyName("customer")]
        public Customer? Customer { get; set; }

        [JsonPropertyName("terminal")]
        public object? Terminal { get; set; }
    }

    public class Merchant
    {
        [JsonPropertyName("walletId")]
        public string? WalletId { get; set; }

        [JsonPropertyName("walletBalance")]
        public decimal? WalletBalance { get; set; }

        [JsonPropertyName("userId")]
        public string? UserId { get; set; }
    }

    public class Transaction
    {
        [JsonPropertyName("transactionId")]
        public string? TransactionId { get; set; }

        [JsonPropertyName("type")]
        public string? Type { get; set; }

        [JsonPropertyName("time")]
        public string? Time { get; set; }

        [JsonPropertyName("responseCode")]
        public string? ResponseCode { get; set; }
    }

    public class Customer
    {
        [JsonPropertyName("bankCode")]
        public string? BankCode { get; set; }

        [JsonPropertyName("senderName")]
        public string? SenderName { get; set; }

        [JsonPropertyName("bankName")]
        public string? BankName { get; set; }

        [JsonPropertyName("accountNumber")]
        public string? AccountNumber { get; set; }
    }

    #endregion     

    <?php

    function hooksCron2() {
        try {
            $payload = <<<JSON
            {
            "event_type": "payment_success",
            "requestId": "45f2dc2d-d559-4773-bba3-2XXXXXXXXXX",
            "data": {
                "merchant": {
                "walletId": "6756ff80aafe04a7XXXXXXXXXX",
                "walletBalance": 6052,
                "userId": "b7b10e81-***-41d0-***-f4e23a132bbf"
                },
                "terminal": {},
                "transaction": {
                "aliasAccountNumber": "5343270516",
                "fee": 5,
                "sessionId": "IFAP-TRANSFER-46501-e0339485-1a2f-4b43-9bd5-XXXXXXXXXX8",
                "type": "vact_transfer",
                "transactionId": "API-VACT_TRA-B7B10-0435b274-807a-4bc7-8abe-XXXXXXXXXX",
                "aliasAccountName": "SAMPLE/JOHN DOE",
                "responseCode": "",
                "originatingFrom": "api",
                "transactionAmount": 10,
                "narration": "Joh Doe Transfer 10.00 To SAMPLE/JOHN DOE - Nomba",
                "time": "2025-09-29T10:51:44Z",
                "aliasAccountReference": "654f7c80b****510c90f***2",
                "aliasAccountType": "VIRTUAL"
                },
                "customer": {
                "bankCode": "090645",
                "senderName": "John Doe",
                "bankName": "Nombank",
                "accountNumber": "0000000000"
                }
            }
            }
            JSON;

            $signatureValue = "Kt9095hQxfgmVbx6iz7G2tPhHdbdXgLlyY/mf35sptw=";
            $nombaTimeStamp = "2025-09-29T10:51:44Z";
            $secret = "SampleSecret";

            $mySig = generateSignature($payload, $secret, $nombaTimeStamp);

            echo "Generated signature [{$mySig}]\n";
            echo "Expected signature [{$signatureValue}]\n";

            if (strcasecmp($signatureValue, $mySig) === 0) {
                echo ">>>>>>> Signatures match <<<<<<<<<\n";
            } else {
                echo "<<<<<<<<< Signatures did not match >>>>>>>>>\n";
            }
        } catch (Exception $ex) {
            echo "Error occurred while generating signature: {$ex->getMessage()}\n";
        }
    }

    function generateSignature($payload, $secret, $timeStamp) {
        $requestPayload = json_decode($payload, true);

        $data = $requestPayload['data'] ?? [];
        $merchant = $data['merchant'] ?? [];
        $transaction = $data['transaction'] ?? [];

        $eventType = $requestPayload['event_type'] ?? '';
        $requestId = $requestPayload['requestId'] ?? '';
        $userId = $merchant['userId'] ?? '';
        $walletId = $merchant['walletId'] ?? '';
        $transactionId = $transaction['transactionId'] ?? '';
        $transactionType = $transaction['type'] ?? '';
        $transactionTime = $transaction['time'] ?? '';
        $transactionResponseCode = $transaction['responseCode'] ?? '';

        if ($transactionResponseCode === "null") {
            $transactionResponseCode = '';
        }

        // Construct payload string same as Java's String.format(SIG_FORMAT, data, timeStamp)
        $hashingPayload = sprintf(
            "%s:%s:%s:%s:%s:%s:%s:%s:%s",
            $eventType,
            $requestId,
            $userId,
            $walletId,
            $transactionId,
            $transactionType,
            $transactionTime,
            $transactionResponseCode,
            $timeStamp
        );

        echo "::: payload to hash --> [{$hashingPayload}] :::\n";

        // Generate HMAC SHA256 and encode in Base64
        $hash = hash_hmac('sha256', $hashingPayload, $secret, true);
        return base64_encode($hash);
    }

    // Run
    hooksCron2();