DGATEWAY_API_KEY=dgw_test_xxxxxxxxxxxxxxxxxxxx

POST /v1/payments/collect
Host: dgatewayapi.desispay.com
Content-Type: application/json
X-Api-Key: dgw_test_xxxxxxxxxxxxxxxxxxxx

{
  "amount": 5000,
  "currency": "UGX",
  "phone_number": "256111777111",
  "provider": "iotec",
  "description": "Sandbox test payment",
  "metadata": { "order_id": "test-order-1" }
}

// Response — status is always "pending" at first, even in sandbox
{
  "data": {
    "reference": "dgw_a1b2c3d4e5f6",
    "provider": "iotec",
    "provider_ref": "iotec-sandbox-...",
    "status": "pending",
    "amount": 5000,
    "currency": "UGX",
    "phone_number": "256111777111"
  },
  "message": "Collection initiated"
}

GET /v1/payments/transactions/dgw_a1b2c3d4e5f6
X-Api-Key: dgw_test_xxxxxxxxxxxxxxxxxxxx

{
  "data": {
    "reference": "dgw_a1b2c3d4e5f6",
    "status": "completed",
    "amount": 5000,
    "currency": "UGX",
    "failure_reason": ""
  },
  "message": "Transaction retrieved"
}

// test-payment.js
const API_URL = "https://dgatewayapi.desispay.com";
const API_KEY = process.env.DGATEWAY_API_KEY;

if (!API_KEY?.startsWith("dgw_test_")) {
  throw new Error("Set DGATEWAY_API_KEY to a dgw_test_ key before running this script");
}

async function collect() {
  const res = await fetch(`${API_URL}/v1/payments/collect`, {
    method: "POST",
    headers: { "Content-Type": "application/json", "X-Api-Key": API_KEY },
    body: JSON.stringify({
      amount: 5000,
      currency: "UGX",
      phone_number: "256111777111", // always succeeds in sandbox
      provider: "iotec",
      description: "Sandbox test payment",
    }),
  });
  const { data, error } = await res.json();
  if (!res.ok) throw new Error(error?.message ?? "Collect request failed");
  return data;
}

async function pollUntilSettled(reference, { intervalMs = 2000, timeoutMs = 30000 } = {}) {
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    const res = await fetch(`${API_URL}/v1/payments/transactions/${reference}`, {
      headers: { "X-Api-Key": API_KEY },
    });
    const { data } = await res.json();
    if (data.status !== "pending") return data;
    await new Promise((r) => setTimeout(r, intervalMs));
  }
  throw new Error(`Timed out waiting for ${reference} to settle`);
}

const txn = await collect();
console.log("Created:", txn.reference, "status:", txn.status);

const result = await pollUntilSettled(txn.reference);
console.log("Final status:", result.status);
if (result.status === "completed") {
  console.log("✅ Sandbox payment succeeded — amount:", result.amount, result.currency);
} else {
  console.log("❌ Sandbox payment failed:", result.failure_reason);
}

DGATEWAY_API_URL=https://dgatewayapi.desispay.com
DGATEWAY_API_KEY=dgw_test_xxxxxxxxxxxxxxxxxxxx

// lib/dgateway.ts — server-side only, never import this in a client component
const API_URL = process.env.DGATEWAY_API_URL!;
const API_KEY = process.env.DGATEWAY_API_KEY!;

export async function collectPayment(params: {
  amount: number;
  currency: string;
  phone_number: string;
  provider?: string;
  description?: string;
}) {
  const res = await fetch(`${API_URL}/v1/payments/collect`, {
    method: "POST",
    headers: { "Content-Type": "application/json", "X-Api-Key": API_KEY },
    body: JSON.stringify(params),
  });
  return res.json();
}

export async function getTransaction(reference: string) {
  const res = await fetch(`${API_URL}/v1/payments/transactions/${reference}`, {
    headers: { "X-Api-Key": API_KEY },
  });
  return res.json();
}

import { NextResponse } from "next/server";
import { collectPayment } from "@/lib/dgateway";

export async function POST() {
  const result = await collectPayment({
    amount: 5000,
    currency: "UGX",
    phone_number: "256111777111", // always succeeds in sandbox
    provider: "iotec",
    description: "Sandbox test payment",
  });
  if (result.error) return NextResponse.json(result, { status: 400 });
  return NextResponse.json(result);
}

