Generar un token

API_KEY="your_api_key"
API_SECRET="your_api_secret"
TIMESTAMP=$(( $(date +%s) * 1000 ))
SIGNATURE=$(printf 'timestamp=%s' "$TIMESTAMP" | openssl dgst -sha256 -hmac "$API_SECRET" | sed 's/^.*= //')

curl --request GET \
  --url "https://api-test.velafi.com/v2/token/generate?timestamp=${TIMESTAMP}&signature=${SIGNATURE}" \
  --header "X-BH-APIKEY: ${API_KEY}"

import hashlib
import hmac
import time

import requests

BASE_URL = "https://api-test.velafi.com"
API_KEY = "your_api_key"
API_SECRET = "your_api_secret"


def generate_token():
    timestamp = str(int(time.time() * 1000))
    signature = hmac.new(
        API_SECRET.encode("utf-8"),
        f"timestamp={timestamp}".encode("utf-8"),
        hashlib.sha256,
    ).hexdigest()

    response = requests.get(
        f"{BASE_URL}/v2/token/generate",
        params={"timestamp": timestamp, "signature": signature},
        headers={"X-BH-APIKEY": API_KEY},
        timeout=10,
    )
    body = response.json()
    if body.get("code") != 200:
        raise RuntimeError(f"Token request failed: {body}")
    return body["data"]["token"], int(body["data"]["expireTime"])


token, expire_time_ms = generate_token()
print(token, expire_time_ms)

const crypto = require("crypto");

const BASE_URL = "https://api-test.velafi.com";
const API_KEY = "your_api_key";
const API_SECRET = "your_api_secret";

async function generateToken() {
  const timestamp = Date.now().toString();
  const signature = crypto
    .createHmac("sha256", API_SECRET)
    .update(`timestamp=${timestamp}`)
    .digest("hex");

  const url = `${BASE_URL}/v2/token/generate?timestamp=${timestamp}&signature=${signature}`;
  const response = await fetch(url, { headers: { "X-BH-APIKEY": API_KEY } });
  const body = await response.json();
  if (body.code !== 200) {
    throw new Error(`Token request failed: ${JSON.stringify(body)}`);
  }
  return { token: body.data.token, expireTime: Number(body.data.expireTime) };
}

generateToken().then(({ token, expireTime }) => console.log(token, expireTime));

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 javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

public class GenerateToken {
    private static final String BASE_URL = "https://api-test.velafi.com";
    private static final String API_KEY = "your_api_key";
    private static final String API_SECRET = "your_api_secret";

    public static void main(String[] args) throws Exception {
        String timestamp = String.valueOf(System.currentTimeMillis());
        String signature = hmacSha256Hex(API_SECRET, "timestamp=" + timestamp);

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(BASE_URL + "/v2/token/generate?timestamp=" + timestamp + "&signature=" + signature))
                .header("X-BH-APIKEY", API_KEY)
                .GET()
                .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
                .send(request, HttpResponse.BodyHandlers.ofString());
        // Si es exitosa: {"code":200,"msg":"SUCCESS","data":{"token":"...","expireTime":"..."}}
        System.out.println(response.body());
    }

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