Authentication

import crypto from 'crypto';
import fetch from 'node-fetch';

const API_KEY = 'YOUR_API_KEY';
const API_SECRET = 'YOUR_API_SECRET';

async function signAndRequest() {
  const method = 'POST';
  const host = 'ramp.hexarails.ai'; // or ramp-sandbox.hexarails.ai
  const path = '/payment/estimate';
  const query = ''; // e.g. 'currency=USDT&network=TRX'

  const bodyObject = {
    // your request body here
  };
  const body = JSON.stringify(bodyObject);

  const timestamp = Math.floor(Date.now() / 1000).toString();
  const nonce = crypto.randomUUID();

  const bodyHash = crypto.createHash('sha256').update(body).digest('hex');

  const canonical = [
    method.toUpperCase(),
    host,
    path,
    query,
    bodyHash,
    timestamp,
    nonce,
  ].join('\n');

  const signature = crypto
    .createHmac('sha256', API_SECRET)
    .update(canonical)
    .digest('hex');

  const url = `https://${host}${path}${query ? '?' + query : ''}`;

  const res = await fetch(url, {
    method,
    headers: {
      'Content-Type': 'application/json',
      'X-API-Key': API_KEY,
      'X-Timestamp': timestamp,
      'X-Nonce': nonce,
      'X-Signature': signature,
    },
    body,
  });

  const data = await res.json();
  console.log(data);
}

signAndRequest().catch(console.error);

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.time.Instant;
import java.util.UUID;

public class CoinutSignatureExample {

    private static String sha256Hex(String data) throws Exception {
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] hash = digest.digest(data.getBytes(StandardCharsets.UTF_8));
        StringBuilder sb = new StringBuilder();
        for (byte b : hash) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }

    private static String hmacSha256Hex(String secret, String data) throws Exception {
        Mac mac = Mac.getInstance("HmacSHA256");
        SecretKeySpec keySpec = new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), "HmacSHA256");
        mac.init(keySpec);
        byte[] result = mac.doFinal(data.getBytes(StandardCharsets.UTF_8));
        StringBuilder sb = new StringBuilder();
        for (byte b : result) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }

    public static void main(String[] args) throws Exception {
        String apiKey = "YOUR_API_KEY";
        String apiSecret = "YOUR_API_SECRET";

        String method = "POST";
        String host = "ramp.hexarails.ai";
        String path = "/payment/estimate";
        String query = "";

        String body = "{\"amount\":100}";

        String timestamp = String.valueOf(Instant.now().getEpochSecond());
        String nonce = UUID.randomUUID().toString();

        String bodyHash = body.isEmpty() ? "" : sha256Hex(body);

        String canonical = String.join("\n",
                method.toUpperCase(),
                host,
                path,
                query,
                bodyHash,
                timestamp,
                nonce
        );

        String signature = hmacSha256Hex(apiSecret, canonical);

        String url = "https://" + host + path + (query.isEmpty() ? "" : "?" + query);

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Content-Type", "application/json")
                .header("X-API-Key", apiKey)
                .header("X-Timestamp", timestamp)
                .header("X-Nonce", nonce)
                .header("X-Signature", signature)
                .method(method, HttpRequest.BodyPublishers.ofString(body))
                .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}

import time
import uuid
import hmac
import hashlib
import json
import requests

API_KEY = "YOUR_API_KEY"
API_SECRET = "YOUR_API_SECRET"


def sha256_hex(data: str) -> str:
    return hashlib.sha256(data.encode("utf-8")).hexdigest()


def hmac_sha256_hex(secret: str, data: str) -> str:
    return hmac.new(
        secret.encode("utf-8"),
        data.encode("utf-8"),
        hashlib.sha256,
    ).hexdigest()


def main():
    method = "POST"
    host = "ramp.hexarails.ai"  # or ramp-sandbox.hexarails.ai
    path = "/payment/estimate"
    query = ""  # e.g. "currency=USDT&network=TRX"

    body_obj = {
        # your request body here
    }
    body = json.dumps(body_obj, separators=(",", ":"))

    timestamp = str(int(time.time()))
    nonce = str(uuid.uuid4())

    body_hash = sha256_hex(body) if body else ""

    canonical = "\n".join(
        [
            method.upper(),
            host,
            path,
            query,
            body_hash,
            timestamp,
            nonce,
        ]
    )

    signature = hmac_sha256_hex(API_SECRET, canonical)

    url = f"https://{host}{path}"
    if query:
        url += f"?{query}"

    headers = {
        "Content-Type": "application/json",
        "X-API-Key": API_KEY,
        "X-Timestamp": timestamp,
        "X-Nonce": nonce,
        "X-Signature": signature,
    }

    resp = requests.post(url, headers=headers, data=body)
    print(resp.status_code)
    print(resp.text)


if __name__ == "__main__":
    main()