import { NextRequest, NextResponse } from "next/server";
import { getTransaction } from "@/lib/dgateway";

export async function GET(
  _req: NextRequest,
  { params }: { params: Promise<{ reference: string }> },
) {
  const { reference } = await params;
  const result = await getTransaction(reference);
  return NextResponse.json(result);
}

"use client";
import { useState } from "react";

export function SandboxPayButton() {
  const [status, setStatus] = useState<string>("idle");

  async function runTestPayment() {
    setStatus("creating");
    const createRes = await fetch("/api/sandbox-payment", { method: "POST" });
    const { data } = await createRes.json();

    setStatus("pending");
    const deadline = Date.now() + 30_000;
    while (Date.now() < deadline) {
      const pollRes = await fetch(`/api/sandbox-payment/${data.reference}`);
      const { data: txn } = await pollRes.json();
      if (txn.status !== "pending") {
        setStatus(txn.status); // "completed" or "failed"
        return;
      }
      await new Promise((r) => setTimeout(r, 2000));
    }
    setStatus("timeout");
  }

  return (
    <button onClick={runTestPayment}>
      Run sandbox payment ({status})
    </button>
  );
}

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"time"
)

const apiURL = "https://dgatewayapi.desispay.com"

type txnResult struct {
	Data struct {
		Reference     string  `json:"reference"`
		Status        string  `json:"status"`
		Amount        float64 `json:"amount"`
		Currency      string  `json:"currency"`
		FailureReason string  `json:"failure_reason"`
	} `json:"data"`
	Error *struct {
		Message string `json:"message"`
	} `json:"error"`
}

func apiKey() string {
	key := os.Getenv("DGATEWAY_API_KEY")
	if key == "" {
		panic("set DGATEWAY_API_KEY to a dgw_test_ key before running this")
	}
	return key
}

func doRequest(method, path string, body interface{}) (*txnResult, error) {
	var reqBody *bytes.Reader
	if body != nil {
		b, _ := json.Marshal(body)
		reqBody = bytes.NewReader(b)
	} else {
		reqBody = bytes.NewReader(nil)
	}
	req, _ := http.NewRequest(method, apiURL+path, reqBody)
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-Api-Key", apiKey())

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	var out txnResult
	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
		return nil, err
	}
	if out.Error != nil {
		return nil, fmt.Errorf("%s", out.Error.Message)
	}
	return &out, nil
}

func collect() (*txnResult, error) {
	return doRequest("POST", "/v1/payments/collect", map[string]interface{}{
		"amount":       5000,
		"currency":     "UGX",
		"phone_number": "256111777111", // always succeeds in sandbox
		"provider":     "iotec",
		"description":  "Sandbox test payment",
	})
}

func pollUntilSettled(reference string) (*txnResult, error) {
	deadline := time.Now().Add(30 * time.Second)
	for time.Now().Before(deadline) {
		result, err := doRequest("GET", "/v1/payments/transactions/"+reference, nil)
		if err != nil {
			return nil, err
		}
		if result.Data.Status != "pending" {
			return result, nil
		}
		time.Sleep(2 * time.Second)
	}
	return nil, fmt.Errorf("timed out waiting for %s to settle", reference)
}

func main() {
	txn, err := collect()
	if err != nil {
		panic(err)
	}
	fmt.Println("Created:", txn.Data.Reference, "status:", txn.Data.Status)

	result, err := pollUntilSettled(txn.Data.Reference)
	if err != nil {
		panic(err)
	}
	if result.Data.Status == "completed" {
		fmt.Printf("✅ Sandbox payment succeeded — amount: %.0f %s\n", result.Data.Amount, result.Data.Currency)
	} else {
		fmt.Println("❌ Sandbox payment failed:", result.Data.FailureReason)
	}
}

<?php
// test-payment.php
$apiUrl = "https://dgatewayapi.desispay.com";
$apiKey = getenv("DGATEWAY_API_KEY");

if (!$apiKey || !str_starts_with($apiKey, "dgw_test_")) {
    fwrite(STDERR, "Set DGATEWAY_API_KEY to a dgw_test_ key before running this script\n");
    exit(1);
}

