Documentação da API

<?php
final class LisansXClient
{
    public function __construct(
        private string $baseUrl,
        private string $apiKey,
        private string $apiSecret
    ) { $this->baseUrl = rtrim($baseUrl, '/'); }

    public function request(string $method, string $path, ?array $body = null): array
    {
        $method  = strtoupper($method);
        $bodyRaw = $body !== null ? json_encode($body, JSON_UNESCAPED_UNICODE) : '';
        $ts      = (string)time();

        // Chave de assinatura = digest hex SHA-256 do secret bruto
        $signingKey = hash('sha256', $this->apiSecret);
        $signature  = hash_hmac('sha256', $ts . "\n" . $method . "\n" . $path . "\n" . $bodyRaw, $signingKey);

        $ch = curl_init($this->baseUrl . $path);
        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_CUSTOMREQUEST  => $method,
            CURLOPT_TIMEOUT        => 30,
            CURLOPT_HTTPHEADER     => [
                'X-Api-Key: '   . $this->apiKey,
                'X-Timestamp: ' . $ts,
                'X-Signature: ' . $signature,
                'Content-Type: application/json',
            ],
        ]);
        if ($body !== null) curl_setopt($ch, CURLOPT_POSTFIELDS, $bodyRaw);

        $raw = curl_exec($ch);
        return json_decode((string)$raw, true) ?: ['success' => false, 'error' => 'invalid_response'];
    }
}

// --- Uso ---
$api = new LisansXClient('https://lisansx.net', 'SUA_CHAVE_DE_API', getenv('LISANSX_SECRET'));

$products = $api->request('GET', '/api/v1/products');
$order    = $api->request('POST', '/api/v1/order', ['product_id' => 1, 'qty' => 1]);

if (!empty($order['success'])) {
    foreach ($order['data']['codes'] as $code) {
        echo "Teslim edilen kod: $code\n";
    }
} else {
    error_log('LisansX hatasi: ' . ($order['message'] ?? 'bilinmiyor'));
}

import crypto from 'node:crypto';

export class LisansXClient {
  constructor(baseUrl, apiKey, apiSecret) {
    this.baseUrl = baseUrl.replace(/\/+$/, '');
    this.apiKey = apiKey;
    this.apiSecret = apiSecret;
  }

  async request(method, path, body = null) {
    method = method.toUpperCase();
    const bodyRaw = body ? JSON.stringify(body) : '';
    const ts = Math.floor(Date.now() / 1000).toString();

    // Chave de assinatura = digest hex SHA-256 do secret bruto
    const signingKey = crypto.createHash('sha256').update(this.apiSecret).digest('hex');
    const signature = crypto
      .createHmac('sha256', signingKey)
      .update(ts + '\n' + method + '\n' + path + '\n' + bodyRaw)
      .digest('hex');

    const res = await fetch(this.baseUrl + path, {
      method,
      headers: {
        'X-Api-Key': this.apiKey,
        'X-Timestamp': ts,
        'X-Signature': signature,
        'Content-Type': 'application/json',
      },
      body: body ? bodyRaw : undefined,
    });
    return res.json();
  }

  products()            { return this.request('GET',  '/api/v1/products'); }
  balance()             { return this.request('GET',  '/api/v1/balance'); }
  order(productId, qty) { return this.request('POST', '/api/v1/order', { product_id: productId, qty }); }
  orderStatus(orderNo)  { return this.request('GET',  '/api/v1/order/' + encodeURIComponent(orderNo)); }
}

// --- Uso ---
const api = new LisansXClient('https://lisansx.net', 'SUA_CHAVE_DE_API', process.env.LISANSX_SECRET);

const order = await api.order(1, 1);
if (order.success) {
  order.data.codes.forEach((code) => console.log('Teslim edilen kod:', code));
} else {
  console.error('LisansX hatasi:', order.message);
}

# services/lisansx.py  —  Django veya saf Python (requests gerekir)
import hashlib
import hmac
import json
import time

import requests


class LisansXClient:
    def __init__(self, base_url: str, api_key: str, api_secret: str):
        self.base_url = base_url.rstrip("/")
        self.api_key = api_key
        self.api_secret = api_secret

    def request(self, method: str, path: str, body: dict | None = None) -> dict:
        method = method.upper()
        # Serializamos o corpo UMA VEZ e usamos a mesma string tanto na assinatura quanto na requisição
        body_raw = json.dumps(body, ensure_ascii=False, separators=(",", ":")) if body else ""
        ts = str(int(time.time()))

        # Chave de assinatura = digest hex SHA-256 do secret bruto
        signing_key = hashlib.sha256(self.api_secret.encode()).hexdigest()
        base = f"{ts}\n{method}\n{path}\n{body_raw}"
        signature = hmac.new(signing_key.encode(), base.encode(), hashlib.sha256).hexdigest()

        response = requests.request(
            method,
            self.base_url + path,
            headers={
                "X-Api-Key": self.api_key,
                "X-Timestamp": ts,
                "X-Signature": signature,
                "Content-Type": "application/json",
            },
            data=body_raw.encode() if body else None,
            timeout=30,
        )
        return response.json()

    def products(self):         return self.request("GET",  "/api/v1/products")
    def balance(self):          return self.request("GET",  "/api/v1/balance")
    def order(self, pid, qty):  return self.request("POST", "/api/v1/order", {"product_id": pid, "qty": qty})
    def order_status(self, no): return self.request("GET",  f"/api/v1/order/{no}")


# --- Django settings.py ---
# LISANSX_BASE   = "https://lisansx.net"
# LISANSX_KEY    = "SUA_CHAVE_DE_API"
# LISANSX_SECRET = os.environ["LISANSX_SECRET"]

# --- Django views.py ---
# from django.conf import settings
# from django.http import JsonResponse
#
# def buy(request):
#     api = LisansXClient(settings.LISANSX_BASE, settings.LISANSX_KEY, settings.LISANSX_SECRET)
#     result = api.order(pid=1, qty=1)
#     if result.get("success"):
#         codes = result["data"]["codes"]   # salve os códigos no pedido
#     return JsonResponse(result)