.NET SDK (C#)

Official PonponPay SDK for .NET. Compatible with .NET 6+ and works with ASP.NET Core, Blazor, and other frameworks.

Installation

dotnet add package PonponPay.SDK

Basic Usage

Initialize Client

using PonponPay.SDK;

var client = new PonponPayClient(new PonponPayConfig
{
    ApiKey = Environment.GetEnvironmentVariable("PONPONPAY_API_KEY"),
    // Optional configurations
    BaseUrl = "https://api.ponponpay.com/api/v1/pay/sdk",
    Timeout = TimeSpan.FromSeconds(30)
});

Create Order

var order = await client.CreateOrderAsync(new CreateOrderRequest
{
    Currency = "USDT",
    Network = "tron",
    Amount = 100.00m,
    MchOrderId = "ORDER_123456",  // Optional
    NotifyUrl = "https://your-site.com/webhook",
    RedirectUrl = "https://your-site.com/success"
});

Console.WriteLine(order.TradeId);      // PonponPay transaction ID
Console.WriteLine(order.PaymentUrl);   // Redirect user to this URL
Console.WriteLine(order.Address);      // Receiving wallet address
Console.WriteLine(order.ActualAmount); // Actual payment amount

Query Order

// Query by PonponPay trade ID
var order = await client.QueryOrderAsync("PP202412110001");

// Query by your merchant order ID
var order = await client.QueryOrderByMchIdAsync("ORDER_123456");

Console.WriteLine(order.Status);  // "pending", "paid", "expired", "cancelled"
Console.WriteLine(order.TxHash);  // Blockchain transaction hash (if paid)

Cancel Order

// Cancel by trade ID
await client.CancelOrderAsync("PP202412110001");

// Cancel by merchant order ID
await client.CancelOrderByMchIdAsync("ORDER_123456");

Get Payment Methods

var methods = await client.GetPaymentMethodsAsync();

foreach (var method in methods)
{
    Console.WriteLine($"{method.Currency} on {method.Network}");
}

Webhook Verification

// In your webhook endpoint
[HttpPost("webhook")]
public async Task<IActionResult> Webhook()
{
    var signature = Request.Headers["X-PonponPay-Signature"].FirstOrDefault();
    using var reader = new StreamReader(Request.Body);
    var payload = await reader.ReadToEndAsync();

    if (client.VerifyWebhook(payload, signature))
    {
        var data = client.ParseWebhook(payload);
        
        if (data.Status == "paid")
        {
            // Update your order status
            // data.TradeId, data.MchOrderId, data.Amount, etc.
        }
    }

    return Ok("OK");
}

HTML Components (MVC/Razor)

For ASP.NET MVC or Razor Pages applications, the SDK provides methods to render payment UI components.

Render Payment Button

// In your Razor view
@Html.Raw(client.RenderPaymentButton(new CreateOrderRequest
{
    Currency = "USDT",
    Network = "tron",
    Amount = 100.00m,
    NotifyUrl = "https://your-site.com/webhook",
    RedirectUrl = "https://your-site.com/success"
}, new ButtonOptions
{
    Text = "Pay with Crypto",
    CssClass = "btn btn-primary"
}))

Render Payment Form

// Render a form with currency/network selection
@Html.Raw(client.RenderPaymentForm(new FormOrderRequest
{
    Amount = 100.00m,
    NotifyUrl = "https://your-site.com/webhook",
    RedirectUrl = "https://your-site.com/success"
}, new FormOptions
{
    CssClass = "payment-form",
    SubmitText = "Proceed to Payment"
}))

ASP.NET Core Integration

Dependency Injection

// Program.cs
builder.Services.AddSingleton<PonponPayClient>(sp =>
    new PonponPayClient(new PonponPayConfig
    {
        ApiKey = builder.Configuration["PonponPay:ApiKey"]
    }));

// Or with options pattern
builder.Services.Configure<PonponPayConfig>(
    builder.Configuration.GetSection("PonponPay"));

builder.Services.AddSingleton<PonponPayClient>(sp =>
{
    var config = sp.GetRequiredService<IOptions<PonponPayConfig>>().Value;
    return new PonponPayClient(config);
});

Configuration

// appsettings.json
{
  "PonponPay": {
    "ApiKey": "your_api_key_here"
  }
}

Controller Example

using PonponPay.SDK;
using Microsoft.AspNetCore.Mvc;

public class PaymentController : Controller
{
    private readonly PonponPayClient _ponponpay;

    public PaymentController(PonponPayClient ponponpay)
    {
        _ponponpay = ponponpay;
    }

    [HttpPost]
    public async Task<IActionResult> Create(PaymentRequest request)
    {
        var order = await _ponponpay.CreateOrderAsync(new CreateOrderRequest
        {
            Currency = request.Currency,
            Network = request.Network,
            Amount = request.Amount,
            NotifyUrl = Url.Action("Webhook", "Payment", null, Request.Scheme),
            RedirectUrl = Url.Action("Success", "Payment", null, Request.Scheme)
        });

        return Redirect(order.PaymentUrl);
    }

    [HttpPost]
    public async Task<IActionResult> Webhook()
    {
        var signature = Request.Headers["X-PonponPay-Signature"].FirstOrDefault();
        using var reader = new StreamReader(Request.Body);
        var payload = await reader.ReadToEndAsync();

        if (_ponponpay.VerifyWebhook(payload, signature))
        {
            var data = _ponponpay.ParseWebhook(payload);
            // Update order status...
        }

        return Ok("OK");
    }

    public IActionResult Success()
    {
        return View();
    }
}

Minimal API Example

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddSingleton<PonponPayClient>(sp =>
    new PonponPayClient(new PonponPayConfig
    {
        ApiKey = builder.Configuration["PonponPay:ApiKey"]!
    }));

var app = builder.Build();

app.MapPost("/payment/create", async (
    PaymentRequest request,
    PonponPayClient ponponpay) =>
{
    var order = await ponponpay.CreateOrderAsync(new CreateOrderRequest
    {
        Currency = request.Currency,
        Network = request.Network,
        Amount = request.Amount
    });

    return Results.Redirect(order.PaymentUrl);
});

app.MapPost("/webhook", async (
    HttpContext context,
    PonponPayClient ponponpay) =>
{
    var signature = context.Request.Headers["X-PonponPay-Signature"].FirstOrDefault();
    using var reader = new StreamReader(context.Request.Body);
    var payload = await reader.ReadToEndAsync();

    if (ponponpay.VerifyWebhook(payload, signature))
    {
        var data = ponponpay.ParseWebhook(payload);
        // Process payment...
    }

    return Results.Ok("OK");
});

app.Run();

Error Handling

using PonponPay.SDK.Exceptions;

try
{
    var order = await client.CreateOrderAsync(request);
}
catch (AuthenticationException ex)
{
    // Invalid API Key
    Console.WriteLine($"Authentication failed: {ex.Message}");
}
catch (ValidationException ex)
{
    // Invalid parameters
    Console.WriteLine($"Validation error: {ex.Message}");
}
catch (PonponPayException ex)
{
    // Other API errors
    Console.WriteLine($"Error {ex.Code}: {ex.Message}");
}