class API {
	var $url = 'https://bitloga.com/api/v1/';
	var $apiKey;
	var $apiSecret;

	function __construct($apiKey, $apiSecret) {
		$this->apiKey = $apiKey;
		$this->apiSecret = $apiSecret;
	}

	function API($apiKey, $apiSecret) {
		$this->__construct($apiKey, $apiSecret);
	}

	function SendRequest($params, $addtourl = '') {
		$dataJson = json_encode($params, JSON_UNESCAPED_SLASHES);
		$signature = hash_hmac('sha512', $dataJson, $this->apiSecret);
		if($addtourl) $addtourl .= '/';
		$ch = curl_init($this->url.$addtourl);
		$headers = [
			'Content-type: application/json',
			'X-APIKEY:'.$this->apiKey,
			'X-SIGNATURE:'.$signature
		];
		curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
		curl_setopt($ch, CURLOPT_POST, true);
		if($dataJson) curl_setopt($ch, CURLOPT_POSTFIELDS, $dataJson);
		curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
		curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 0);
		curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
		$res = curl_exec($ch);
		curl_close($ch);   
		return json_decode($res, true);
	}

	function balances($currency='') {
		$params = array();
		$params['action'] = 'balances';
		if($currency) $params['currency'] = $currency;
		return $this->SendRequest($params);
	}

	function invoice($uniqueid, $paysys, $amount, $purse='', $paylist='', $comis='', $dtag='', $name='', $surname='', $desc='', $callback='', $success='', $fail='') {
		$params = array();
		$params['action'] = 'invoice';
		$params['uniqueid'] = $uniqueid;
		$params['paysys'] = $paysys;
		$params['amount'] = $amount;
		if($purse) $params['purse'] = $purse;
		if($paylist) $params['paylist'] = $paylist;
		if($comis) $params['comis'] = $comis;
		if($dtag) $params['dtag'] = $dtag;
		if($name) $params['name'] = $name;
		if($surname) $params['surname'] = $surname;
		if($desc) $params['desc'] = $desc;
		if($callback) $params['callbackurl'] = $callback;
		if($success) $params['successurl'] = $success;
		if($fail) $params['failurl'] = $fail;
		return $this->SendRequest($params);
	}

	function withdraw($uniqueid, $currency, $paysys, $amount, $purse, $dtag='', $name='', $surname='') {
		$params = array();
		$params['action'] = 'withdraw';
		$params['uniqueid'] = $uniqueid;
		$params['currency'] = $currency;
		$params['paysys'] = $paysys;
		$params['amount'] = $amount;
		$params['purse'] = $purse;
		if($dtag) $params['dtag'] = $dtag;
		if($name) $params['name'] = $name;
		if($surname) $params['surname'] = $surname;
		return $this->SendRequest($params);
	}

	function details($uniqueid) {
		$params = array();
		$params['action'] = 'details';
		$params['uniqueid'] = $uniqueid;
		return $this->SendRequest($params);
	}
	
	function createCode($amount, $currency, $pass='', $desc='') {
		$params = array();
		$params['action'] = 'create';
		$params['amount'] = $amount;
		$params['currency'] = $currency;
		if($pass) $params['pass'] = $pass;
		if($desc) $params['desc'] = $desc;
		return $this->SendRequest($params, 'code');
	}
	
	function getCode($code='', $amount='', $currency='', $status='', $offset='', $limit='') {
		$params = array();
		$params['action'] = 'get';
		if($code) $params['code'] = $code;
		if($amount) $params['amount'] = $amount;
		if($currency) $params['currency'] = $currency;
		if($status) $params['status'] = $status;
		if($offset) $params['offset'] = $offset;
		if($limit) $params['limit'] = $limit;
		return $this->SendRequest($params, 'code');
	}
	
	function applyCode($code, $pass='') {
		$params = array();
		$params['action'] = 'apply';
		$params['code'] = $code;
		if($pass) $params['pass'] = $pass;
		return $this->SendRequest($params, 'code');
	}
	
}

$apiKey = 'your api key'; // Enter your API key
$apiSecret = 'your secret key'; // Enter your Secret Key

$api = new API($apiKey, $apiSecret);

// Receiving balances
$responce = $api->balances('USD');
var_dump($responce);

// Creating an invoice
$responce = $api->invoice('125', 'WMZ', 1.00, 'Z123456789012');
var_dump($responce);

// Withdraw
$responce = $api->withdraw('135', 'USD', 'WMZ', 10.00, 'Z123456789012');
var_dump($responce);

// Transaction details
$responce = $api->details('125');
var_dump($responce);