function dgatewayRequest(string $method, string $path, ?array $body = null): array
{
    global $apiUrl, $apiKey;
    $ch = curl_init($apiUrl . $path);
    $headers = ["X-Api-Key: $apiKey", "Content-Type: application/json"];
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_CUSTOMREQUEST  => $method,
        CURLOPT_HTTPHEADER     => $headers,
    ]);
    if ($body !== null) {
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($body));
    }
    $response = curl_exec($ch);
    curl_close($ch);
    return json_decode($response, true);
}

function collectPayment(): array
{
    $result = dgatewayRequest("POST", "/v1/payments/collect", [
        "amount"       => 5000,
        "currency"     => "UGX",
        "phone_number" => "256111777111", // always succeeds in sandbox
        "provider"     => "iotec",
        "description"  => "Sandbox test payment",
    ]);
    if (isset($result["error"])) {
        throw new Exception($result["error"]["message"]);
    }
    return $result["data"];
}

function pollUntilSettled(string $reference, int $timeoutSeconds = 30): array
{
    $deadline = time() + $timeoutSeconds;
    while (time() < $deadline) {
        $result = dgatewayRequest("GET", "/v1/payments/transactions/$reference");
        $data = $result["data"];
        if ($data["status"] !== "pending") {
            return $data;
        }
        sleep(2);
    }
    throw new Exception("Timed out waiting for $reference to settle");
}

$txn = collectPayment();
echo "Created: {$txn['reference']} status: {$txn['status']}\n";

$result = pollUntilSettled($txn["reference"]);
if ($result["status"] === "completed") {
    echo "✅ Sandbox payment succeeded — amount: {$result['amount']} {$result['currency']}\n";
} else {
    echo "❌ Sandbox payment failed: {$result['failure_reason']}\n";
}

DGATEWAY_API_URL=https://dgatewayapi.desispay.com
DGATEWAY_API_KEY=dgw_test_xxxxxxxxxxxxxxxxxxxx

<?php
// Add to the 'services' array in config/services.php
'dgateway' => [
    'url' => env('DGATEWAY_API_URL', 'https://dgatewayapi.desispay.com'),
    'key' => env('DGATEWAY_API_KEY'),
],

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\Http;

class TestDGatewayPayment extends Command
{
    protected $signature = 'dgateway:test-payment';
    protected $description = 'Run one sandbox payment against DGateway and print the result';

    public function handle(): int
    {
        $key = config('services.dgateway.key');
        if (!$key || !str_starts_with($key, 'dgw_test_')) {
            $this->error('Set DGATEWAY_API_KEY to a dgw_test_ key in your .env first.');
            return self::FAILURE;
        }

        $created = $this->collect();
        $this->info("Created: {$created['reference']} status: {$created['status']}");

        $result = $this->pollUntilSettled($created['reference']);

        if ($result['status'] === 'completed') {
            $this->info("✅ Sandbox payment succeeded — amount: {$result['amount']} {$result['currency']}");
        } else {
            $this->error("❌ Sandbox payment failed: {$result['failure_reason']}");
        }

        return self::SUCCESS;
    }

    private function collect(): array
    {
        $response = Http::withHeaders([
            'X-Api-Key' => config('services.dgateway.key'),
        ])->post(config('services.dgateway.url') . '/v1/payments/collect', [
            'amount'       => 5000,
            'currency'     => 'UGX',
            'phone_number' => '256111777111', // always succeeds in sandbox
            'provider'     => 'iotec',
            'description'  => 'Sandbox test payment',
        ]);

        if ($response->failed()) {
            throw new \Exception($response->json('error.message') ?? 'Collect request failed');
        }

        return $response->json('data');
    }

    private function pollUntilSettled(string $reference, int $timeoutSeconds = 30): array
    {
        $deadline = now()->addSeconds($timeoutSeconds);

        while (now()->lessThan($deadline)) {
            $response = Http::withHeaders([
                'X-Api-Key' => config('services.dgateway.key'),
            ])->get(config('services.dgateway.url') . "/v1/payments/transactions/{$reference}");

            $data = $response->json('data');
            if ($data['status'] !== 'pending') {
                return $data;
            }

            sleep(2);
        }

        throw new \Exception("Timed out waiting for {$reference} to settle");
    }
}