PSP #1 Adapter -- PassimPay

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

public static class PassimPaySignature
{
    /// Sign a PassimPay API request.
    /// Contract: HMAC-SHA256( platformId + ";" + jsonBody + ";" + secret, secret )
    /// IMPORTANT: PassimPay expects escaped forward slashes (\/).
    public static string SignRequest(int platformId, object body, string secret)
    {
        var jsonBody = JsonSerializer.Serialize(body).Replace("/", "\/");
        var contract = $"{platformId};{jsonBody};{secret}";
        using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(secret));
        var hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(contract));
        return Convert.ToHexString(hash).ToLower();
    }

    /// Verify an incoming PassimPay webhook.
    /// Same contract -- compare computed signature with x-signature header.
    public static bool VerifyWebhook(
        int platformId,
        string rawBody,       // raw unparsed request body string
        string secret,
        string receivedSignature)
    {
        var contract = $"{platformId};{rawBody};{secret}";
        using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(secret));
        var expected = Convert.ToHexString(hmac.ComputeHash(Encoding.UTF8.GetBytes(contract))).ToLower();
        return CryptographicOperations.FixedTimeEquals(
            Convert.FromHexString(expected),
            Convert.FromHexString(receivedSignature)
        );
    }
}

[ApiController]
[Route("webhooks")]
public class PassimPayWebhookController : ControllerBase
{
    private readonly IWebhookEventRepository _events;
    private readonly IPaymentQueue _queue;

    public PassimPayWebhookController(
        IWebhookEventRepository events,
        IPaymentQueue queue)
    {
        _events = events;
        _queue = queue;
    }

    // IMPORTANT: read raw body BEFORE any middleware deserializes it.
    // Do NOT use [FromBody] -- that would parse the body and break signature verification.
    [HttpPost("passimpay")]
    public async Task<IActionResult> HandleWebhook()
    {
        // Step 1 -- read raw body (required for signature verification)
        using var reader = new StreamReader(Request.Body, Encoding.UTF8);
        var rawBody = await reader.ReadToEndAsync();

        var signature = Request.Headers["x-signature"].ToString();
        var platformId = int.Parse(Environment.GetEnvironmentVariable("PASSIMPAY_PLATFORM_ID")!);
        var secret = Environment.GetEnvironmentVariable("PASSIMPAY_API_SECRET")!;

        // Step 2 -- verify signature
        if (!PassimPaySignature.VerifyWebhook(platformId, rawBody, secret, signature))
            return BadRequest(new { error = "INVALID_SIGNATURE" });

        // Step 3 -- parse body
        var payload = JsonSerializer.Deserialize<JsonElement>(rawBody);

        // Step 4 -- idempotency check (orderId or transactionId)
        var idempotencyKey =
            payload.TryGetProperty("orderId", out var orderId) ? orderId.GetString() :
            payload.GetProperty("transactionId").GetString();

        if (await _events.ExistsAsync(idempotencyKey!))
            return Ok(new { ok = true }); // return 200 to stop PSP retries

        // Step 5 -- enqueue for orchestrator (do NOT process inline)
        await _queue.PushAsync(new PassimPayWebhookMessage { RawBody = rawBody });

        // Step 6 -- respond 200 immediately
        // PassimPay retries up to 2 times if 200 is not returned promptly.
        return Ok(new { ok = true });
    }
}