// Code creation
$responce = $api->create(1.00, 'USD', 'mypassword', 'Описание кода');
var_dump($responce);

// Receiving codes
$responce = $api->get();
var_dump($responce);

// Code activation
$responce = $api->apply('wf9g-amrf-2o9t-831u', 'mypassword');
var_dump($responce);

$apiKey = 'your api key'; // Enter your API key
$apiSecret = 'your secret key'; // Enter your Secret Key

// Parameters preparation
// In this example we get the balance of the USD account
$params = array();
$params['action'] = 'balances';
$params['currency'] = 'USD';

$dataJson = json_encode($params, JSON_UNESCAPED_SLASHES);
$signature = hash_hmac('sha512', $dataJson, $apiSecret);

// Headers preparation
$headers = [
	'Content-type: application/json',
	'X-APIKEY:'.$apiKey,
	'X-SIGNATURE:'.$signature
];

// Sending request
$ch = curl_init('https://bitloga.com/api/v1/');
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $dataJson);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
$res = curl_exec($ch);
curl_close($ch);   

// Response processing
$arrayRes = json_decode($res);
var_dump($arrayRes);

$apiSecret = 'your secret key'; // Enter your Secret Key

$rawjson = file_get_contents('php://input'); // Receive JSON data, it contains all information about the transaction
$headers = getallheaders(); // Receive headers, they contain a signature.

// Form a signature with your key and verify it
$sign = hash_hmac('sha512', $rawjson, $apiSecret);
if(!hash_equals($sign, $headers['X-SIGNATURE'])) exit('Signature Error');

// Transferring data to an array
$data = json_decode($rawjson, true);
var_dump($data);

let crypto = require('crypto');
let https = require('https');

let apiKey = ''; // Enter your API key
let apiSecret = ''; // Enter your Secret Key

// Parameters preparation
// In this example we get the balance of the USD account
let data = {
	action: "balances",
	currency: "USD"
}

let dataJsonStr = JSON.stringify(data);
let hash = crypto.createHmac('sha512', apiSecret);
let signature = hash.update(dataJsonStr).digest('hex');

let options = {
	hostname: 'https://bitloga.com',
	path: '/api/v1/',
	method: 'POST',
	headers: {
		'Content-Type': 'application/json',
		'X-APIKEY': apiKey,
		'X-SIGNATURE': signature
	}
}

const req = https.request(options, res => {
	res.setEncoding('utf8')

	console.log(`statusCode: ${res.statusCode}`)

	let responseBody = '';

	res.on('data', chunk => {
		responseBody += chunk;
	});

	res.on('end', () => {
		if (res.statusCode !== 200) {
			console.error("Api call failed with response code", res.statusCode);
		}

		console.log('Body:', responseBody);
	});
})

req.on('error', error => {
	console.error("Request error", error);
})

req.write(dataJsonStr);

req.end();

import json
import base64
import requests
import hmac
import hashlib

api_key = '' #Enter your API key
secret_key = '' #Enter your Secret Key

#Parameters preparation
#In this example we get the balance of the USD account
data = {
	'action': 'balances',
	'currency': USD
}

data_json = json.dumps(data, separators=(',', ':'))
signature = hmac.new(secret_key.encode('ascii'), data_json.encode('ascii'), hashlib.sha512).hexdigest()

#Headers preparation
headers = {
	'Content-type': 'application/json',
	'X-APIKEY': api_key,
	'X-SIGNATURE': signature,
}

#Sending request
resp = requests.post('https://bitloga.com/api/v1/', headers=headers, data=data_json)

#Response processing
print(json.dumps(resp.json(), sort_keys=True, indent=4))

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.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;
import java.util.Formatter;

public class TradeAccountBalanceJava {
	private static final String API_KEY = ""; // Enter your API key
	private static final String API_SECRET = ""; // Enter your Secret Key

	public static void main(String[] args) throws Exception {

		// Parameters preparation
		// In this example we get the balance of the USD account
		String dataJson = String.format("{\"action\":\"%1$s\",\"currency\":\"%2$s\"}",
			"balances",
			"USD"

		String signature = calcSignature(dataJson.getBytes());

		HttpClient client = HttpClient.newHttpClient();
		HttpRequest request = HttpRequest.newBuilder()
			.uri(URI.create("https://bitloga.com/api/v1/"))
			.header("Content-type", "application/json")
			.header("X-APIKEY", API_KEY)
			.header("X-SIGNATURE", signature)
			.POST(HttpRequest.BodyPublishers.ofString(dataJson))
			.build();

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

	private static String calcSignature(String data)
	throws NoSuchAlgorithmException, InvalidKeyException {

		final String HMAC_SHA512 = "HmacSHA512";
		SecretKeySpec secretKeySpec = new SecretKeySpec(API_SECRET.getBytes(), HMAC_SHA512);
		Mac mac = Mac.getInstance(HMAC_SHA512);
		mac.init(secretKeySpec);

		byte[] bytes = mac.doFinal(data.getBytes());
		Formatter formatter = new Formatter();
		for (byte b : bytes) {
			formatter.format("%02x", b);
		}

		return formatter.toString();
	}
}

using Newtonsoft.Json;
using System;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

namespace TradeAccountBalance
{
	internal class Payload
	{
		[JsonProperty("action")]
		public string Action { get; set; }

		[JsonProperty("currency")]
		public string Currency { get; set; }
	}

	internal static class Program
	{
		private static readonly HttpClient _httpClient = new HttpClient();

		private static async Task Main()
		{
			var apiKey = ""; // Enter your API key
			var apiSecret = ""; // Enter your Secret Key

			// Parameters preparation
			// In this example we get the balance of the USD account
			var data = new Payload
			{
				Action = "balances",
				Currency = "USD"
			};

			var dataJsonStr = JsonConvert.SerializeObject(data);
			var signature = CalcSignature(dataJsonStr, apiSecret);

			var content = new StringContent(dataJsonStr, Encoding.UTF8, "application/json");
			var requestMessage = new HttpRequestMessage(HttpMethod.Post, $"https://bitloga.com/api/v1/")
			{
				Content = content
			};
			requestMessage.Headers.Add("X-TXC-APIKEY", apiKey);
			requestMessage.Headers.Add("X-TXC-SIGNATURE", signature);

			var response = await _httpClient.SendAsync(requestMessage);
			var responseBody = await response.Content.ReadAsStringAsync();

			Console.WriteLine(responseBody);
		}

		public static string CalcSignature(string text, string apiSecret)
		{
			using (var hmac = new HMACSHA512(Encoding.UTF8.GetBytes(apiSecret)))
			{
				var hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(text));
				return BitConverter.ToString(hash).Replace("-", string.Empty).ToLower();
			}
		}
	}
}

package main

import (
	"bytes"
	"crypto/hmac"
	"crypto/sha512"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"strconv"
)

type apiHelper struct {
	PublicKey string
	SecretKey string
}

func (api *apiHelper) SendRequest(data map[string]string) (responseBody []byte, err error) {

	requestBody, err := json.Marshal(data)
	if err != nil {
		return
	}

	h := hmac.New(sha512.New, []byte(api.SecretKey))
	h.Write([]byte(requestBody))
	signature := fmt.Sprintf("%x", h.Sum(nil))

	client := http.Client{}

	request, err := http.NewRequest("POST", "https://bitloga.com/api/v1/", bytes.NewBuffer(requestBody))
	if err != nil {
		log.Fatal(err)
	}

	// Headers preparation
	request.Header.Set("Content-type", "application/json")
	request.Header.Set("X-APIKEY", api.PublicKey)
	request.Header.Set("X-SIGNATURE", signature)

	// Sending request
	response, err := client.Do(request)
	if err != nil {
		return
	}
	defer response.Body.Close()

	// Response processing
	responseBody, err = ioutil.ReadAll(response.Body)

	return
}

func main() {
	provider := apiHelper{
		PublicKey: "", // Enter your API key
		SecretKey: "", // Enter your Secret Key
	}

	// Parameters preparation
	// In this example we get the balance of the USD account
	data := map[string]string{
		"action": "balances",
		"currency": "USD",
	}

	resultData, err := provider.SendRequest(data)
	if err != nil {
		log.Fatal(err)
	}

	var result interface{}
	if err := json.Unmarshal(resultData, &result); err != nil {
		log.Fatal(err)
	}

	log.Println(result)
}

require 'json'
require 'openssl'
require 'net/http'

api_key = '' #Enter your API key
api_secret = '' #Enter your Secret Key

#Parameters preparation
#In this example we get the balance of the USD account
data = {
	'action': 'balances',
	'currency': 'USD'
}

data_json_str = data.to_json
signature = OpenSSL::HMAC.hexdigest('SHA512', api_secret, data_json_str)

#Headers preparation
header = {
	'Content-Type': 'application/json',
	'X-APIKEY': api_key,
	'X-SIGNATURE': signature
}

#Sending request
uri = URI.parse('https://bitloga.com/api/v1/')
request_data = Net::HTTP::Post.new(uri.request_uri, header)
request_data.body = data_json_str
response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |http| http.request(request_data) }

#Response processing
puts response.code
puts response.message
puts response.body